Series comparison

-[Qemu-devel] [PULL 00/12] Block patches
+[PULL 00/23] Block patches
-The following changes since commit 9964e96dc9999cf7f7c936ee854a795415d19b60:
+The following changes since commit 9d662a6b22a0838a85c5432385f35db2488a33a5:
-  Merge remote-tracking branch 'jasowang/tags/net-pull-request' into staging (2017-05-23 15:01:31 +0100)
+  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:
+are available in the Git repository at:
-  git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request
+  https://gitlab.com/hreitz/qemu.git tags/pull-block-2022-03-07
-for you to fetch changes up to 223a23c198787328ae75bc65d84edf5fde33c0b6:
+for you to fetch changes up to 743da0b401cdc3ee94bc519975e339a3cdbe0ad1:
-  block/gluster: glfs_lseek() workaround (2017-05-24 16:44:46 -0400)
+  iotests/image-fleecing: test push backup with fleecing (2022-03-07 09:33:31 +0100)
 ----------------------------------------------------------------
-Block patches
+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
-Jeff Cody (1):
+Peter Maydell (2):
-  block/gluster: glfs_lseek() workaround
+  block/curl.c: Set error message string if curl_init_state() fails
   block/curl.c: Check error return from curl_easy_setopt()
-Paolo Bonzini (11):
+Thomas Huth (2):
-  blockjob: remove unnecessary check
+  tests/qemu-iotests/040: Skip TestCommitWithFilters without 'throttle'
-  blockjob: remove iostatus_reset callback
+  tests/qemu-iotests/testrunner: Quote "case not run" lines in TAP mode
   blockjob: introduce block_job_early_fail
   blockjob: introduce block_job_pause/resume_all
   blockjob: separate monitor and blockjob APIs
   blockjob: move iostatus reset inside block_job_user_resume
   blockjob: introduce block_job_cancel_async, check iostatus invariants
   blockjob: group BlockJob transaction functions together
   blockjob: strengthen a bit test-blockjob-txn
   blockjob: reorganize block_job_completed_txn_abort
   blockjob: use deferred_to_main_loop to indicate the coroutine has
     ended
- block/backup.c               |   2 +-
+Vladimir Sementsov-Ogievskiy (17):
- block/commit.c               |   2 +-
+  block: fix preallocate filter: don't do unaligned preallocate requests
- block/gluster.c              |  18 +-
+  block/block-copy: move copy_bitmap initialization to
- block/io.c                   |  19 +-
+    block_copy_state_new()
- block/mirror.c               |   2 +-
+  block/dirty-bitmap: bdrv_merge_dirty_bitmap(): add return value
- blockdev.c                   |   1 -
+  block/block-copy: block_copy_state_new(): add bitmap parameter
- blockjob.c                   | 750 ++++++++++++++++++++++++-------------------
+  block/copy-before-write: add bitmap open parameter
- include/block/blockjob.h     |  16 -
+  block/block-copy: add block_copy_reset()
- include/block/blockjob_int.h |  27 +-
+  block: intoduce reqlist
- tests/test-blockjob-txn.c    |   7 +-
+  block/reqlist: reqlist_find_conflict(): use ranges_overlap()
- tests/test-blockjob.c        |  10 +-
+  block/dirty-bitmap: introduce bdrv_dirty_bitmap_status()
-files changed, 463 insertions(+), 391 deletions(-)
+  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
  qapi/block-core.json                        |  14 +-
  include/block/block-common.h                |   3 +-
  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
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 01/12] blockjob: remove unnecessary check
+[PULL 01/23] ide: Increment BB in-flight counter for TRIM BH
-From: Paolo Bonzini <pbonzini@redhat.com>
+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.
-!job is always checked prior to the call, drop it from here.
+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.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+It is clear that if blk_drain() is a no-op, the value of
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+s->bus->dma->aiocb will not change between checking it in the `if`
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+condition and asserting that it is NULL after blk_drain().
-Message-id: 20170508141310.8674-2-pbonzini@redhat.com
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+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>
 ---
- blockjob.c | 2 +-
+ hw/ide/core.c | 7 +++++++
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 7 insertions(+)
-diff --git a/blockjob.c b/blockjob.c
+diff --git a/hw/ide/core.c b/hw/ide/core.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/hw/ide/core.c
-+++ b/blockjob.c
++++ b/hw/ide/core.c
-@@ -XXX,XX +XXX,XX @@ static bool block_job_should_pause(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ static const AIOCBInfo trim_aiocb_info = {
+ static void ide_trim_bh_cb(void *opaque)
  bool block_job_user_paused(BlockJob *job)
  {
--    return job ? job->user_paused : 0;
+     TrimAIOCB *iocb = opaque;
-+    return job->user_paused;
++    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);
  }
- void coroutine_fn block_job_pause_point(BlockJob *job)
+ 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);
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 02/12] blockjob: remove iostatus_reset callback
+[PULL 02/23] block/curl.c: Set error message string if curl_init_state() fails
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Peter Maydell <peter.maydell@linaro.org>
-This is unused since commit 66a0fae ("blockjob: Don't touch BDS iostatus",
+In curl_open(), the 'out' label assumes that the state->errmsg string
--05-19).
+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.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+(We can't be specific about the cause of failure: the documentation
-Reviewed-by: John Snow <jsnow@redhat.com>
+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>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Message-id: 20170508141310.8674-3-pbonzini@redhat.com
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 ---
- blockjob.c                   | 3 ---
+ block/curl.c | 2 ++
- include/block/blockjob_int.h | 3 ---
+file changed, 2 insertions(+)
 files changed, 6 deletions(-)
-diff --git a/blockjob.c b/blockjob.c
+diff --git a/block/curl.c b/block/curl.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/block/curl.c
-+++ b/blockjob.c
++++ b/block/curl.c
-@@ -XXX,XX +XXX,XX @@ bool block_job_is_cancelled(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ static int curl_open(BlockDriverState *bs, QDict *options, int flags,
- void block_job_iostatus_reset(BlockJob *job)
+     // Get file size
- {
-     job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
+     if (curl_init_state(s, state) < 0) {
--    if (job->driver->iostatus_reset) {
++        pstrcpy(state->errmsg, CURL_ERROR_SIZE,
--        job->driver->iostatus_reset(job);
++                "curl library initialization failed.");
--    }
+         goto out;
- }
+     }
  static int block_job_finish_sync(BlockJob *job,
 diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/blockjob_int.h
 +++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
      /** Optional callback for job types that support setting a speed limit */
      void (*set_speed)(BlockJob *job, int64_t speed, Error **errp);
 -    /** Optional callback for job types that need to forward I/O status reset */
 -    void (*iostatus_reset)(BlockJob *job);
 -
      /** Mandatory: Entrypoint for the Coroutine. */
      CoroutineEntry *start;
 --
-.9.3
+.34.1

-New patch
+[PULL 03/23] block/curl.c: Check error return from curl_easy_setopt()
+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 +++++++++++++++++++++++++++++++++-------------------
+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;
+--
+.34.1

-New patch
+[PULL 04/23] block: fix preallocate filter: don't do unaligned preallocate requests
+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

-New patch
+[PULL 05/23] tests/qemu-iotests/040: Skip TestCommitWithFilters without 'throttle'
+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

-New patch
+[PULL 06/23] tests/qemu-iotests/testrunner: Quote "case not run" lines in TAP mode
+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

-New patch
+[PULL 07/23] iotests: Write test output to TEST_DIR
+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

-[Qemu-devel] [PULL 09/12] blockjob: strengthen a bit test-blockjob-txn
+[PULL 08/23] block/block-copy: move copy_bitmap initialization to block_copy_state_new()
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Unlike test-blockjob-txn, QMP releases the reference to the transaction
+We are going to complicate bitmap initialization in the further
-before the jobs finish.  Thus, qemu-iotest 124 showed a failure while
+commit. And in future, backup job will be able to work without filter
-working on the next patch that the unit tests did not have.  Make
+(when source is immutable), so we'll need same bitmap initialization in
-the test a little nastier.
+copy-before-write filter and in backup job. So, it's reasonable to do
 it in block-copy.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Note that for now cbw_open() is the only caller of
-Reviewed-by: John Snow <jsnow@redhat.com>
+block_copy_state_new().
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Message-id: 20170508141310.8674-10-pbonzini@redhat.com
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20220303194349.2304213-2-vsementsov@virtuozzo.com>
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
- tests/test-blockjob-txn.c | 7 +++++--
+ block/block-copy.c        | 1 +
-file changed, 5 insertions(+), 2 deletions(-)
+ block/copy-before-write.c | 4 ----
 files changed, 1 insertion(+), 4 deletions(-)
-diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
+diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-blockjob-txn.c
+--- a/block/block-copy.c
-+++ b/tests/test-blockjob-txn.c
++++ b/block/block-copy.c
-@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs(int expected1, int expected2)
+@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
-     block_job_start(job1);
+         return NULL;
      block_job_start(job2);
 +    /* Release our reference now to trigger as many nice
 +     * use-after-free bugs as possible.
 +     */
 +    block_job_txn_unref(txn);
 +
      if (expected1 == -ECANCELED) {
          block_job_cancel(job1);
      }
-@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs(int expected1, int expected2)
+     bdrv_disable_dirty_bitmap(copy_bitmap);
++    bdrv_set_dirty_bitmap(copy_bitmap, 0, bdrv_dirty_bitmap_size(copy_bitmap));
-     g_assert_cmpint(result1, ==, expected1);
-     g_assert_cmpint(result2, ==, expected2);
+     /*
       * 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));
 -
--    block_job_txn_unref(txn);
+     return 0;
  }
- static void test_pair_jobs_success(void)
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 10/12] blockjob: reorganize block_job_completed_txn_abort
+[PULL 09/23] block/dirty-bitmap: bdrv_merge_dirty_bitmap(): add return value
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-This splits the part that touches job states from the part that invokes
+That simplifies handling failure in existing code and in further new
-callbacks.  It will make the code simpler to understand once job states will
+usage of bdrv_merge_dirty_bitmap().
 be protected by a different mutex than the AioContext lock.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Message-id: 20170508141310.8674-11-pbonzini@redhat.com
+Message-Id: <20220303194349.2304213-3-vsementsov@virtuozzo.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
- blockjob.c | 35 ++++++++++++++++++++++-------------
+ include/block/dirty-bitmap.h    | 2 +-
-file changed, 22 insertions(+), 13 deletions(-)
+ block/dirty-bitmap.c            | 9 +++++++--
  block/monitor/bitmap-qmp-cmds.c | 5 +----
 files changed, 9 insertions(+), 7 deletions(-)
-diff --git a/blockjob.c b/blockjob.c
+diff --git a/include/block/dirty-bitmap.h b/include/block/dirty-bitmap.h
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/include/block/dirty-bitmap.h
-+++ b/blockjob.c
++++ b/include/block/dirty-bitmap.h
-@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ void bdrv_dirty_bitmap_set_persistence(BdrvDirtyBitmap *bitmap,
+                                        bool persistent);
- static void block_job_completed_single(BlockJob *job)
+ 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)
  {
-+    assert(job->completed);
+-    bool ret;
-+
++    bool ret = false;
-     if (!job->ret) {
-         if (job->driver->commit) {
+     bdrv_dirty_bitmaps_lock(dest->bs);
-             job->driver->commit(job);
+     if (src->bs != dest->bs) {
-@@ -XXX,XX +XXX,XX @@ static int block_job_finish_sync(BlockJob *job,
+@@ -XXX,XX +XXX,XX @@ out:
+     if (src->bs != dest->bs) {
-     block_job_ref(job);
+         bdrv_dirty_bitmaps_unlock(src->bs);
 -    finish(job, &local_err);
 +    if (finish) {
 +        finish(job, &local_err);
 +    }
      if (local_err) {
          error_propagate(errp, local_err);
          block_job_unref(job);
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
  {
      AioContext *ctx;
      BlockJobTxn *txn = job->txn;
 -    BlockJob *other_job, *next;
 +    BlockJob *other_job;
      if (txn->aborting) {
          /*
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
          return;
      }
      txn->aborting = true;
 +    block_job_txn_ref(txn);
 +
      /* We are the first failed job. Cancel other jobs. */
      QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
          ctx = blk_get_aio_context(other_job->blk);
          aio_context_acquire(ctx);
      }
 +
-+    /* Other jobs are effectively cancelled by us, set the status for
++    return ret;
-+     * them; this job, however, may or may not be cancelled, depending
+ }
-+     * on the caller, so leave it. */
-     QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
+ /**
--        if (other_job == job || other_job->completed) {
+diff --git a/block/monitor/bitmap-qmp-cmds.c b/block/monitor/bitmap-qmp-cmds.c
--            /* Other jobs are "effectively" cancelled by us, set the status for
+index XXXXXXX..XXXXXXX 100644
--             * them; this job, however, may or may not be cancelled, depending
+--- a/block/monitor/bitmap-qmp-cmds.c
--             * on the caller, so leave it. */
++++ b/block/monitor/bitmap-qmp-cmds.c
--            if (other_job != job) {
+@@ -XXX,XX +XXX,XX @@ BdrvDirtyBitmap *block_dirty_bitmap_merge(const char *node, const char *target,
--                block_job_cancel_async(other_job);
+     BlockDriverState *bs;
--            }
+     BdrvDirtyBitmap *dst, *src, *anon;
--            continue;
+     BlockDirtyBitmapMergeSourceList *lst;
-+        if (other_job != job) {
+-    Error *local_err = NULL;
-+            block_job_cancel_async(other_job);
      GLOBAL_STATE_CODE();
@@ -XXX,XX +XXX,XX @@ BdrvDirtyBitmap *block_dirty_bitmap_merge(const char *node, const char *target,
              abort();
          }
--        block_job_cancel_sync(other_job);
--        assert(other_job->completed);
+-        bdrv_merge_dirty_bitmap(anon, src, NULL, &local_err);
-     }
+-        if (local_err) {
--    QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
+-            error_propagate(errp, local_err);
-+    while (!QLIST_EMPTY(&txn->jobs)) {
++        if (!bdrv_merge_dirty_bitmap(anon, src, NULL, errp)) {
-+        other_job = QLIST_FIRST(&txn->jobs);
+             dst = NULL;
-         ctx = blk_get_aio_context(other_job->blk);
+             goto out;
-+        if (!other_job->completed) {
+         }
 +            assert(other_job->cancelled);
 +            block_job_finish_sync(other_job, NULL, NULL);
 +        }
          block_job_completed_single(other_job);
          aio_context_release(ctx);
      }
 +
 +    block_job_txn_unref(txn);
  }
  static void block_job_completed_txn_success(BlockJob *job)
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 12/12] block/gluster: glfs_lseek() workaround
+[PULL 10/23] block/block-copy: block_copy_state_new(): add bitmap parameter
-On current released versions of glusterfs, glfs_lseek() will sometimes
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 return invalid values for SEEK_DATA or SEEK_HOLE.  For SEEK_DATA and
 SEEK_HOLE, the returned value should be >= the passed offset, or < 0 in
 the case of error:
-LSEEK(2):
+This will be used in the following commit to bring "incremental" mode
 to copy-before-write filter.
-    off_t lseek(int fd, off_t offset, int whence);
+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
     SEEK_HOLE
               Adjust  the file offset to the next hole in the file greater
               than or equal to offset.  If offset points into the middle of
               a hole, then the file offset is set to offset.  If there is no
               hole past offset, then the file offset is adjusted to the end
               of the file (i.e., there is  an implicit hole at the end of
               any file).
     [...]
     RETURN VALUE
               Upon  successful  completion,  lseek()  returns  the resulting
               offset location as measured in bytes from the beginning of the
               file.  On error, the value (off_t) -1 is returned and errno is
               set to indicate the error
 However, occasionally glfs_lseek() for SEEK_HOLE/DATA will return a
 value less than the passed offset, yet greater than zero.
 For instance, here are example values observed from this call:
     offs = glfs_lseek(s->fd, start, SEEK_HOLE);
     if (offs < 0) {
         return -errno;          /* D1 and (H3 or H4) */
     }
 start == 7608336384
 offs == 7607877632
 This causes QEMU to abort on the assert test.  When this value is
 returned, errno is also 0.
 This is a reported and known bug to glusterfs:
 https://bugzilla.redhat.com/show_bug.cgi?id=1425293
 Although this is being fixed in gluster, we still should work around it
 in QEMU, given that multiple released versions of gluster behave this
 way.
 This patch treats the return case of (offs < start) the same as if an
 error value other than ENXIO is returned; we will assume we learned
 nothing, and there are no holes in the file.
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Niels de Vos <ndevos@redhat.com>
 Message-id: 87c0140e9407c08f6e74b04131b610f2e27c014c.1495560397.git.jcody@redhat.com
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 ---
  block/gluster.c | 18 ++++++++++++++++--
 file changed, 16 insertions(+), 2 deletions(-)
 diff --git a/block/gluster.c b/block/gluster.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/gluster.c
+--- a/include/block/block-copy.h
-+++ b/block/gluster.c
++++ b/include/block/block-copy.h
-@@ -XXX,XX +XXX,XX @@ static int find_allocation(BlockDriverState *bs, off_t start,
+@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState BlockCopyState;
-     if (offs < 0) {
+ typedef struct BlockCopyCallState BlockCopyCallState;
-         return -errno;          /* D3 or D4 */
  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;
      }
--    assert(offs >= start);
+     bdrv_disable_dirty_bitmap(copy_bitmap);
-+
+-    bdrv_set_dirty_bitmap(copy_bitmap, 0, bdrv_dirty_bitmap_size(copy_bitmap));
-+    if (offs < start) {
++    if (bitmap) {
-+        /* This is not a valid return by lseek().  We are safe to just return
++        if (!bdrv_merge_dirty_bitmap(copy_bitmap, bitmap, NULL, errp)) {
-+         * -EIO in this case, and we'll treat it like D4. Unfortunately some
++            error_prepend(errp, "Failed to merge bitmap '%s' to internal "
-+         *  versions of gluster server will return offs < start, so an assert
++                          "copy-bitmap: ", bdrv_dirty_bitmap_name(bitmap));
-+         *  here will unnecessarily abort QEMU. */
++            bdrv_release_dirty_bitmap(copy_bitmap);
-+        return -EIO;
++            return NULL;
 +        }
 +    } else {
 +        bdrv_set_dirty_bitmap(copy_bitmap, 0,
 +                              bdrv_dirty_bitmap_size(copy_bitmap));
 +    }
-     if (offs > start) {
+     /*
-         /* D2: in hole, next data at offs */
+      * If source is in backing chain of target assume that target is going to be
-@@ -XXX,XX +XXX,XX @@ static int find_allocation(BlockDriverState *bs, off_t start,
+diff --git a/block/copy-before-write.c b/block/copy-before-write.c
-     if (offs < 0) {
+index XXXXXXX..XXXXXXX 100644
-         return -errno;          /* D1 and (H3 or H4) */
+--- a/block/copy-before-write.c
-     }
++++ b/block/copy-before-write.c
--    assert(offs >= start);
+@@ -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) &
-+    if (offs < start) {
+              bs->file->bs->supported_zero_flags);
-+        /* This is not a valid return by lseek().  We are safe to just return
-+         * -EIO in this case, and we'll treat it like H4. Unfortunately some
+-    s->bcs = block_copy_state_new(bs->file, s->target, errp);
-+         *  versions of gluster server will return offs < start, so an assert
++    s->bcs = block_copy_state_new(bs->file, s->target, NULL, errp);
-+         *  here will unnecessarily abort QEMU. */
+     if (!s->bcs) {
-+        return -EIO;
+         error_prepend(errp, "Cannot create block-copy-state: ");
-+    }
+         return -EINVAL;
      if (offs > start) {
          /*
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 06/12] blockjob: move iostatus reset inside block_job_user_resume
+[PULL 11/23] block/copy-before-write: add bitmap open parameter
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Outside blockjob.c, the block_job_iostatus_reset function is used once
+This brings "incremental" mode to copy-before-write filter: user can
-in the monitor and once in BlockBackend.  When we introduce the block
+specify bitmap so that filter will copy only "dirty" areas.
 job mutex, block_job_iostatus_reset's client is going to be the block
 layer (for which blockjob.c will take the block job mutex) rather than
 the monitor (which will take the block job mutex by itself).
-The monitor's call to block_job_iostatus_reset from the monitor comes
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-just before the sole call to block_job_user_resume, so reset the
+Message-Id: <20220303194349.2304213-5-vsementsov@virtuozzo.com>
-iostatus directly from block_job_iostatus_reset.  This will avoid
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-the need to introduce separate block_job_iostatus_reset and
+---
-block_job_iostatus_reset_locked APIs.
+ qapi/block-core.json      | 10 +++++++-
  block/copy-before-write.c | 51 ++++++++++++++++++++++++++++++++++++++-
 files changed, 59 insertions(+), 2 deletions(-)
-After making this change, move the function together with the others
+diff --git a/qapi/block-core.json b/qapi/block-core.json
 that were moved in the previous patch.
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 Message-id: 20170508141310.8674-7-pbonzini@redhat.com
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 ---
  blockdev.c |  1 -
  blockjob.c | 11 ++++++-----
 files changed, 6 insertions(+), 6 deletions(-)
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
+--- a/qapi/block-core.json
-+++ b/blockdev.c
++++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@ void qmp_block_job_resume(const char *device, Error **errp)
+@@ -XXX,XX +XXX,XX @@
-     }
+ #
+ # @target: The target for copy-before-write operations.
-     trace_qmp_block_job_resume(job);
+ #
--    block_job_iostatus_reset(job);
++# @bitmap: If specified, copy-before-write filter will do
-     block_job_user_resume(job);
++#          copy-before-write operations only for dirty regions of the
-     aio_context_release(aio_context);
++#          bitmap. Bitmap size must be equal to length of file and
- }
++#          target child of the filter. Note also, that bitmap is used
-diff --git a/blockjob.c b/blockjob.c
++#          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/blockjob.c
+--- a/block/copy-before-write.c
-+++ b/blockjob.c
++++ b/block/copy-before-write.c
-@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@
- {
-     if (job && job->user_paused && job->pause_count > 0) {
+ #include "block/copy-before-write.h"
-         job->user_paused = false;
-+        block_job_iostatus_reset(job);
++#include "qapi/qapi-visit-block-core.h"
-         block_job_resume(job);
++
  typedef struct BDRVCopyBeforeWriteState {
      BlockCopyState *bcs;
      BdrvChild *target;
@@ -XXX,XX +XXX,XX @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c,
      }
  }
-@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
-     }
++static bool cbw_parse_bitmap_option(QDict *options, BdrvDirtyBitmap **bitmap,
- }
++                                    Error **errp)
 -void block_job_iostatus_reset(BlockJob *job)
 -{
 -    job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
 -}
 -
  static int block_job_finish_sync(BlockJob *job,
                                   void (*finish)(BlockJob *, Error **errp),
                                   Error **errp)
@@ -XXX,XX +XXX,XX @@ void block_job_yield(BlockJob *job)
      block_job_pause_point(job);
  }
 +void block_job_iostatus_reset(BlockJob *job)
 +{
-+    job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
++    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;
 +}
 +
- void block_job_event_ready(BlockJob *job)
+ static int cbw_open(BlockDriverState *bs, QDict *options, int flags,
                      Error **errp)
  {
-     job->ready = true;
+     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;
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 11/12] blockjob: use deferred_to_main_loop to indicate the coroutine has ended
+[PULL 12/23] block/block-copy: add block_copy_reset()
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-All block jobs are using block_job_defer_to_main_loop as the final
+Split block_copy_reset() out of block_copy_reset_unallocated() to be
-step just before the coroutine terminates.  At this point,
+used separately later.
 block_job_enter should do nothing, but currently it restarts
 the freed coroutine.
-Now, the job->co states should probably be changed to an enum
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-(e.g. BEFORE_START, STARTED, YIELDED, COMPLETED) subsuming
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-block_job_started, job->deferred_to_main_loop and job->busy.
+Message-Id: <20220303194349.2304213-6-vsementsov@virtuozzo.com>
-For now, this patch eliminates the problematic reenter by
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-removing the reset of job->deferred_to_main_loop (which served
+---
-no purpose, as far as I could see) and checking the flag in
+ include/block/block-copy.h |  1 +
-block_job_enter.
+ block/block-copy.c         | 21 +++++++++++++--------
 files changed, 14 insertions(+), 8 deletions(-)
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+diff --git a/include/block/block-copy.h b/include/block/block-copy.h
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Message-id: 20170508141310.8674-12-pbonzini@redhat.com
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 ---
  blockjob.c                   | 10 ++++++++--
  include/block/blockjob_int.h |  3 ++-
 files changed, 10 insertions(+), 3 deletions(-)
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/include/block/block-copy.h
-+++ b/blockjob.c
++++ b/include/block/block-copy.h
-@@ -XXX,XX +XXX,XX @@ void block_job_resume_all(void)
+@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm);
- void block_job_enter(BlockJob *job)
+ void block_copy_state_free(BlockCopyState *s);
- {
--    if (job->co && !job->busy) {
++void block_copy_reset(BlockCopyState *s, int64_t offset, int64_t bytes);
-+    if (!block_job_started(job)) {
+ int64_t block_copy_reset_unallocated(BlockCopyState *s,
-+        return;
+                                      int64_t offset, int64_t *count);
-+    }
-+    if (job->deferred_to_main_loop) {
+diff --git a/block/block-copy.c b/block/block-copy.c
-+        return;
+index XXXXXXX..XXXXXXX 100644
-+    }
+--- a/block/block-copy.c
-+
++++ b/block/block-copy.c
-+    if (!job->busy) {
+@@ -XXX,XX +XXX,XX @@ static int block_copy_is_cluster_allocated(BlockCopyState *s, int64_t offset,
          bdrv_coroutine_enter(blk_bs(job->blk), job->co);
      }
  }
-@@ -XXX,XX +XXX,XX @@ static void block_job_defer_to_main_loop_bh(void *opaque)
-         aio_context_acquire(aio_context);
++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);
      }
--    data->job->deferred_to_main_loop = false;
+     *count = bytes;
      data->fn(data->job, data->opaque);
      if (aio_context != data->aio_context) {
 diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/blockjob_int.h
 +++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ typedef void BlockJobDeferToMainLoopFn(BlockJob *job, void *opaque);
   * @fn: The function to run in the main loop
   * @opaque: The opaque value that is passed to @fn
   *
 - * Execute a given function in the main loop with the BlockDriverState
 + * This function must be called by the main job coroutine just before it
 + * returns.  @fn is executed in the main loop with the BlockDriverState
   * AioContext acquired.  Block jobs must call bdrv_unref(), bdrv_close(), and
   * anything that uses bdrv_drain_all() in the main loop.
   *
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 05/12] blockjob: separate monitor and blockjob APIs
+[PULL 13/23] block: intoduce reqlist
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-We have two different headers for block job operations, blockjob.h
+Split intersecting-requests functionality out of block-copy to be
-and blockjob_int.h.  The former contains APIs called by the monitor,
+reused in copy-before-write filter.
 the latter contains APIs called by the block job drivers and the
 block layer itself.
-Keep the two APIs separate in the blockjob.c file too.  This will
+Note: while being here, fix tiny typo in MAINTAINERS.
 be useful when transitioning away from the AioContext lock, because
 there will be locking policies for the two categories, too---the
 monitor will have to call new block_job_lock/unlock APIs, while blockjob
 APIs will take care of this for the users.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Message-id: 20170508141310.8674-6-pbonzini@redhat.com
+Message-Id: <20220303194349.2304213-7-vsementsov@virtuozzo.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
- blockjob.c | 390 ++++++++++++++++++++++++++++++++-----------------------------
+ include/block/reqlist.h |  67 +++++++++++++++++++++++
-file changed, 205 insertions(+), 185 deletions(-)
+ 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/blockjob.c b/blockjob.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/blockjob.c
+--- a/block/block-copy.c
-+++ b/blockjob.c
++++ b/block/block-copy.c
-@@ -XXX,XX +XXX,XX @@ struct BlockJobTxn {
+@@ -XXX,XX +XXX,XX @@
+ #include "trace.h"
- static QLIST_HEAD(, BlockJob) block_jobs = QLIST_HEAD_INITIALIZER(block_jobs);
+ #include "qapi/error.h"
+ #include "block/block-copy.h"
-+/*
++#include "block/reqlist.h"
-+ * The block job API is composed of two categories of functions.
+ #include "sysemu/block-backend.h"
-+ *
+ #include "qemu/units.h"
-+ * The first includes functions used by the monitor.  The monitor is
+ #include "qemu/coroutine.h"
-+ * peculiar in that it accesses the block job list with block_job_get, and
+@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyTask {
-+ * therefore needs consistency across block_job_get and the actual operation
+      */
-+ * (e.g. block_job_set_speed).  The consistency is achieved with
+     BlockCopyState *s;
-+ * aio_context_acquire/release.  These functions are declared in blockjob.h.
+     BlockCopyCallState *call_state;
-+ *
+-    int64_t offset;
-+ * The second includes functions used by the block job drivers and sometimes
+     /*
-+ * by the core block layer.  These do not care about locking, because the
+      * @method can also be set again in the while loop of
-+ * whole coroutine runs under the AioContext lock, and are declared in
+      * block_copy_dirty_clusters(), but it is never accessed concurrently
-+ * blockjob_int.h.
+@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyTask {
-+ */
+     BlockCopyMethod method;
-+
- BlockJob *block_job_next(BlockJob *job)
+     /*
 -     * 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)
  {
-     if (!job) {
+-    return task->offset + task->bytes;
-@@ -XXX,XX +XXX,XX @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
++    return task->req.offset + task->req.bytes;
      return 0;
  }
--void *block_job_create(const char *job_id, const BlockJobDriver *driver,
+ typedef struct BlockCopyState {
--                       BlockDriverState *bs, uint64_t perm,
+@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
--                       uint64_t shared_perm, int64_t speed, int flags,
+     CoMutex lock;
--                       BlockCompletionFunc *cb, void *opaque, Error **errp)
+     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)
 -{
--    BlockBackend *blk;
+-    BlockCopyTask *t;
--    BlockJob *job;
+-
--    int ret;
+-    QLIST_FOREACH(t, &s->tasks, list) {
--
+-        if (offset + bytes > t->offset && offset < t->offset + t->bytes) {
--    if (bs->job) {
+-            return t;
 -        error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
 -        return NULL;
 -    }
 -
 -    if (job_id == NULL && !(flags & BLOCK_JOB_INTERNAL)) {
 -        job_id = bdrv_get_device_name(bs);
 -        if (!*job_id) {
 -            error_setg(errp, "An explicit job ID is required for this node");
 -            return NULL;
 -        }
 -    }
 -
--    if (job_id) {
+-    return NULL;
--        if (flags & BLOCK_JOB_INTERNAL) {
+-}
--            error_setg(errp, "Cannot specify job ID for internal block job");
+-
--            return NULL;
+-/*
--        }
+- * If there are no intersecting tasks return false. Otherwise, wait for the
--
+- * first found intersecting tasks to finish and return true.
--        if (!id_wellformed(job_id)) {
+- *
--            error_setg(errp, "Invalid job ID '%s'", job_id);
+- * Called with lock held. May temporary release the lock.
--            return NULL;
+- * Return value of 0 proves that lock was NOT released.
--        }
+- */
--
+-static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t offset,
--        if (block_job_get(job_id)) {
+-                                             int64_t bytes)
--            error_setg(errp, "Job ID '%s' already in use", job_id);
+-{
--            return NULL;
+-    BlockCopyTask *task = find_conflicting_task(s, offset, bytes);
--        }
+-
 -    if (!task) {
 -        return false;
 -    }
 -
--    blk = blk_new(perm, shared_perm);
+-    qemu_co_queue_wait(&task->wait_queue, &s->lock);
--    ret = blk_insert_bs(blk, bs, errp);
+-
--    if (ret < 0) {
+-    return true;
 -        blk_unref(blk);
 -        return NULL;
 -    }
 -
 -    job = g_malloc0(driver->instance_size);
 -    job->driver        = driver;
 -    job->id            = g_strdup(job_id);
 -    job->blk           = blk;
 -    job->cb            = cb;
 -    job->opaque        = opaque;
 -    job->busy          = false;
 -    job->paused        = true;
 -    job->pause_count   = 1;
 -    job->refcnt        = 1;
 -
 -    error_setg(&job->blocker, "block device is in use by block job: %s",
 -               BlockJobType_lookup[driver->job_type]);
 -    block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
 -    bs->job = job;
 -
 -    blk_set_dev_ops(blk, &block_job_dev_ops, job);
 -    bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
 -
 -    QLIST_INSERT_HEAD(&block_jobs, job, job_list);
 -
 -    blk_add_aio_context_notifier(blk, block_job_attached_aio_context,
 -                                 block_job_detach_aio_context, job);
 -
 -    /* Only set speed when necessary to avoid NotSupported error */
 -    if (speed != 0) {
 -        Error *local_err = NULL;
 -
 -        block_job_set_speed(job, speed, &local_err);
 -        if (local_err) {
 -            block_job_unref(job);
 -            error_propagate(errp, local_err);
 -            return NULL;
 -        }
 -    }
 -    return job;
 -}
 -
- bool block_job_is_internal(BlockJob *job)
+ /* Called with lock held */
  static int64_t block_copy_chunk_size(BlockCopyState *s)
  {
-     return (job->id == NULL);
+@@ -XXX,XX +XXX,XX @@ block_copy_task_create(BlockCopyState *s, BlockCopyCallState *call_state,
-@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
+     bytes = QEMU_ALIGN_UP(bytes, s->cluster_size);
-     bdrv_coroutine_enter(blk_bs(job->blk), job->co);
      /* 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,
--void block_job_early_fail(BlockJob *job)
+                                                 int64_t new_bytes)
 -{
 -    block_job_unref(job);
 -}
 -
  static void block_job_completed_single(BlockJob *job)
  {
-     if (!job->ret) {
+     QEMU_LOCK_GUARD(&task->s->lock);
-@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
+-    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);
  }
--void block_job_completed(BlockJob *job, int ret)
+ static void coroutine_fn block_copy_task_end(BlockCopyTask *task, int ret)
 -{
 -    assert(blk_bs(job->blk)->job == job);
 -    assert(!job->completed);
 -    job->completed = true;
 -    job->ret = ret;
 -    if (!job->txn) {
 -        block_job_completed_single(job);
 -    } else if (ret < 0 || block_job_is_cancelled(job)) {
 -        block_job_completed_txn_abort(job);
 -    } else {
 -        block_job_completed_txn_success(job);
 -    }
 -}
 -
  void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
  {
-     Error *local_err = NULL;
+     QEMU_LOCK_GUARD(&task->s->lock);
-@@ -XXX,XX +XXX,XX @@ void block_job_user_pause(BlockJob *job)
+-    task->s->in_flight_bytes -= task->bytes;
-     block_job_pause(job);
++    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);
  }
--static bool block_job_should_pause(BlockJob *job)
+ void block_copy_state_free(BlockCopyState *s)
--{
+@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
--    return job->pause_count > 0;
--}
+     ratelimit_init(&s->rate_limit);
--
+     qemu_co_mutex_init(&s->lock);
- bool block_job_user_paused(BlockJob *job)
+-    QLIST_INIT(&s->tasks);
- {
++    QLIST_INIT(&s->reqs);
-     return job->user_paused;
+     QLIST_INIT(&s->calls);
- }
+     return s;
--void coroutine_fn block_job_pause_point(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_run(AioTaskPool *pool,
--{
--    assert(job && block_job_started(job));
+     aio_task_pool_wait_slot(pool);
--
+     if (aio_task_pool_status(pool) < 0) {
--    if (!block_job_should_pause(job)) {
+-        co_put_to_shres(task->s->mem, task->bytes);
--        return;
++        co_put_to_shres(task->s->mem, task->req.bytes);
--    }
+         block_copy_task_end(task, -ECANCELED);
--    if (block_job_is_cancelled(job)) {
+         g_free(task);
--        return;
+         return -ECANCELED;
--    }
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
--
+     BlockCopyMethod method = t->method;
--    if (job->driver->pause) {
+     int ret;
--        job->driver->pause(job);
--    }
+-    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,
--    if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
++                             &error_is_read);
--        job->paused = true;
--        job->busy = false;
+     WITH_QEMU_LOCK_GUARD(&s->lock) {
--        qemu_coroutine_yield(); /* wait for block_job_resume() */
+         if (s->method == t->method) {
--        job->busy = true;
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int block_copy_task_entry(AioTask *task)
--        job->paused = false;
+                 t->call_state->error_is_read = error_is_read;
--    }
+             }
--
+         } else if (s->progress) {
--    if (job->driver->resume) {
+-            progress_work_done(s->progress, t->bytes);
--        job->driver->resume(job);
++            progress_work_done(s->progress, t->req.bytes);
--    }
+         }
 -}
 -
  void block_job_user_resume(BlockJob *job)
  {
      if (job && job->user_paused && job->pause_count > 0) {
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job)
      }
- }
+-    co_put_to_shres(s->mem, t->bytes);
++    co_put_to_shres(s->mem, t->req.bytes);
--void block_job_enter(BlockJob *job)
+     block_copy_task_end(t, ret);
--{
--    if (job->co && !job->busy) {
+     return ret;
--        bdrv_coroutine_enter(blk_bs(job->blk), job->co);
+@@ -XXX,XX +XXX,XX @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
--    }
+             trace_block_copy_skip_range(s, offset, bytes);
--}
+             break;
--
+         }
- void block_job_cancel(BlockJob *job)
+-        if (task->offset > offset) {
- {
+-            trace_block_copy_skip_range(s, offset, task->offset - offset);
-     if (block_job_started(job)) {
++        if (task->req.offset > offset) {
-@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
++            trace_block_copy_skip_range(s, offset, task->req.offset - offset);
-     }
+         }
- }
+         found_dirty = true;
--bool block_job_is_cancelled(BlockJob *job)
--{
+-        ret = block_copy_block_status(s, task->offset, task->bytes,
--    return job->cancelled;
++        ret = block_copy_block_status(s, task->req.offset, task->req.bytes,
--}
+                                       &status_bytes);
--
+         assert(ret >= 0); /* never fail */
- void block_job_iostatus_reset(BlockJob *job)
+-        if (status_bytes < task->bytes) {
- {
++        if (status_bytes < task->req.bytes) {
-     job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
+             block_copy_task_shrink(task, status_bytes);
-@@ -XXX,XX +XXX,XX @@ int block_job_complete_sync(BlockJob *job, Error **errp)
+         }
-     return block_job_finish_sync(job, &block_job_complete, errp);
+         if (qatomic_read(&s->skip_unallocated) &&
- }
+             !(ret & BDRV_BLOCK_ALLOCATED)) {
+             block_copy_task_end(task, 0);
--void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns)
+-            trace_block_copy_skip_range(s, task->offset, task->bytes);
--{
++            trace_block_copy_skip_range(s, task->req.offset, task->req.bytes);
--    assert(job->busy);
+             offset = task_end(task);
--
+             bytes = end - offset;
--    /* Check cancellation *before* setting busy = false, too!  */
+             g_free(task);
--    if (block_job_is_cancelled(job)) {
+@@ -XXX,XX +XXX,XX @@ block_copy_dirty_clusters(BlockCopyCallState *call_state)
--        return;
+             }
--    }
+         }
--
--    job->busy = false;
+-        ratelimit_calculate_delay(&s->rate_limit, task->bytes);
--    if (!block_job_should_pause(job)) {
++        ratelimit_calculate_delay(&s->rate_limit, task->req.bytes);
--        co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns);
--    }
+-        trace_block_copy_process(s, task->offset);
--    job->busy = true;
++        trace_block_copy_process(s, task->req.offset);
--
--    block_job_pause_point(job);
+-        co_get_from_shres(s->mem, task->bytes);
--}
++        co_get_from_shres(s->mem, task->req.bytes);
--
--void block_job_yield(BlockJob *job)
+         offset = task_end(task);
--{
+         bytes = end - offset;
--    assert(job->busy);
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
--
+                  * Check that there is no task we still need to
--    /* Check cancellation *before* setting busy = false, too!  */
+                  * wait to complete
--    if (block_job_is_cancelled(job)) {
+                  */
--        return;
+-                ret = block_copy_wait_one(s, call_state->offset,
--    }
+-                                          call_state->bytes);
--
++                ret = reqlist_wait_one(&s->reqs, call_state->offset,
--    job->busy = false;
++                                       call_state->bytes, &s->lock);
--    if (!block_job_should_pause(job)) {
+                 if (ret == 0) {
--        qemu_coroutine_yield();
+                     /*
--    }
+                      * No pending tasks, but check again the bitmap in this
--    job->busy = true;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_common(BlockCopyCallState *call_state)
--
+                      * between this and the critical section in
--    block_job_pause_point(job);
+                      * block_copy_dirty_clusters().
--}
+                      *
--
+-                     * block_copy_wait_one return value 0 also means that it
- BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
++                     * reqlist_wait_one return value 0 also means that it
- {
+                      * didn't release the lock. So, we are still in the same
-     BlockJobInfo *info;
+                      * critical section, not interrupted by any concurrent
-@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(BlockJob *job, const char *msg)
+                      * access to state.
-                                         &error_abort);
+diff --git a/block/reqlist.c b/block/reqlist.c
- }
+new file mode 100644
+index XXXXXXX..XXXXXXX
-+/*
+--- /dev/null
-+ * API for block job drivers and the block layer.  These functions are
++++ b/block/reqlist.c
-+ * declared in blockjob_int.h.
+@@ -XXX,XX +XXX,XX @@
-+ */
++/*
-+
++ * reqlist API
-+void *block_job_create(const char *job_id, const BlockJobDriver *driver,
++ *
-+                       BlockDriverState *bs, uint64_t perm,
++ * Copyright (C) 2013 Proxmox Server Solutions
-+                       uint64_t shared_perm, int64_t speed, int flags,
++ * Copyright (c) 2021 Virtuozzo International GmbH.
-+                       BlockCompletionFunc *cb, void *opaque, Error **errp)
++ *
 + * 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)
 +{
-+    BlockBackend *blk;
++    assert(!reqlist_find_conflict(reqs, offset, bytes));
-+    BlockJob *job;
++
-+    int ret;
++    *req = (BlockReq) {
-+
++        .offset = offset,
-+    if (bs->job) {
++        .bytes = bytes,
-+        error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
++    };
-+        return NULL;
++    qemu_co_queue_init(&req->wait_queue);
-+    }
++    QLIST_INSERT_HEAD(reqs, req, list);
-+
++}
-+    if (job_id == NULL && !(flags & BLOCK_JOB_INTERNAL)) {
++
-+        job_id = bdrv_get_device_name(bs);
++BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
-+        if (!*job_id) {
++                                int64_t bytes)
-+            error_setg(errp, "An explicit job ID is required for this node");
++{
-+            return NULL;
++    BlockReq *r;
 +
 +    QLIST_FOREACH(r, reqs, list) {
 +        if (offset + bytes > r->offset && offset < r->offset + r->bytes) {
 +            return r;
 +        }
 +    }
 +
-+    if (job_id) {
++    return NULL;
-+        if (flags & BLOCK_JOB_INTERNAL) {
++}
-+            error_setg(errp, "Cannot specify job ID for internal block job");
++
-+            return NULL;
++bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
-+        }
++                                   int64_t bytes, CoMutex *lock)
-+
++{
-+        if (!id_wellformed(job_id)) {
++    BlockReq *r = reqlist_find_conflict(reqs, offset, bytes);
-+            error_setg(errp, "Invalid job ID '%s'", job_id);
++
-+            return NULL;
++    if (!r) {
-+        }
++        return false;
 +
 +        if (block_job_get(job_id)) {
 +            error_setg(errp, "Job ID '%s' already in use", job_id);
 +            return NULL;
 +        }
 +    }
 +
-+    blk = blk_new(perm, shared_perm);
++    qemu_co_queue_wait(&r->wait_queue, lock);
-+    ret = blk_insert_bs(blk, bs, errp);
++
-+    if (ret < 0) {
++    return true;
 +        blk_unref(blk);
 +        return NULL;
 +    }
 +
 +    job = g_malloc0(driver->instance_size);
 +    job->driver        = driver;
 +    job->id            = g_strdup(job_id);
 +    job->blk           = blk;
 +    job->cb            = cb;
 +    job->opaque        = opaque;
 +    job->busy          = false;
 +    job->paused        = true;
 +    job->pause_count   = 1;
 +    job->refcnt        = 1;
 +
 +    error_setg(&job->blocker, "block device is in use by block job: %s",
 +               BlockJobType_lookup[driver->job_type]);
 +    block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
 +    bs->job = job;
 +
 +    blk_set_dev_ops(blk, &block_job_dev_ops, job);
 +    bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
 +
 +    QLIST_INSERT_HEAD(&block_jobs, job, job_list);
 +
 +    blk_add_aio_context_notifier(blk, block_job_attached_aio_context,
 +                                 block_job_detach_aio_context, job);
 +
 +    /* Only set speed when necessary to avoid NotSupported error */
 +    if (speed != 0) {
 +        Error *local_err = NULL;
 +
 +        block_job_set_speed(job, speed, &local_err);
 +        if (local_err) {
 +            block_job_unref(job);
 +            error_propagate(errp, local_err);
 +            return NULL;
 +        }
 +    }
 +    return job;
 +}
 +
- void block_job_pause_all(void)
++void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
  {
      BlockJob *job = NULL;
@@ -XXX,XX +XXX,XX @@ void block_job_pause_all(void)
      }
  }
 +void block_job_early_fail(BlockJob *job)
 +{
-+    block_job_unref(job);
++    if (new_bytes == req->bytes) {
 +}
 +
 +void block_job_completed(BlockJob *job, int ret)
 +{
 +    assert(blk_bs(job->blk)->job == job);
 +    assert(!job->completed);
 +    job->completed = true;
 +    job->ret = ret;
 +    if (!job->txn) {
 +        block_job_completed_single(job);
 +    } else if (ret < 0 || block_job_is_cancelled(job)) {
 +        block_job_completed_txn_abort(job);
 +    } else {
 +        block_job_completed_txn_success(job);
 +    }
 +}
 +
 +static bool block_job_should_pause(BlockJob *job)
 +{
 +    return job->pause_count > 0;
 +}
 +
 +void coroutine_fn block_job_pause_point(BlockJob *job)
 +{
 +    assert(job && block_job_started(job));
 +
 +    if (!block_job_should_pause(job)) {
 +        return;
 +    }
-+    if (block_job_is_cancelled(job)) {
++
-+        return;
++    assert(new_bytes > 0 && new_bytes < req->bytes);
-+    }
++
-+
++    req->bytes = new_bytes;
-+    if (job->driver->pause) {
++    qemu_co_queue_restart_all(&req->wait_queue);
 +        job->driver->pause(job);
 +    }
 +
 +    if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
 +        job->paused = true;
 +        job->busy = false;
 +        qemu_coroutine_yield(); /* wait for block_job_resume() */
 +        job->busy = true;
 +        job->paused = false;
 +    }
 +
 +    if (job->driver->resume) {
 +        job->driver->resume(job);
 +    }
 +}
 +
- void block_job_resume_all(void)
++void coroutine_fn reqlist_remove_req(BlockReq *req)
  {
      BlockJob *job = NULL;
@@ -XXX,XX +XXX,XX @@ void block_job_resume_all(void)
      }
  }
 +void block_job_enter(BlockJob *job)
 +{
-+    if (job->co && !job->busy) {
++    QLIST_REMOVE(req, list);
-+        bdrv_coroutine_enter(blk_bs(job->blk), job->co);
++    qemu_co_queue_restart_all(&req->wait_queue);
 +    }
 +}
-+
+diff --git a/MAINTAINERS b/MAINTAINERS
-+bool block_job_is_cancelled(BlockJob *job)
+index XXXXXXX..XXXXXXX 100644
-+{
+--- a/MAINTAINERS
-+    return job->cancelled;
++++ b/MAINTAINERS
-+}
+@@ -XXX,XX +XXX,XX @@ F: block/stream.c
-+
+ F: block/mirror.c
-+void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns)
+ F: qapi/job.json
-+{
+ F: block/block-copy.c
-+    assert(job->busy);
+-F: include/block/block-copy.c
-+
++F: include/block/block-copy.h
-+    /* Check cancellation *before* setting busy = false, too!  */
++F: block/reqlist.c
-+    if (block_job_is_cancelled(job)) {
++F: include/block/reqlist.h
-+        return;
+ F: block/copy-before-write.h
-+    }
+ F: block/copy-before-write.c
-+
+ F: include/block/aio_task.h
-+    job->busy = false;
+diff --git a/block/meson.build b/block/meson.build
-+    if (!block_job_should_pause(job)) {
+index XXXXXXX..XXXXXXX 100644
-+        co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns);
+--- a/block/meson.build
-+    }
++++ b/block/meson.build
-+    job->busy = true;
+@@ -XXX,XX +XXX,XX @@ block_ss.add(files(
-+
+   'qcow2.c',
-+    block_job_pause_point(job);
+   'quorum.c',
-+}
+   'raw-format.c',
-+
++  'reqlist.c',
-+void block_job_yield(BlockJob *job)
+   'snapshot.c',
-+{
+   'throttle-groups.c',
-+    assert(job->busy);
+   'throttle.c',
 +
 +    /* Check cancellation *before* setting busy = false, too!  */
 +    if (block_job_is_cancelled(job)) {
 +        return;
 +    }
 +
 +    job->busy = false;
 +    if (!block_job_should_pause(job)) {
 +        qemu_coroutine_yield();
 +    }
 +    job->busy = true;
 +
 +    block_job_pause_point(job);
 +}
 +
  void block_job_event_ready(BlockJob *job)
  {
      job->ready = true;
 --
-.9.3
+.34.1

-New patch
+[PULL 14/23] block/reqlist: reqlist_find_conflict(): use ranges_overlap()
+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

-[Qemu-devel] [PULL 07/12] blockjob: introduce block_job_cancel_async, check iostatus invariants
+[PULL 15/23] block/dirty-bitmap: introduce bdrv_dirty_bitmap_status()
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-The new functions helps respecting the invariant that the coroutine
+Add a convenient function similar with bdrv_block_status() to get
-is entered with false user_resume, zero pause count and no error
+status of dirty bitmap.
 recorded in the iostatus.
-Resetting the iostatus is now common to all of block_job_cancel_async,
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-block_job_user_resume and block_job_iostatus_reset, albeit with slight
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-differences:
+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(+)
-- block_job_cancel_async resets the iostatus, and resumes the job if
+diff --git a/include/block/dirty-bitmap.h b/include/block/dirty-bitmap.h
 there was an error, but the coroutine is not restarted immediately.
 For example the caller may continue with a call to block_job_finish_sync.
 - block_job_user_resume resets the iostatus.  It wants to resume the job
 unconditionally, even if there was no error.
 - block_job_iostatus_reset doesn't resume the job at all.  Maybe that's
 a bug but it should be fixed separately.
 block_job_iostatus_reset does the least common denominator, so add some
 checking but otherwise leave it as the entry point for resetting the
 iostatus.
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Message-id: 20170508141310.8674-8-pbonzini@redhat.com
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 ---
  blockjob.c | 24 ++++++++++++++++++++----
 file changed, 20 insertions(+), 4 deletions(-)
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/include/block/dirty-bitmap.h
-+++ b/blockjob.c
++++ b/include/block/dirty-bitmap.h
-@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
+@@ -XXX,XX +XXX,XX @@ int64_t bdrv_dirty_bitmap_next_zero(BdrvDirtyBitmap *bitmap, int64_t offset,
-     block_job_unref(job);
+ 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);
  }
-+static void block_job_cancel_async(BlockJob *job)
++bool bdrv_dirty_bitmap_status(BdrvDirtyBitmap *bitmap, int64_t offset,
 +                              int64_t bytes, int64_t *count)
 +{
-+    if (job->iostatus != BLOCK_DEVICE_IO_STATUS_OK) {
++    return hbitmap_status(bitmap->bitmap, offset, bytes, count);
 +        block_job_iostatus_reset(job);
 +    }
 +    if (job->user_paused) {
 +        /* Do not call block_job_enter here, the caller will handle it.  */
 +        job->user_paused = false;
 +        job->pause_count--;
 +    }
 +    job->cancelled = true;
 +}
 +
- static void block_job_completed_txn_abort(BlockJob *job)
+ /**
   * 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)
  {
-     AioContext *ctx;
+     return hb->count == 0;
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
               * them; this job, however, may or may not be cancelled, depending
               * on the caller, so leave it. */
              if (other_job != job) {
 -                other_job->cancelled = true;
 +                block_job_cancel_async(other_job);
              }
              continue;
          }
@@ -XXX,XX +XXX,XX @@ bool block_job_user_paused(BlockJob *job)
  void block_job_user_resume(BlockJob *job)
  {
      if (job && job->user_paused && job->pause_count > 0) {
 -        job->user_paused = false;
          block_job_iostatus_reset(job);
 +        job->user_paused = false;
          block_job_resume(job);
      }
  }
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job)
  void block_job_cancel(BlockJob *job)
  {
      if (block_job_started(job)) {
 -        job->cancelled = true;
 -        block_job_iostatus_reset(job);
 +        block_job_cancel_async(job);
          block_job_enter(job);
      } else {
          block_job_completed(job, -ECANCELED);
@@ -XXX,XX +XXX,XX @@ void block_job_yield(BlockJob *job)
  void block_job_iostatus_reset(BlockJob *job)
  {
 +    if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
 +        return;
 +    }
 +    assert(job->user_paused && job->pause_count > 0);
      job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
  }
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 03/12] blockjob: introduce block_job_early_fail
+[PULL 16/23] block/reqlist: add reqlist_wait_all()
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Outside blockjob.c, block_job_unref is only used when a block job fails
+Add function to wait for all intersecting requests.
-to start, and block_job_ref is not used at all.  The reference counting
+To be used in the further commit.
 thus is pretty well hidden.  Introduce a separate function to be used
 by block jobs; because block_job_ref and block_job_unref now become
 static, move them earlier in blockjob.c.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Nikita Lapshin <nikita.lapshin@virtuozzo.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Message-Id: <20220303194349.2304213-10-vsementsov@virtuozzo.com>
-Message-id: 20170508141310.8674-4-pbonzini@redhat.com
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 ---
- block/backup.c               |  2 +-
+ include/block/reqlist.h | 8 ++++++++
- block/commit.c               |  2 +-
+ block/reqlist.c         | 8 ++++++++
- block/mirror.c               |  2 +-
+files changed, 16 insertions(+)
  blockjob.c                   | 47 ++++++++++++++++++++++++++------------------
  include/block/blockjob_int.h | 15 +++-----------
  tests/test-blockjob.c        | 10 +++++-----
 files changed, 39 insertions(+), 39 deletions(-)
-diff --git a/block/backup.c b/block/backup.c
+diff --git a/include/block/reqlist.h b/include/block/reqlist.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/backup.c
+--- a/include/block/reqlist.h
-+++ b/block/backup.c
++++ b/include/block/reqlist.h
-@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ BlockReq *reqlist_find_conflict(BlockReqList *reqs, int64_t offset,
-     }
+ bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
-     if (job) {
+                                    int64_t bytes, CoMutex *lock);
-         backup_clean(&job->common);
--        block_job_unref(&job->common);
++/*
-+        block_job_early_fail(&job->common);
++ * 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.
-     return NULL;
++ */
-diff --git a/block/commit.c b/block/commit.c
++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/commit.c
+--- a/block/reqlist.c
-+++ b/block/commit.c
++++ b/block/reqlist.c
-@@ -XXX,XX +XXX,XX @@ fail:
+@@ -XXX,XX +XXX,XX @@ bool coroutine_fn reqlist_wait_one(BlockReqList *reqs, int64_t offset,
-     if (commit_top_bs) {
+     return true;
          bdrv_set_backing_hd(overlay_bs, top, &error_abort);
      }
 -    block_job_unref(&s->common);
 +    block_job_early_fail(&s->common);
  }
++void coroutine_fn reqlist_wait_all(BlockReqList *reqs, int64_t offset,
-diff --git a/block/mirror.c b/block/mirror.c
++                                   int64_t bytes, CoMutex *lock)
 index XXXXXXX..XXXXXXX 100644
 --- a/block/mirror.c
 +++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ fail:
          g_free(s->replaces);
          blk_unref(s->target);
 -        block_job_unref(&s->common);
 +        block_job_early_fail(&s->common);
      }
      bdrv_child_try_set_perm(mirror_top_bs->backing, 0, BLK_PERM_ALL,
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ BlockJob *block_job_get(const char *id)
      return NULL;
  }
 +static void block_job_ref(BlockJob *job)
 +{
-+    ++job->refcnt;
++    while (reqlist_wait_one(reqs, offset, bytes, lock)) {
-+}
++        /* continue */
 +
 +static void block_job_attached_aio_context(AioContext *new_context,
 +                                           void *opaque);
 +static void block_job_detach_aio_context(void *opaque);
 +
 +static void block_job_unref(BlockJob *job)
 +{
 +    if (--job->refcnt == 0) {
 +        BlockDriverState *bs = blk_bs(job->blk);
 +        bs->job = NULL;
 +        block_job_remove_all_bdrv(job);
 +        blk_remove_aio_context_notifier(job->blk,
 +                                        block_job_attached_aio_context,
 +                                        block_job_detach_aio_context, job);
 +        blk_unref(job->blk);
 +        error_free(job->blocker);
 +        g_free(job->id);
 +        QLIST_REMOVE(job, job_list);
 +        g_free(job);
 +    }
 +}
 +
- static void block_job_attached_aio_context(AioContext *new_context,
+ void coroutine_fn reqlist_shrink_req(BlockReq *req, int64_t new_bytes)
                                             void *opaque)
  {
-@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
+     if (new_bytes == req->bytes) {
      bdrv_coroutine_enter(blk_bs(job->blk), job->co);
  }
 -void block_job_ref(BlockJob *job)
 +void block_job_early_fail(BlockJob *job)
  {
 -    ++job->refcnt;
 -}
 -
 -void block_job_unref(BlockJob *job)
 -{
 -    if (--job->refcnt == 0) {
 -        BlockDriverState *bs = blk_bs(job->blk);
 -        bs->job = NULL;
 -        block_job_remove_all_bdrv(job);
 -        blk_remove_aio_context_notifier(job->blk,
 -                                        block_job_attached_aio_context,
 -                                        block_job_detach_aio_context, job);
 -        blk_unref(job->blk);
 -        error_free(job->blocker);
 -        g_free(job->id);
 -        QLIST_REMOVE(job, job_list);
 -        g_free(job);
 -    }
 +    block_job_unref(job);
  }
  static void block_job_completed_single(BlockJob *job)
 diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/blockjob_int.h
 +++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns);
  void block_job_yield(BlockJob *job);
  /**
 - * block_job_ref:
 + * block_job_early_fail:
   * @bs: The block device.
   *
 - * Grab a reference to the block job. Should be paired with block_job_unref.
 + * The block job could not be started, free it.
   */
 -void block_job_ref(BlockJob *job);
 -
 -/**
 - * block_job_unref:
 - * @bs: The block device.
 - *
 - * Release reference to the block job and release resources if it is the last
 - * reference.
 - */
 -void block_job_unref(BlockJob *job);
 +void block_job_early_fail(BlockJob *job);
  /**
   * block_job_completed:
 diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob.c
 +++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static void test_job_ids(void)
      job[1] = do_test_id(blk[1], "id0", false);
      /* But once job[0] finishes we can reuse its ID */
 -    block_job_unref(job[0]);
 +    block_job_early_fail(job[0]);
      job[1] = do_test_id(blk[1], "id0", true);
      /* No job ID specified, defaults to the backend name ('drive1') */
 -    block_job_unref(job[1]);
 +    block_job_early_fail(job[1]);
      job[1] = do_test_id(blk[1], NULL, true);
      /* Duplicate job ID */
@@ -XXX,XX +XXX,XX @@ static void test_job_ids(void)
      /* This one is valid */
      job[2] = do_test_id(blk[2], "id_2", true);
 -    block_job_unref(job[0]);
 -    block_job_unref(job[1]);
 -    block_job_unref(job[2]);
 +    block_job_early_fail(job[0]);
 +    block_job_early_fail(job[1]);
 +    block_job_early_fail(job[2]);
      destroy_blk(blk[0]);
      destroy_blk(blk[1]);
 --
-.9.3
+.34.1

-[Qemu-devel] [PULL 04/12] blockjob: introduce block_job_pause/resume_all
+[PULL 17/23] block/io: introduce block driver snapshot-access API
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Remove use of block_job_pause/resume from outside blockjob.c, thus
+Add new block driver handlers and corresponding generic wrappers.
-making them static.  The new functions are used by the block layer,
+It will be used to allow copy-before-write filter to provide
-so place them in blockjob_int.h.
+reach fleecing interface in further commit.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+In future this approach may be used to allow reading qcow2 internal
-Reviewed-by: John Snow <jsnow@redhat.com>
+snapshots, for example to export them through NBD.
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-id: 20170508141310.8674-5-pbonzini@redhat.com
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-Signed-off-by: Jeff Cody <jcody@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>
 ---
- block/io.c                   |  19 ++------
+ include/block/block_int-common.h | 18 ++++++++
- blockjob.c                   | 114 ++++++++++++++++++++++++++-----------------
+ include/block/block_int-io.h     |  9 ++++
- include/block/blockjob.h     |  16 ------
+ block/io.c                       | 72 ++++++++++++++++++++++++++++++++
- include/block/blockjob_int.h |  14 ++++++
+files changed, 99 insertions(+)
 files changed, 86 insertions(+), 77 deletions(-)
+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 @@
+@@ -XXX,XX +XXX,XX @@ void bdrv_cancel_in_flight(BlockDriverState *bs)
- #include "trace.h"
+         bs->drv->bdrv_cancel_in_flight(bs);
  #include "sysemu/block-backend.h"
  #include "block/blockjob.h"
 +#include "block/blockjob_int.h"
  #include "block/block_int.h"
  #include "qemu/cutils.h"
  #include "qapi/error.h"
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
      bool waited = true;
      BlockDriverState *bs;
      BdrvNextIterator it;
 -    BlockJob *job = NULL;
      GSList *aio_ctxs = NULL, *ctx;
 -    while ((job = block_job_next(job))) {
 -        AioContext *aio_context = blk_get_aio_context(job->blk);
 -
 -        aio_context_acquire(aio_context);
 -        block_job_pause(job);
 -        aio_context_release(aio_context);
 -    }
 +    block_job_pause_all();
      for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
          AioContext *aio_context = bdrv_get_aio_context(bs);
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
  {
      BlockDriverState *bs;
      BdrvNextIterator it;
 -    BlockJob *job = NULL;
      for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
          AioContext *aio_context = bdrv_get_aio_context(bs);
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
          aio_context_release(aio_context);
      }
--    while ((job = block_job_next(job))) {
--        AioContext *aio_context = blk_get_aio_context(job->blk);
--
--        aio_context_acquire(aio_context);
--        block_job_resume(job);
--        aio_context_release(aio_context);
--    }
-+    block_job_resume_all();
  }
++
- void bdrv_drain_all(void)
++int coroutine_fn
-diff --git a/blockjob.c b/blockjob.c
++bdrv_co_preadv_snapshot(BdrvChild *child, int64_t offset, int64_t bytes,
-index XXXXXXX..XXXXXXX 100644
++                        QEMUIOVector *qiov, size_t qiov_offset)
 --- a/blockjob.c
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ struct BlockJobTxn {
  static QLIST_HEAD(, BlockJob) block_jobs = QLIST_HEAD_INITIALIZER(block_jobs);
 -static char *child_job_get_parent_desc(BdrvChild *c)
 -{
 -    BlockJob *job = c->opaque;
 -    return g_strdup_printf("%s job '%s'",
 -                           BlockJobType_lookup[job->driver->job_type],
 -                           job->id);
 -}
 -
 -static const BdrvChildRole child_job = {
 -    .get_parent_desc    = child_job_get_parent_desc,
 -    .stay_at_node       = true,
 -};
 -
 -static void block_job_drained_begin(void *opaque)
 -{
 -    BlockJob *job = opaque;
 -    block_job_pause(job);
 -}
 -
 -static void block_job_drained_end(void *opaque)
 -{
 -    BlockJob *job = opaque;
 -    block_job_resume(job);
 -}
 -
 -static const BlockDevOps block_job_dev_ops = {
 -    .drained_begin = block_job_drained_begin,
 -    .drained_end = block_job_drained_end,
 -};
 -
  BlockJob *block_job_next(BlockJob *job)
  {
      if (!job) {
@@ -XXX,XX +XXX,XX @@ BlockJob *block_job_get(const char *id)
      return NULL;
  }
 +static void block_job_pause(BlockJob *job)
 +{
-+    job->pause_count++;
++    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;
 +}
 +
-+static void block_job_resume(BlockJob *job)
++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)
 +{
-+    assert(job->pause_count > 0);
++    BlockDriver *drv = bs->drv;
-+    job->pause_count--;
++    int ret;
-+    if (job->pause_count) {
++    IO_CODE();
-+        return;
++
 +    if (!drv) {
 +        return -ENOMEDIUM;
 +    }
-+    block_job_enter(job);
++
 +    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;
 +}
 +
- static void block_job_ref(BlockJob *job)
++int coroutine_fn
- {
++bdrv_co_pdiscard_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes)
      ++job->refcnt;
@@ -XXX,XX +XXX,XX @@ static void block_job_detach_aio_context(void *opaque)
      block_job_unref(job);
  }
 +static char *child_job_get_parent_desc(BdrvChild *c)
 +{
-+    BlockJob *job = c->opaque;
++    BlockDriver *drv = bs->drv;
-+    return g_strdup_printf("%s job '%s'",
++    int ret;
-+                           BlockJobType_lookup[job->driver->job_type],
++    IO_CODE();
-+                           job->id);
++
 +    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;
 +}
-+
-+static const BdrvChildRole child_job = {
-+    .get_parent_desc    = child_job_get_parent_desc,
-+    .stay_at_node       = true,
-+};
-+
-+static void block_job_drained_begin(void *opaque)
-+{
-+    BlockJob *job = opaque;
-+    block_job_pause(job);
-+}
-+
-+static void block_job_drained_end(void *opaque)
-+{
-+    BlockJob *job = opaque;
-+    block_job_resume(job);
-+}
-+
-+static const BlockDevOps block_job_dev_ops = {
-+    .drained_begin = block_job_drained_begin,
-+    .drained_end = block_job_drained_end,
-+};
-+
- void block_job_remove_all_bdrv(BlockJob *job)
- {
-     GSList *l;
-@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
-     job->driver->complete(job, errp);
- }
--void block_job_pause(BlockJob *job)
--{
--    job->pause_count++;
--}
--
- void block_job_user_pause(BlockJob *job)
- {
-     job->user_paused = true;
-@@ -XXX,XX +XXX,XX @@ void coroutine_fn block_job_pause_point(BlockJob *job)
-     }
- }
--void block_job_resume(BlockJob *job)
--{
--    assert(job->pause_count > 0);
--    job->pause_count--;
--    if (job->pause_count) {
--        return;
--    }
--    block_job_enter(job);
--}
--
- void block_job_user_resume(BlockJob *job)
- {
-     if (job && job->user_paused && job->pause_count > 0) {
-@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(BlockJob *job, const char *msg)
-                                         &error_abort);
- }
-+void block_job_pause_all(void)
-+{
-+    BlockJob *job = NULL;
-+    while ((job = block_job_next(job))) {
-+        AioContext *aio_context = blk_get_aio_context(job->blk);
-+
-+        aio_context_acquire(aio_context);
-+        block_job_pause(job);
-+        aio_context_release(aio_context);
-+    }
-+}
-+
-+void block_job_resume_all(void)
-+{
-+    BlockJob *job = NULL;
-+    while ((job = block_job_next(job))) {
-+        AioContext *aio_context = blk_get_aio_context(job->blk);
-+
-+        aio_context_acquire(aio_context);
-+        block_job_resume(job);
-+        aio_context_release(aio_context);
-+    }
-+}
-+
- void block_job_event_ready(BlockJob *job)
- {
-     job->ready = true;
-diff --git a/include/block/blockjob.h b/include/block/blockjob.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob.h
-+++ b/include/block/blockjob.h
-@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp);
- BlockJobInfo *block_job_query(BlockJob *job, Error **errp);
- /**
-- * block_job_pause:
-- * @job: The job to be paused.
-- *
-- * Asynchronously pause the specified job.
-- */
--void block_job_pause(BlockJob *job);
--
--/**
-  * block_job_user_pause:
-  * @job: The job to be paused.
-  *
-@@ -XXX,XX +XXX,XX @@ void block_job_user_pause(BlockJob *job);
- bool block_job_user_paused(BlockJob *job);
- /**
-- * block_job_resume:
-- * @job: The job to be resumed.
-- *
-- * Resume the specified job.  Must be paired with a preceding block_job_pause.
-- */
--void block_job_resume(BlockJob *job);
--
--/**
-  * block_job_user_resume:
-  * @job: The job to be resumed.
-  *
-diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob_int.h
-+++ b/include/block/blockjob_int.h
-@@ -XXX,XX +XXX,XX @@ void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns);
- void block_job_yield(BlockJob *job);
- /**
-+ * block_job_pause_all:
-+ *
-+ * Asynchronously pause all jobs.
-+ */
-+void block_job_pause_all(void);
-+
-+/**
-+ * block_job_resume_all:
-+ *
-+ * Resume all block jobs.  Must be paired with a preceding block_job_pause_all.
-+ */
-+void block_job_resume_all(void);
-+
-+/**
-  * block_job_early_fail:
-  * @bs: The block device.
-  *
 --
-.9.3
+.34.1

-New patch
+[PULL 18/23] block: introduce snapshot-access block driver
+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:
 [guest]                   [NBD export]
    |                            |
    | root                       | root
    v                 file       v
 [copy-before-write]<------[snapshot-access]
    |           |
    | file      | target
    v           v
 [active-disk] [temp.img]
 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 +
 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',
 --
 .34.1

-[Qemu-devel] [PULL 08/12] blockjob: group BlockJob transaction functions together
+[PULL 19/23] block: copy-before-write: realize snapshot-access API
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Yet another pure code movement patch, preparing for the next change.
+Current scheme of image fleecing looks like this:
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+[guest]                    [NBD export]
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+  |                              |
-Message-id: 20170508141310.8674-9-pbonzini@redhat.com
+  |root                          | root
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+  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>
 ---
- blockjob.c | 128 ++++++++++++++++++++++++++++++-------------------------------
+ block/copy-before-write.c  | 212 ++++++++++++++++++++++++++++++++++-
-file changed, 64 insertions(+), 64 deletions(-)
+ tests/qemu-iotests/257.out | 224 +++++++++++++++++++++++++++++++++++++
+files changed, 435 insertions(+), 1 deletion(-)
-diff --git a/blockjob.c b/blockjob.c
 diff --git a/block/copy-before-write.c b/block/copy-before-write.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/block/copy-before-write.c
-+++ b/blockjob.c
++++ b/block/copy-before-write.c
-@@ -XXX,XX +XXX,XX @@ BlockJob *block_job_get(const char *id)
+@@ -XXX,XX +XXX,XX @@
-     return NULL;
+ #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);
  }
-+BlockJobTxn *block_job_txn_new(void)
++/*
 + * 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)
 +{
-+    BlockJobTxn *txn = g_new0(BlockJobTxn, 1);
++    BDRVCopyBeforeWriteState *s = bs->opaque;
-+    QLIST_INIT(&txn->jobs);
++    BlockReq *req = g_new(BlockReq, 1);
-+    txn->refcnt = 1;
++    bool done;
-+    return txn;
++
 +    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 block_job_txn_ref(BlockJobTxn *txn)
++static void cbw_snapshot_read_unlock(BlockDriverState *bs, BlockReq *req)
 +{
-+    txn->refcnt++;
++    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);
 +}
 +
-+void block_job_txn_unref(BlockJobTxn *txn)
++static coroutine_fn int
 +cbw_co_preadv_snapshot(BlockDriverState *bs, int64_t offset, int64_t bytes,
 +                       QEMUIOVector *qiov, size_t qiov_offset)
 +{
-+    if (txn && --txn->refcnt == 0) {
++    BlockReq *req;
-+        g_free(txn);
++    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;
 +}
 +
-+void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job)
++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)
 +{
-+    if (!txn) {
++    BDRVCopyBeforeWriteState *s = bs->opaque;
-+        return;
++    BlockReq *req;
 +    }
 +
 +    assert(!job->txn);
 +    job->txn = txn;
 +
 +    QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
 +    block_job_txn_ref(txn);
 +}
 +
  static void block_job_pause(BlockJob *job)
  {
      job->pause_count++;
@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
      job->cancelled = true;
  }
 +static int block_job_finish_sync(BlockJob *job,
 +                                 void (*finish)(BlockJob *, Error **errp),
 +                                 Error **errp)
 +{
 +    Error *local_err = NULL;
 +    int ret;
-+
++    int64_t cur_bytes;
-+    assert(blk_bs(job->blk)->job == job);
++    BdrvChild *child;
 +
-+    block_job_ref(job);
++    req = cbw_snapshot_read_lock(bs, offset, bytes, &cur_bytes, &child);
-+
++    if (!req) {
-+    finish(job, &local_err);
++        return -EACCES;
-+    if (local_err) {
++    }
-+        error_propagate(errp, local_err);
++
-+        block_job_unref(job);
++    ret = bdrv_block_status(child->bs, offset, cur_bytes, pnum, map, file);
-+        return -EBUSY;
++    if (child == s->target) {
-+    }
++        /*
-+    /* block_job_drain calls block_job_enter, and it should be enough to
++         * We refer to s->target only for areas that we've written to it.
-+     * induce progress until the job completes or moves to the main thread.
++         * And we can not report unallocated blocks in s->target: this will
-+    */
++         * break generic block-status-above logic, that will go to
-+    while (!job->deferred_to_main_loop && !job->completed) {
++         * copy-before-write filtered child in this case.
-+        block_job_drain(job);
++         */
-+    }
++        assert(ret & BDRV_BLOCK_ALLOCATED);
-+    while (!job->completed) {
++    }
-+        aio_poll(qemu_get_aio_context(), true);
++
-+    }
++    cbw_snapshot_read_unlock(bs, req);
-+    ret = (job->cancelled && job->ret == 0) ? -ECANCELED : job->ret;
++
 +    block_job_unref(job);
 +    return ret;
 +}
 +
- static void block_job_completed_txn_abort(BlockJob *job)
++static int coroutine_fn cbw_co_pdiscard_snapshot(BlockDriverState *bs,
- {
++                                                 int64_t offset, int64_t bytes)
-     AioContext *ctx;
++{
-@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
++    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;
  }
--static int block_job_finish_sync(BlockJob *job,
+@@ -XXX,XX +XXX,XX @@ static void cbw_close(BlockDriverState *bs)
--                                 void (*finish)(BlockJob *, Error **errp),
+ {
--                                 Error **errp)
+     BDRVCopyBeforeWriteState *s = bs->opaque;
--{
--    Error *local_err = NULL;
++    bdrv_release_dirty_bitmap(s->access_bitmap);
--    int ret;
++    bdrv_release_dirty_bitmap(s->done_bitmap);
--
++
--    assert(blk_bs(job->blk)->job == job);
+     block_copy_state_free(s->bcs);
--
+     s->bcs = NULL;
 -    block_job_ref(job);
 -
 -    finish(job, &local_err);
 -    if (local_err) {
 -        error_propagate(errp, local_err);
 -        block_job_unref(job);
 -        return -EBUSY;
 -    }
 -    /* block_job_drain calls block_job_enter, and it should be enough to
 -     * induce progress until the job completes or moves to the main thread.
 -    */
 -    while (!job->deferred_to_main_loop && !job->completed) {
 -        block_job_drain(job);
 -    }
 -    while (!job->completed) {
 -        aio_poll(qemu_get_aio_context(), true);
 -    }
 -    ret = (job->cancelled && job->ret == 0) ? -ECANCELED : job->ret;
 -    block_job_unref(job);
 -    return ret;
 -}
 -
  /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
   * used with block_job_finish_sync() without the need for (rather nasty)
   * function pointer casts there. */
@@ -XXX,XX +XXX,XX @@ void block_job_defer_to_main_loop(BlockJob *job,
      aio_bh_schedule_oneshot(qemu_get_aio_context(),
                              block_job_defer_to_main_loop_bh, data);
  }
--
+@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_cbw_filter = {
--BlockJobTxn *block_job_txn_new(void)
+     .bdrv_co_pdiscard           = cbw_co_pdiscard,
--{
+     .bdrv_co_flush              = cbw_co_flush,
--    BlockJobTxn *txn = g_new0(BlockJobTxn, 1);
--    QLIST_INIT(&txn->jobs);
++    .bdrv_co_preadv_snapshot       = cbw_co_preadv_snapshot,
--    txn->refcnt = 1;
++    .bdrv_co_pdiscard_snapshot     = cbw_co_pdiscard_snapshot,
--    return txn;
++    .bdrv_co_snapshot_block_status = cbw_co_snapshot_block_status,
--}
++
--
+     .bdrv_refresh_filename      = cbw_refresh_filename,
--static void block_job_txn_ref(BlockJobTxn *txn)
--{
+     .bdrv_child_perm            = cbw_child_perm,
--    txn->refcnt++;
+diff --git a/tests/qemu-iotests/257.out b/tests/qemu-iotests/257.out
--}
+index XXXXXXX..XXXXXXX 100644
--
+--- a/tests/qemu-iotests/257.out
--void block_job_txn_unref(BlockJobTxn *txn)
++++ b/tests/qemu-iotests/257.out
--{
+@@ -XXX,XX +XXX,XX @@ write -P0x67 0x3fe0000 0x20000
--    if (txn && --txn->refcnt == 0) {
+ {"return": ""}
--        g_free(txn);
+ {
--    }
+   "bitmaps": {
--}
++    "backup-top": [
--
++      {
--void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job)
++        "busy": false,
--{
++        "count": 67108864,
--    if (!txn) {
++        "granularity": 65536,
--        return;
++        "persistent": false,
--    }
++        "recording": false
--
++      },
--    assert(!job->txn);
++      {
--    job->txn = txn;
++        "busy": false,
--
++        "count": 458752,
--    QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
++        "granularity": 65536,
--    block_job_txn_ref(txn);
++        "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,
 --
-.9.3
+.34.1

-New patch
+[PULL 20/23] iotests/image-fleecing: add test-case for fleecing format node
+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

-New patch
+[PULL 21/23] iotests.py: add qemu_io_pipe_and_status()
+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

-New patch
+[PULL 22/23] iotests/image-fleecing: add test case with bitmap
+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

-New patch
+[PULL 23/23] iotests/image-fleecing: test push backup with fleecing
+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 9964e96dc9999cf7f7c936ee854a795415d19b60:

Merge remote-tracking branch 'jasowang/tags/net-pull-request' into staging (2017-05-23 15:01:31 +0100)

are available in the git repository at:

git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request

for you to fetch changes up to 223a23c198787328ae75bc65d84edf5fde33c0b6:

block/gluster: glfs_lseek() workaround (2017-05-24 16:44:46 -0400)

----------------------------------------------------------------
Block patches
----------------------------------------------------------------

Jeff Cody (1):
  block/gluster: glfs_lseek() workaround

Paolo Bonzini (11):
  blockjob: remove unnecessary check
  blockjob: remove iostatus_reset callback
  blockjob: introduce block_job_early_fail
  blockjob: introduce block_job_pause/resume_all
  blockjob: separate monitor and blockjob APIs
  blockjob: move iostatus reset inside block_job_user_resume
  blockjob: introduce block_job_cancel_async, check iostatus invariants
  blockjob: group BlockJob transaction functions together
  blockjob: strengthen a bit test-blockjob-txn
  blockjob: reorganize block_job_completed_txn_abort
  blockjob: use deferred_to_main_loop to indicate the coroutine has
    ended

-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

This is unused since commit 66a0fae ("blockjob: Don't touch BDS iostatus",
2016-05-19).

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Message-id: 20170508141310.8674-3-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 blockjob.c                   | 3 ---
 include/block/blockjob_int.h | 3 ---
 2 files changed, 6 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ bool block_job_is_cancelled(BlockJob *job)
 void block_job_iostatus_reset(BlockJob *job)
 {
     job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
-    if (job->driver->iostatus_reset) {
-        job->driver->iostatus_reset(job);
-    }
 }
 
 static int block_job_finish_sync(BlockJob *job,
diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob_int.h
+++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockJobDriver {
     /** Optional callback for job types that support setting a speed limit */
     void (*set_speed)(BlockJob *job, int64_t speed, Error **errp);
 
-    /** Optional callback for job types that need to forward I/O status reset */
-    void (*iostatus_reset)(BlockJob *job);
-
     /** Mandatory: Entrypoint for the Coroutine. */
     CoroutineEntry *start;
 
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Outside blockjob.c, block_job_unref is only used when a block job fails
to start, and block_job_ref is not used at all.  The reference counting
thus is pretty well hidden.  Introduce a separate function to be used
by block jobs; because block_job_ref and block_job_unref now become
static, move them earlier in blockjob.c.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Message-id: 20170508141310.8674-4-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/backup.c               |  2 +-
 block/commit.c               |  2 +-
 block/mirror.c               |  2 +-
 blockjob.c                   | 47 ++++++++++++++++++++++++++------------------
 include/block/blockjob_int.h | 15 +++-----------
 tests/test-blockjob.c        | 10 +++++-----
 6 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
     }
     if (job) {
         backup_clean(&job->common);
-        block_job_unref(&job->common);
+        block_job_early_fail(&job->common);
     }
 
     return NULL;
diff --git a/block/commit.c b/block/commit.c
index XXXXXXX..XXXXXXX 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -XXX,XX +XXX,XX @@ fail:
     if (commit_top_bs) {
         bdrv_set_backing_hd(overlay_bs, top, &error_abort);
     }
-    block_job_unref(&s->common);
+    block_job_early_fail(&s->common);
 }
 
 
diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ fail:
 
         g_free(s->replaces);
         blk_unref(s->target);
-        block_job_unref(&s->common);
+        block_job_early_fail(&s->common);
     }
 
     bdrv_child_try_set_perm(mirror_top_bs->backing, 0, BLK_PERM_ALL,
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ BlockJob *block_job_get(const char *id)
     return NULL;
 }
 
+static void block_job_ref(BlockJob *job)
+{
+    ++job->refcnt;
+}
+
+static void block_job_attached_aio_context(AioContext *new_context,
+                                           void *opaque);
+static void block_job_detach_aio_context(void *opaque);
+
+static void block_job_unref(BlockJob *job)
+{
+    if (--job->refcnt == 0) {
+        BlockDriverState *bs = blk_bs(job->blk);
+        bs->job = NULL;
+        block_job_remove_all_bdrv(job);
+        blk_remove_aio_context_notifier(job->blk,
+                                        block_job_attached_aio_context,
+                                        block_job_detach_aio_context, job);
+        blk_unref(job->blk);
+        error_free(job->blocker);
+        g_free(job->id);
+        QLIST_REMOVE(job, job_list);
+        g_free(job);
+    }
+}
+
 static void block_job_attached_aio_context(AioContext *new_context,
                                            void *opaque)
 {
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
     bdrv_coroutine_enter(blk_bs(job->blk), job->co);
 }
 
-void block_job_ref(BlockJob *job)
+void block_job_early_fail(BlockJob *job)
 {
-    ++job->refcnt;
-}
-
-void block_job_unref(BlockJob *job)
-{
-    if (--job->refcnt == 0) {
-        BlockDriverState *bs = blk_bs(job->blk);
-        bs->job = NULL;
-        block_job_remove_all_bdrv(job);
-        blk_remove_aio_context_notifier(job->blk,
-                                        block_job_attached_aio_context,
-                                        block_job_detach_aio_context, job);
-        blk_unref(job->blk);
-        error_free(job->blocker);
-        g_free(job->id);
-        QLIST_REMOVE(job, job_list);
-        g_free(job);
-    }
+    block_job_unref(job);
 }
 
 static void block_job_completed_single(BlockJob *job)
diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob_int.h
+++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns);
 void block_job_yield(BlockJob *job);
 
 /**
- * block_job_ref:
+ * block_job_early_fail:
  * @bs: The block device.
  *
- * Grab a reference to the block job. Should be paired with block_job_unref.
+ * The block job could not be started, free it.
  */
-void block_job_ref(BlockJob *job);
-
-/**
- * block_job_unref:
- * @bs: The block device.
- *
- * Release reference to the block job and release resources if it is the last
- * reference.
- */
-void block_job_unref(BlockJob *job);
+void block_job_early_fail(BlockJob *job);
 
 /**
  * block_job_completed:
diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob.c
+++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static void test_job_ids(void)
     job[1] = do_test_id(blk[1], "id0", false);
 
     /* But once job[0] finishes we can reuse its ID */
-    block_job_unref(job[0]);
+    block_job_early_fail(job[0]);
     job[1] = do_test_id(blk[1], "id0", true);
 
     /* No job ID specified, defaults to the backend name ('drive1') */
-    block_job_unref(job[1]);
+    block_job_early_fail(job[1]);
     job[1] = do_test_id(blk[1], NULL, true);
 
     /* Duplicate job ID */
@@ -XXX,XX +XXX,XX @@ static void test_job_ids(void)
     /* This one is valid */
     job[2] = do_test_id(blk[2], "id_2", true);
 
-    block_job_unref(job[0]);
-    block_job_unref(job[1]);
-    block_job_unref(job[2]);
+    block_job_early_fail(job[0]);
+    block_job_early_fail(job[1]);
+    block_job_early_fail(job[2]);
 
     destroy_blk(blk[0]);
     destroy_blk(blk[1]);
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Remove use of block_job_pause/resume from outside blockjob.c, thus
making them static.  The new functions are used by the block layer,
so place them in blockjob_int.h.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Message-id: 20170508141310.8674-5-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/io.c                   |  19 ++------
 blockjob.c                   | 114 ++++++++++++++++++++++++++-----------------
 include/block/blockjob.h     |  16 ------
 include/block/blockjob_int.h |  14 ++++++
 4 files changed, 86 insertions(+), 77 deletions(-)

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 @@
 #include "trace.h"
 #include "sysemu/block-backend.h"
 #include "block/blockjob.h"
+#include "block/blockjob_int.h"
 #include "block/block_int.h"
 #include "qemu/cutils.h"
 #include "qapi/error.h"
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
     bool waited = true;
     BlockDriverState *bs;
     BdrvNextIterator it;
-    BlockJob *job = NULL;
     GSList *aio_ctxs = NULL, *ctx;
 
-    while ((job = block_job_next(job))) {
-        AioContext *aio_context = blk_get_aio_context(job->blk);
-
-        aio_context_acquire(aio_context);
-        block_job_pause(job);
-        aio_context_release(aio_context);
-    }
+    block_job_pause_all();
 
     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
         AioContext *aio_context = bdrv_get_aio_context(bs);
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
 {
     BlockDriverState *bs;
     BdrvNextIterator it;
-    BlockJob *job = NULL;
 
     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
         AioContext *aio_context = bdrv_get_aio_context(bs);
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
         aio_context_release(aio_context);
     }
 
-    while ((job = block_job_next(job))) {
-        AioContext *aio_context = blk_get_aio_context(job->blk);
-
-        aio_context_acquire(aio_context);
-        block_job_resume(job);
-        aio_context_release(aio_context);
-    }
+    block_job_resume_all();
 }
 
 void bdrv_drain_all(void)
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ struct BlockJobTxn {
 
 static QLIST_HEAD(, BlockJob) block_jobs = QLIST_HEAD_INITIALIZER(block_jobs);
 
-static char *child_job_get_parent_desc(BdrvChild *c)
-{
-    BlockJob *job = c->opaque;
-    return g_strdup_printf("%s job '%s'",
-                           BlockJobType_lookup[job->driver->job_type],
-                           job->id);
-}
-
-static const BdrvChildRole child_job = {
-    .get_parent_desc    = child_job_get_parent_desc,
-    .stay_at_node       = true,
-};
-
-static void block_job_drained_begin(void *opaque)
-{
-    BlockJob *job = opaque;
-    block_job_pause(job);
-}
-
-static void block_job_drained_end(void *opaque)
-{
-    BlockJob *job = opaque;
-    block_job_resume(job);
-}
-
-static const BlockDevOps block_job_dev_ops = {
-    .drained_begin = block_job_drained_begin,
-    .drained_end = block_job_drained_end,
-};
-
 BlockJob *block_job_next(BlockJob *job)
 {
     if (!job) {
@@ -XXX,XX +XXX,XX @@ BlockJob *block_job_get(const char *id)
     return NULL;
 }
 
+static void block_job_pause(BlockJob *job)
+{
+    job->pause_count++;
+}
+
+static void block_job_resume(BlockJob *job)
+{
+    assert(job->pause_count > 0);
+    job->pause_count--;
+    if (job->pause_count) {
+        return;
+    }
+    block_job_enter(job);
+}
+
 static void block_job_ref(BlockJob *job)
 {
     ++job->refcnt;
@@ -XXX,XX +XXX,XX @@ static void block_job_detach_aio_context(void *opaque)
     block_job_unref(job);
 }
 
+static char *child_job_get_parent_desc(BdrvChild *c)
+{
+    BlockJob *job = c->opaque;
+    return g_strdup_printf("%s job '%s'",
+                           BlockJobType_lookup[job->driver->job_type],
+                           job->id);
+}
+
+static const BdrvChildRole child_job = {
+    .get_parent_desc    = child_job_get_parent_desc,
+    .stay_at_node       = true,
+};
+
+static void block_job_drained_begin(void *opaque)
+{
+    BlockJob *job = opaque;
+    block_job_pause(job);
+}
+
+static void block_job_drained_end(void *opaque)
+{
+    BlockJob *job = opaque;
+    block_job_resume(job);
+}
+
+static const BlockDevOps block_job_dev_ops = {
+    .drained_begin = block_job_drained_begin,
+    .drained_end = block_job_drained_end,
+};
+
 void block_job_remove_all_bdrv(BlockJob *job)
 {
     GSList *l;
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp)
     job->driver->complete(job, errp);
 }
 
-void block_job_pause(BlockJob *job)
-{
-    job->pause_count++;
-}
-
 void block_job_user_pause(BlockJob *job)
 {
     job->user_paused = true;
@@ -XXX,XX +XXX,XX @@ void coroutine_fn block_job_pause_point(BlockJob *job)
     }
 }
 
-void block_job_resume(BlockJob *job)
-{
-    assert(job->pause_count > 0);
-    job->pause_count--;
-    if (job->pause_count) {
-        return;
-    }
-    block_job_enter(job);
-}
-
 void block_job_user_resume(BlockJob *job)
 {
     if (job && job->user_paused && job->pause_count > 0) {
@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(BlockJob *job, const char *msg)
                                         &error_abort);
 }
 
+void block_job_pause_all(void)
+{
+    BlockJob *job = NULL;
+    while ((job = block_job_next(job))) {
+        AioContext *aio_context = blk_get_aio_context(job->blk);
+
+        aio_context_acquire(aio_context);
+        block_job_pause(job);
+        aio_context_release(aio_context);
+    }
+}
+
+void block_job_resume_all(void)
+{
+    BlockJob *job = NULL;
+    while ((job = block_job_next(job))) {
+        AioContext *aio_context = blk_get_aio_context(job->blk);
+
+        aio_context_acquire(aio_context);
+        block_job_resume(job);
+        aio_context_release(aio_context);
+    }
+}
+
 void block_job_event_ready(BlockJob *job)
 {
     job->ready = true;
diff --git a/include/block/blockjob.h b/include/block/blockjob.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob.h
+++ b/include/block/blockjob.h
@@ -XXX,XX +XXX,XX @@ void block_job_complete(BlockJob *job, Error **errp);
 BlockJobInfo *block_job_query(BlockJob *job, Error **errp);
 
 /**
- * block_job_pause:
- * @job: The job to be paused.
- *
- * Asynchronously pause the specified job.
- */
-void block_job_pause(BlockJob *job);
-
-/**
  * block_job_user_pause:
  * @job: The job to be paused.
  *
@@ -XXX,XX +XXX,XX @@ void block_job_user_pause(BlockJob *job);
 bool block_job_user_paused(BlockJob *job);
 
 /**
- * block_job_resume:
- * @job: The job to be resumed.
- *
- * Resume the specified job.  Must be paired with a preceding block_job_pause.
- */
-void block_job_resume(BlockJob *job);
-
-/**
  * block_job_user_resume:
  * @job: The job to be resumed.
  *
diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob_int.h
+++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns);
 void block_job_yield(BlockJob *job);
 
 /**
+ * block_job_pause_all:
+ *
+ * Asynchronously pause all jobs.
+ */
+void block_job_pause_all(void);
+
+/**
+ * block_job_resume_all:
+ *
+ * Resume all block jobs.  Must be paired with a preceding block_job_pause_all.
+ */
+void block_job_resume_all(void);
+
+/**
  * block_job_early_fail:
  * @bs: The block device.
  *
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

We have two different headers for block job operations, blockjob.h
and blockjob_int.h.  The former contains APIs called by the monitor,
the latter contains APIs called by the block job drivers and the
block layer itself.

Keep the two APIs separate in the blockjob.c file too.  This will
be useful when transitioning away from the AioContext lock, because
there will be locking policies for the two categories, too---the
monitor will have to call new block_job_lock/unlock APIs, while blockjob
APIs will take care of this for the users.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20170508141310.8674-6-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 blockjob.c | 390 ++++++++++++++++++++++++++++++++-----------------------------
 1 file changed, 205 insertions(+), 185 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ struct BlockJobTxn {
 
 static QLIST_HEAD(, BlockJob) block_jobs = QLIST_HEAD_INITIALIZER(block_jobs);
 
+/*
+ * The block job API is composed of two categories of functions.
+ *
+ * The first includes functions used by the monitor.  The monitor is
+ * peculiar in that it accesses the block job list with block_job_get, and
+ * therefore needs consistency across block_job_get and the actual operation
+ * (e.g. block_job_set_speed).  The consistency is achieved with
+ * aio_context_acquire/release.  These functions are declared in blockjob.h.
+ *
+ * The second includes functions used by the block job drivers and sometimes
+ * by the core block layer.  These do not care about locking, because the
+ * whole coroutine runs under the AioContext lock, and are declared in
+ * blockjob_int.h.
+ */
+
 BlockJob *block_job_next(BlockJob *job)
 {
     if (!job) {
@@ -XXX,XX +XXX,XX @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
     return 0;
 }
 
-void *block_job_create(const char *job_id, const BlockJobDriver *driver,
-                       BlockDriverState *bs, uint64_t perm,
-                       uint64_t shared_perm, int64_t speed, int flags,
-                       BlockCompletionFunc *cb, void *opaque, Error **errp)
-{
-    BlockBackend *blk;
-    BlockJob *job;
-    int ret;
-
-    if (bs->job) {
-        error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
-        return NULL;
-    }
-
-    if (job_id == NULL && !(flags & BLOCK_JOB_INTERNAL)) {
-        job_id = bdrv_get_device_name(bs);
-        if (!*job_id) {
-            error_setg(errp, "An explicit job ID is required for this node");
-            return NULL;
-        }
-    }
-
-    if (job_id) {
-        if (flags & BLOCK_JOB_INTERNAL) {
-            error_setg(errp, "Cannot specify job ID for internal block job");
-            return NULL;
-        }
-
-        if (!id_wellformed(job_id)) {
-            error_setg(errp, "Invalid job ID '%s'", job_id);
-            return NULL;
-        }
-
-        if (block_job_get(job_id)) {
-            error_setg(errp, "Job ID '%s' already in use", job_id);
-            return NULL;
-        }
-    }
-
-    blk = blk_new(perm, shared_perm);
-    ret = blk_insert_bs(blk, bs, errp);
-    if (ret < 0) {
-        blk_unref(blk);
-        return NULL;
-    }
-
-    job = g_malloc0(driver->instance_size);
-    job->driver        = driver;
-    job->id            = g_strdup(job_id);
-    job->blk           = blk;
-    job->cb            = cb;
-    job->opaque        = opaque;
-    job->busy          = false;
-    job->paused        = true;
-    job->pause_count   = 1;
-    job->refcnt        = 1;
-
-    error_setg(&job->blocker, "block device is in use by block job: %s",
-               BlockJobType_lookup[driver->job_type]);
-    block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
-    bs->job = job;
-
-    blk_set_dev_ops(blk, &block_job_dev_ops, job);
-    bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
-
-    QLIST_INSERT_HEAD(&block_jobs, job, job_list);
-
-    blk_add_aio_context_notifier(blk, block_job_attached_aio_context,
-                                 block_job_detach_aio_context, job);
-
-    /* Only set speed when necessary to avoid NotSupported error */
-    if (speed != 0) {
-        Error *local_err = NULL;
-
-        block_job_set_speed(job, speed, &local_err);
-        if (local_err) {
-            block_job_unref(job);
-            error_propagate(errp, local_err);
-            return NULL;
-        }
-    }
-    return job;
-}
-
 bool block_job_is_internal(BlockJob *job)
 {
     return (job->id == NULL);
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
     bdrv_coroutine_enter(blk_bs(job->blk), job->co);
 }
 
-void block_job_early_fail(BlockJob *job)
-{
-    block_job_unref(job);
-}
-
 static void block_job_completed_single(BlockJob *job)
 {
     if (!job->ret) {
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_success(BlockJob *job)
     }
 }
 
-void block_job_completed(BlockJob *job, int ret)
-{
-    assert(blk_bs(job->blk)->job == job);
-    assert(!job->completed);
-    job->completed = true;
-    job->ret = ret;
-    if (!job->txn) {
-        block_job_completed_single(job);
-    } else if (ret < 0 || block_job_is_cancelled(job)) {
-        block_job_completed_txn_abort(job);
-    } else {
-        block_job_completed_txn_success(job);
-    }
-}
-
 void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
 {
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ void block_job_user_pause(BlockJob *job)
     block_job_pause(job);
 }
 
-static bool block_job_should_pause(BlockJob *job)
-{
-    return job->pause_count > 0;
-}
-
 bool block_job_user_paused(BlockJob *job)
 {
     return job->user_paused;
 }
 
-void coroutine_fn block_job_pause_point(BlockJob *job)
-{
-    assert(job && block_job_started(job));
-
-    if (!block_job_should_pause(job)) {
-        return;
-    }
-    if (block_job_is_cancelled(job)) {
-        return;
-    }
-
-    if (job->driver->pause) {
-        job->driver->pause(job);
-    }
-
-    if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
-        job->paused = true;
-        job->busy = false;
-        qemu_coroutine_yield(); /* wait for block_job_resume() */
-        job->busy = true;
-        job->paused = false;
-    }
-
-    if (job->driver->resume) {
-        job->driver->resume(job);
-    }
-}
-
 void block_job_user_resume(BlockJob *job)
 {
     if (job && job->user_paused && job->pause_count > 0) {
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job)
     }
 }
 
-void block_job_enter(BlockJob *job)
-{
-    if (job->co && !job->busy) {
-        bdrv_coroutine_enter(blk_bs(job->blk), job->co);
-    }
-}
-
 void block_job_cancel(BlockJob *job)
 {
     if (block_job_started(job)) {
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
     }
 }
 
-bool block_job_is_cancelled(BlockJob *job)
-{
-    return job->cancelled;
-}
-
 void block_job_iostatus_reset(BlockJob *job)
 {
     job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
@@ -XXX,XX +XXX,XX @@ int block_job_complete_sync(BlockJob *job, Error **errp)
     return block_job_finish_sync(job, &block_job_complete, errp);
 }
 
-void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns)
-{
-    assert(job->busy);
-
-    /* Check cancellation *before* setting busy = false, too!  */
-    if (block_job_is_cancelled(job)) {
-        return;
-    }
-
-    job->busy = false;
-    if (!block_job_should_pause(job)) {
-        co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns);
-    }
-    job->busy = true;
-
-    block_job_pause_point(job);
-}
-
-void block_job_yield(BlockJob *job)
-{
-    assert(job->busy);
-
-    /* Check cancellation *before* setting busy = false, too!  */
-    if (block_job_is_cancelled(job)) {
-        return;
-    }
-
-    job->busy = false;
-    if (!block_job_should_pause(job)) {
-        qemu_coroutine_yield();
-    }
-    job->busy = true;
-
-    block_job_pause_point(job);
-}
-
 BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
 {
     BlockJobInfo *info;
@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(BlockJob *job, const char *msg)
                                         &error_abort);
 }
 
+/*
+ * API for block job drivers and the block layer.  These functions are
+ * declared in blockjob_int.h.
+ */
+
+void *block_job_create(const char *job_id, const BlockJobDriver *driver,
+                       BlockDriverState *bs, uint64_t perm,
+                       uint64_t shared_perm, int64_t speed, int flags,
+                       BlockCompletionFunc *cb, void *opaque, Error **errp)
+{
+    BlockBackend *blk;
+    BlockJob *job;
+    int ret;
+
+    if (bs->job) {
+        error_setg(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
+        return NULL;
+    }
+
+    if (job_id == NULL && !(flags & BLOCK_JOB_INTERNAL)) {
+        job_id = bdrv_get_device_name(bs);
+        if (!*job_id) {
+            error_setg(errp, "An explicit job ID is required for this node");
+            return NULL;
+        }
+    }
+
+    if (job_id) {
+        if (flags & BLOCK_JOB_INTERNAL) {
+            error_setg(errp, "Cannot specify job ID for internal block job");
+            return NULL;
+        }
+
+        if (!id_wellformed(job_id)) {
+            error_setg(errp, "Invalid job ID '%s'", job_id);
+            return NULL;
+        }
+
+        if (block_job_get(job_id)) {
+            error_setg(errp, "Job ID '%s' already in use", job_id);
+            return NULL;
+        }
+    }
+
+    blk = blk_new(perm, shared_perm);
+    ret = blk_insert_bs(blk, bs, errp);
+    if (ret < 0) {
+        blk_unref(blk);
+        return NULL;
+    }
+
+    job = g_malloc0(driver->instance_size);
+    job->driver        = driver;
+    job->id            = g_strdup(job_id);
+    job->blk           = blk;
+    job->cb            = cb;
+    job->opaque        = opaque;
+    job->busy          = false;
+    job->paused        = true;
+    job->pause_count   = 1;
+    job->refcnt        = 1;
+
+    error_setg(&job->blocker, "block device is in use by block job: %s",
+               BlockJobType_lookup[driver->job_type]);
+    block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
+    bs->job = job;
+
+    blk_set_dev_ops(blk, &block_job_dev_ops, job);
+    bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
+
+    QLIST_INSERT_HEAD(&block_jobs, job, job_list);
+
+    blk_add_aio_context_notifier(blk, block_job_attached_aio_context,
+                                 block_job_detach_aio_context, job);
+
+    /* Only set speed when necessary to avoid NotSupported error */
+    if (speed != 0) {
+        Error *local_err = NULL;
+
+        block_job_set_speed(job, speed, &local_err);
+        if (local_err) {
+            block_job_unref(job);
+            error_propagate(errp, local_err);
+            return NULL;
+        }
+    }
+    return job;
+}
+
 void block_job_pause_all(void)
 {
     BlockJob *job = NULL;
@@ -XXX,XX +XXX,XX @@ void block_job_pause_all(void)
     }
 }
 
+void block_job_early_fail(BlockJob *job)
+{
+    block_job_unref(job);
+}
+
+void block_job_completed(BlockJob *job, int ret)
+{
+    assert(blk_bs(job->blk)->job == job);
+    assert(!job->completed);
+    job->completed = true;
+    job->ret = ret;
+    if (!job->txn) {
+        block_job_completed_single(job);
+    } else if (ret < 0 || block_job_is_cancelled(job)) {
+        block_job_completed_txn_abort(job);
+    } else {
+        block_job_completed_txn_success(job);
+    }
+}
+
+static bool block_job_should_pause(BlockJob *job)
+{
+    return job->pause_count > 0;
+}
+
+void coroutine_fn block_job_pause_point(BlockJob *job)
+{
+    assert(job && block_job_started(job));
+
+    if (!block_job_should_pause(job)) {
+        return;
+    }
+    if (block_job_is_cancelled(job)) {
+        return;
+    }
+
+    if (job->driver->pause) {
+        job->driver->pause(job);
+    }
+
+    if (block_job_should_pause(job) && !block_job_is_cancelled(job)) {
+        job->paused = true;
+        job->busy = false;
+        qemu_coroutine_yield(); /* wait for block_job_resume() */
+        job->busy = true;
+        job->paused = false;
+    }
+
+    if (job->driver->resume) {
+        job->driver->resume(job);
+    }
+}
+
 void block_job_resume_all(void)
 {
     BlockJob *job = NULL;
@@ -XXX,XX +XXX,XX @@ void block_job_resume_all(void)
     }
 }
 
+void block_job_enter(BlockJob *job)
+{
+    if (job->co && !job->busy) {
+        bdrv_coroutine_enter(blk_bs(job->blk), job->co);
+    }
+}
+
+bool block_job_is_cancelled(BlockJob *job)
+{
+    return job->cancelled;
+}
+
+void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns)
+{
+    assert(job->busy);
+
+    /* Check cancellation *before* setting busy = false, too!  */
+    if (block_job_is_cancelled(job)) {
+        return;
+    }
+
+    job->busy = false;
+    if (!block_job_should_pause(job)) {
+        co_aio_sleep_ns(blk_get_aio_context(job->blk), type, ns);
+    }
+    job->busy = true;
+
+    block_job_pause_point(job);
+}
+
+void block_job_yield(BlockJob *job)
+{
+    assert(job->busy);
+
+    /* Check cancellation *before* setting busy = false, too!  */
+    if (block_job_is_cancelled(job)) {
+        return;
+    }
+
+    job->busy = false;
+    if (!block_job_should_pause(job)) {
+        qemu_coroutine_yield();
+    }
+    job->busy = true;
+
+    block_job_pause_point(job);
+}
+
 void block_job_event_ready(BlockJob *job)
 {
     job->ready = true;
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Outside blockjob.c, the block_job_iostatus_reset function is used once
in the monitor and once in BlockBackend.  When we introduce the block
job mutex, block_job_iostatus_reset's client is going to be the block
layer (for which blockjob.c will take the block job mutex) rather than
the monitor (which will take the block job mutex by itself).

The monitor's call to block_job_iostatus_reset from the monitor comes
just before the sole call to block_job_user_resume, so reset the
iostatus directly from block_job_iostatus_reset.  This will avoid
the need to introduce separate block_job_iostatus_reset and
block_job_iostatus_reset_locked APIs.

After making this change, move the function together with the others
that were moved in the previous patch.

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_job_resume(const char *device, Error **errp)
     }
 
     trace_qmp_block_job_resume(job);
-    block_job_iostatus_reset(job);
     block_job_user_resume(job);
     aio_context_release(aio_context);
 }
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job)
 {
     if (job && job->user_paused && job->pause_count > 0) {
         job->user_paused = false;
+        block_job_iostatus_reset(job);
         block_job_resume(job);
     }
 }
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
     }
 }
 
-void block_job_iostatus_reset(BlockJob *job)
-{
-    job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
-}
-
 static int block_job_finish_sync(BlockJob *job,
                                  void (*finish)(BlockJob *, Error **errp),
                                  Error **errp)
@@ -XXX,XX +XXX,XX @@ void block_job_yield(BlockJob *job)
     block_job_pause_point(job);
 }
 
+void block_job_iostatus_reset(BlockJob *job)
+{
+    job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
+}
+
 void block_job_event_ready(BlockJob *job)
 {
     job->ready = true;
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

The new functions helps respecting the invariant that the coroutine
is entered with false user_resume, zero pause count and no error
recorded in the iostatus.

Resetting the iostatus is now common to all of block_job_cancel_async,
block_job_user_resume and block_job_iostatus_reset, albeit with slight
differences:

- block_job_cancel_async resets the iostatus, and resumes the job if
there was an error, but the coroutine is not restarted immediately.
For example the caller may continue with a call to block_job_finish_sync.

- block_job_user_resume resets the iostatus.  It wants to resume the job
unconditionally, even if there was no error.

- block_job_iostatus_reset doesn't resume the job at all.  Maybe that's
a bug but it should be fixed separately.

block_job_iostatus_reset does the least common denominator, so add some
checking but otherwise leave it as the entry point for resetting the
iostatus.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20170508141310.8674-8-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 blockjob.c | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_single(BlockJob *job)
     block_job_unref(job);
 }
 
+static void block_job_cancel_async(BlockJob *job)
+{
+    if (job->iostatus != BLOCK_DEVICE_IO_STATUS_OK) {
+        block_job_iostatus_reset(job);
+    }
+    if (job->user_paused) {
+        /* Do not call block_job_enter here, the caller will handle it.  */
+        job->user_paused = false;
+        job->pause_count--;
+    }
+    job->cancelled = true;
+}
+
 static void block_job_completed_txn_abort(BlockJob *job)
 {
     AioContext *ctx;
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
              * them; this job, however, may or may not be cancelled, depending
              * on the caller, so leave it. */
             if (other_job != job) {
-                other_job->cancelled = true;
+                block_job_cancel_async(other_job);
             }
             continue;
         }
@@ -XXX,XX +XXX,XX @@ bool block_job_user_paused(BlockJob *job)
 void block_job_user_resume(BlockJob *job)
 {
     if (job && job->user_paused && job->pause_count > 0) {
-        job->user_paused = false;
         block_job_iostatus_reset(job);
+        job->user_paused = false;
         block_job_resume(job);
     }
 }
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(BlockJob *job)
 void block_job_cancel(BlockJob *job)
 {
     if (block_job_started(job)) {
-        job->cancelled = true;
-        block_job_iostatus_reset(job);
+        block_job_cancel_async(job);
         block_job_enter(job);
     } else {
         block_job_completed(job, -ECANCELED);
@@ -XXX,XX +XXX,XX @@ void block_job_yield(BlockJob *job)
 
 void block_job_iostatus_reset(BlockJob *job)
 {
+    if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
+        return;
+    }
+    assert(job->user_paused && job->pause_count > 0);
     job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
 }
 
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Yet another pure code movement patch, preparing for the next change.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20170508141310.8674-9-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 blockjob.c | 128 ++++++++++++++++++++++++++++++-------------------------------
 1 file changed, 64 insertions(+), 64 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ BlockJob *block_job_get(const char *id)
     return NULL;
 }
 
+BlockJobTxn *block_job_txn_new(void)
+{
+    BlockJobTxn *txn = g_new0(BlockJobTxn, 1);
+    QLIST_INIT(&txn->jobs);
+    txn->refcnt = 1;
+    return txn;
+}
+
+static void block_job_txn_ref(BlockJobTxn *txn)
+{
+    txn->refcnt++;
+}
+
+void block_job_txn_unref(BlockJobTxn *txn)
+{
+    if (txn && --txn->refcnt == 0) {
+        g_free(txn);
+    }
+}
+
+void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job)
+{
+    if (!txn) {
+        return;
+    }
+
+    assert(!job->txn);
+    job->txn = txn;
+
+    QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
+    block_job_txn_ref(txn);
+}
+
 static void block_job_pause(BlockJob *job)
 {
     job->pause_count++;
@@ -XXX,XX +XXX,XX @@ static void block_job_cancel_async(BlockJob *job)
     job->cancelled = true;
 }
 
+static int block_job_finish_sync(BlockJob *job,
+                                 void (*finish)(BlockJob *, Error **errp),
+                                 Error **errp)
+{
+    Error *local_err = NULL;
+    int ret;
+
+    assert(blk_bs(job->blk)->job == job);
+
+    block_job_ref(job);
+
+    finish(job, &local_err);
+    if (local_err) {
+        error_propagate(errp, local_err);
+        block_job_unref(job);
+        return -EBUSY;
+    }
+    /* block_job_drain calls block_job_enter, and it should be enough to
+     * induce progress until the job completes or moves to the main thread.
+    */
+    while (!job->deferred_to_main_loop && !job->completed) {
+        block_job_drain(job);
+    }
+    while (!job->completed) {
+        aio_poll(qemu_get_aio_context(), true);
+    }
+    ret = (job->cancelled && job->ret == 0) ? -ECANCELED : job->ret;
+    block_job_unref(job);
+    return ret;
+}
+
 static void block_job_completed_txn_abort(BlockJob *job)
 {
     AioContext *ctx;
@@ -XXX,XX +XXX,XX @@ void block_job_cancel(BlockJob *job)
     }
 }
 
-static int block_job_finish_sync(BlockJob *job,
-                                 void (*finish)(BlockJob *, Error **errp),
-                                 Error **errp)
-{
-    Error *local_err = NULL;
-    int ret;
-
-    assert(blk_bs(job->blk)->job == job);
-
-    block_job_ref(job);
-
-    finish(job, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        block_job_unref(job);
-        return -EBUSY;
-    }
-    /* block_job_drain calls block_job_enter, and it should be enough to
-     * induce progress until the job completes or moves to the main thread.
-    */
-    while (!job->deferred_to_main_loop && !job->completed) {
-        block_job_drain(job);
-    }
-    while (!job->completed) {
-        aio_poll(qemu_get_aio_context(), true);
-    }
-    ret = (job->cancelled && job->ret == 0) ? -ECANCELED : job->ret;
-    block_job_unref(job);
-    return ret;
-}
-
 /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be
  * used with block_job_finish_sync() without the need for (rather nasty)
  * function pointer casts there. */
@@ -XXX,XX +XXX,XX @@ void block_job_defer_to_main_loop(BlockJob *job,
     aio_bh_schedule_oneshot(qemu_get_aio_context(),
                             block_job_defer_to_main_loop_bh, data);
 }
-
-BlockJobTxn *block_job_txn_new(void)
-{
-    BlockJobTxn *txn = g_new0(BlockJobTxn, 1);
-    QLIST_INIT(&txn->jobs);
-    txn->refcnt = 1;
-    return txn;
-}
-
-static void block_job_txn_ref(BlockJobTxn *txn)
-{
-    txn->refcnt++;
-}
-
-void block_job_txn_unref(BlockJobTxn *txn)
-{
-    if (txn && --txn->refcnt == 0) {
-        g_free(txn);
-    }
-}
-
-void block_job_txn_add_job(BlockJobTxn *txn, BlockJob *job)
-{
-    if (!txn) {
-        return;
-    }
-
-    assert(!job->txn);
-    job->txn = txn;
-
-    QLIST_INSERT_HEAD(&txn->jobs, job, txn_list);
-    block_job_txn_ref(txn);
-}
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Unlike test-blockjob-txn, QMP releases the reference to the transaction
before the jobs finish.  Thus, qemu-iotest 124 showed a failure while
working on the next patch that the unit tests did not have.  Make
the test a little nastier.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20170508141310.8674-10-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 tests/test-blockjob-txn.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob-txn.c
+++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs(int expected1, int expected2)
     block_job_start(job1);
     block_job_start(job2);
 
+    /* Release our reference now to trigger as many nice
+     * use-after-free bugs as possible.
+     */
+    block_job_txn_unref(txn);
+
     if (expected1 == -ECANCELED) {
         block_job_cancel(job1);
     }
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs(int expected1, int expected2)
 
     g_assert_cmpint(result1, ==, expected1);
     g_assert_cmpint(result2, ==, expected2);
-
-    block_job_txn_unref(txn);
 }
 
 static void test_pair_jobs_success(void)
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

This splits the part that touches job states from the part that invokes
callbacks.  It will make the code simpler to understand once job states will
be protected by a different mutex than the AioContext lock.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20170508141310.8674-11-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 blockjob.c | 35 ++++++++++++++++++++++-------------
 1 file changed, 22 insertions(+), 13 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ void block_job_start(BlockJob *job)
 
 static void block_job_completed_single(BlockJob *job)
 {
+    assert(job->completed);
+
     if (!job->ret) {
         if (job->driver->commit) {
             job->driver->commit(job);
@@ -XXX,XX +XXX,XX @@ static int block_job_finish_sync(BlockJob *job,
 
     block_job_ref(job);
 
-    finish(job, &local_err);
+    if (finish) {
+        finish(job, &local_err);
+    }
     if (local_err) {
         error_propagate(errp, local_err);
         block_job_unref(job);
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
 {
     AioContext *ctx;
     BlockJobTxn *txn = job->txn;
-    BlockJob *other_job, *next;
+    BlockJob *other_job;
 
     if (txn->aborting) {
         /*
@@ -XXX,XX +XXX,XX @@ static void block_job_completed_txn_abort(BlockJob *job)
         return;
     }
     txn->aborting = true;
+    block_job_txn_ref(txn);
+
     /* We are the first failed job. Cancel other jobs. */
     QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
         ctx = blk_get_aio_context(other_job->blk);
         aio_context_acquire(ctx);
     }
+
+    /* Other jobs are effectively cancelled by us, set the status for
+     * them; this job, however, may or may not be cancelled, depending
+     * on the caller, so leave it. */
     QLIST_FOREACH(other_job, &txn->jobs, txn_list) {
-        if (other_job == job || other_job->completed) {
-            /* Other jobs are "effectively" cancelled by us, set the status for
-             * them; this job, however, may or may not be cancelled, depending
-             * on the caller, so leave it. */
-            if (other_job != job) {
-                block_job_cancel_async(other_job);
-            }
-            continue;
+        if (other_job != job) {
+            block_job_cancel_async(other_job);
         }
-        block_job_cancel_sync(other_job);
-        assert(other_job->completed);
     }
-    QLIST_FOREACH_SAFE(other_job, &txn->jobs, txn_list, next) {
+    while (!QLIST_EMPTY(&txn->jobs)) {
+        other_job = QLIST_FIRST(&txn->jobs);
         ctx = blk_get_aio_context(other_job->blk);
+        if (!other_job->completed) {
+            assert(other_job->cancelled);
+            block_job_finish_sync(other_job, NULL, NULL);
+        }
         block_job_completed_single(other_job);
         aio_context_release(ctx);
     }
+
+    block_job_txn_unref(txn);
 }
 
 static void block_job_completed_txn_success(BlockJob *job)
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

All block jobs are using block_job_defer_to_main_loop as the final
step just before the coroutine terminates.  At this point,
block_job_enter should do nothing, but currently it restarts
the freed coroutine.

Now, the job->co states should probably be changed to an enum
(e.g. BEFORE_START, STARTED, YIELDED, COMPLETED) subsuming
block_job_started, job->deferred_to_main_loop and job->busy.
For now, this patch eliminates the problematic reenter by
removing the reset of job->deferred_to_main_loop (which served
no purpose, as far as I could see) and checking the flag in
block_job_enter.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20170508141310.8674-12-pbonzini@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 blockjob.c                   | 10 ++++++++--
 include/block/blockjob_int.h |  3 ++-
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ void block_job_resume_all(void)
 
 void block_job_enter(BlockJob *job)
 {
-    if (job->co && !job->busy) {
+    if (!block_job_started(job)) {
+        return;
+    }
+    if (job->deferred_to_main_loop) {
+        return;
+    }
+
+    if (!job->busy) {
         bdrv_coroutine_enter(blk_bs(job->blk), job->co);
     }
 }
@@ -XXX,XX +XXX,XX @@ static void block_job_defer_to_main_loop_bh(void *opaque)
         aio_context_acquire(aio_context);
     }
 
-    data->job->deferred_to_main_loop = false;
     data->fn(data->job, data->opaque);
 
     if (aio_context != data->aio_context) {
diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob_int.h
+++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ typedef void BlockJobDeferToMainLoopFn(BlockJob *job, void *opaque);
  * @fn: The function to run in the main loop
  * @opaque: The opaque value that is passed to @fn
  *
- * Execute a given function in the main loop with the BlockDriverState
+ * This function must be called by the main job coroutine just before it
+ * returns.  @fn is executed in the main loop with the BlockDriverState
  * AioContext acquired.  Block jobs must call bdrv_unref(), bdrv_close(), and
  * anything that uses bdrv_drain_all() in the main loop.
  *
-- 
2.9.3

On current released versions of glusterfs, glfs_lseek() will sometimes
return invalid values for SEEK_DATA or SEEK_HOLE.  For SEEK_DATA and
SEEK_HOLE, the returned value should be >= the passed offset, or < 0 in
the case of error:

LSEEK(2):

off_t lseek(int fd, off_t offset, int whence);

[...]

SEEK_HOLE
              Adjust  the file offset to the next hole in the file greater
              than or equal to offset.  If offset points into the middle of
              a hole, then the file offset is set to offset.  If there is no
              hole past offset, then the file offset is adjusted to the end
              of the file (i.e., there is  an implicit hole at the end of
              any file).

[...]

RETURN VALUE
              Upon  successful  completion,  lseek()  returns  the resulting
              offset location as measured in bytes from the beginning of the
              file.  On error, the value (off_t) -1 is returned and errno is
              set to indicate the error

However, occasionally glfs_lseek() for SEEK_HOLE/DATA will return a
value less than the passed offset, yet greater than zero.

For instance, here are example values observed from this call:

offs = glfs_lseek(s->fd, start, SEEK_HOLE);
    if (offs < 0) {
        return -errno;          /* D1 and (H3 or H4) */
    }

start == 7608336384
offs == 7607877632

This causes QEMU to abort on the assert test.  When this value is
returned, errno is also 0.

This is a reported and known bug to glusterfs:
https://bugzilla.redhat.com/show_bug.cgi?id=1425293

Although this is being fixed in gluster, we still should work around it
in QEMU, given that multiple released versions of gluster behave this
way.

This patch treats the return case of (offs < start) the same as if an
error value other than ENXIO is returned; we will assume we learned
nothing, and there are no holes in the file.

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Niels de Vos <ndevos@redhat.com>
Message-id: 87c0140e9407c08f6e74b04131b610f2e27c014c.1495560397.git.jcody@redhat.com
Signed-off-by: Jeff Cody <jcody@redhat.com>
---
 block/gluster.c | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/block/gluster.c b/block/gluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@ static int find_allocation(BlockDriverState *bs, off_t start,
     if (offs < 0) {
         return -errno;          /* D3 or D4 */
     }
-    assert(offs >= start);
+
+    if (offs < start) {
+        /* This is not a valid return by lseek().  We are safe to just return
+         * -EIO in this case, and we'll treat it like D4. Unfortunately some
+         *  versions of gluster server will return offs < start, so an assert
+         *  here will unnecessarily abort QEMU. */
+        return -EIO;
+    }
 
     if (offs > start) {
         /* D2: in hole, next data at offs */
@@ -XXX,XX +XXX,XX @@ static int find_allocation(BlockDriverState *bs, off_t start,
     if (offs < 0) {
         return -errno;          /* D1 and (H3 or H4) */
     }
-    assert(offs >= start);
+
+    if (offs < start) {
+        /* This is not a valid return by lseek().  We are safe to just return
+         * -EIO in this case, and we'll treat it like H4. Unfortunately some
+         *  versions of gluster server will return offs < start, so an assert
+         *  here will unnecessarily abort QEMU. */
+        return -EIO;
+    }
 
     if (offs > start) {
         /*
-- 
2.9.3

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