Series comparison

-[PULL 0/3] Block patches
+[PULL 00/35] Block patches
-The following changes since commit 9cf289af47bcfae5c75de37d8e5d6fd23705322c:
+The following changes since commit 9548cbeffffd4253e38570d29b8cff0bf77c998f:
-  Merge tag 'qga-pull-request' of gitlab.com:marcandre.lureau/qemu into staging (2022-05-04 03:42:49 -0700)
+  iotests/copy-before-write: specify required_fmts (2022-07-12 13:21:02 +0530)
 are available in the Git repository at:
-  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/hreitz/qemu.git tags/pull-block-2022-07-12
-for you to fetch changes up to bef2e050d6a7feb865854c65570c496ac5a8cf53:
+for you to fetch changes up to 85c4bf8aa6c93c24876e8870ae7cf8ab2e5a96cf:
-  util/event-loop-base: Introduce options to set the thread pool size (2022-05-04 17:02:19 +0100)
+  vl: Unlink absolute PID file path (2022-07-12 14:31:15 +0200)
 ----------------------------------------------------------------
-Pull request
+Block patches:
+- Refactoring for non-coroutine variants of bdrv/blk_co_* functions:
-Add new thread-pool-min/thread-pool-max parameters to control the thread pool
+  Auto-generate more of them with the block coroutine wrapper generator
-used for async I/O.
+  script
 - iotest fixes
 - Both for the storage daemon and the system emulator: Fix PID file
   handling when daemonizing (store the absolute path and delete that on
   exit, which is necessary because daemonizing will change the working
   directory to /)
 ----------------------------------------------------------------
+Alberto Faria (28):
+  block: Add a 'flags' param to bdrv_{pread,pwrite,pwrite_sync}()
+  block: Change bdrv_{pread,pwrite,pwrite_sync}() param order
+  block: Make bdrv_{pread,pwrite}() return 0 on success
+  crypto: Make block callbacks return 0 on success
+  block: Make bdrv_co_pwrite() take a const buffer
+  block: Make 'bytes' param of bdrv_co_{pread,pwrite,preadv,pwritev}()
+    an int64_t
+  block: Implement bdrv_{pread,pwrite,pwrite_zeroes}() using
+    generated_co_wrapper
+  block: Add bdrv_co_pwrite_sync()
+  block: Use bdrv_co_pwrite_sync() when caller is coroutine_fn
+  block/qcow2: Use bdrv_pwrite_sync() in qcow2_mark_dirty()
+  block: Make blk_{pread,pwrite}() return 0 on success
+  block: Add a 'flags' param to blk_pread()
+  block: Change blk_{pread,pwrite}() param order
+  block: Make 'bytes' param of blk_{pread,pwrite}() an int64_t
+  block: Make blk_co_pwrite() take a const buffer
+  block: Implement blk_{pread,pwrite}() using generated_co_wrapper
+  block: Add blk_{preadv,pwritev}()
+  block: Add blk_[co_]preadv_part()
+  block: Export blk_pwritev_part() in block-backend-io.h
+  block: Change blk_pwrite_compressed() param order
+  block: Add blk_co_pwrite_compressed()
+  block: Implement blk_pwrite_zeroes() using generated_co_wrapper
+  block: Implement blk_pdiscard() using generated_co_wrapper
+  block: Implement blk_flush() using generated_co_wrapper
+  block: Add blk_co_ioctl()
+  block: Add blk_co_truncate()
+  block: Reorganize some declarations in block-backend-io.h
+  block: Remove remaining unused symbols in coroutines.h
-Nicolas Saenz Julienne (3):
+Hanna Reitz (5):
-  Introduce event-loop-base abstract class
+  qsd: Do not use error_report() before monitor_init
-  util/main-loop: Introduce the main loop into QOM
+  iotests/297: Have mypy ignore unused ignores
-  util/event-loop-base: Introduce options to set the thread pool size
+  qsd: Unlink absolute PID file path
   vl: Conditionally register PID file unlink notifier
   vl: Unlink absolute PID file path
- qapi/qom.json                    |  43 ++++++++--
+John Snow (2):
- meson.build                      |  26 +++---
+  tests/qemu-iotests: hotfix for 307, 223 output
- include/block/aio.h              |  10 +++
+  tests/qemu-iotests: skip 108 when FUSE is not loaded
- include/block/thread-pool.h      |   3 +
- include/qemu/main-loop.h         |  10 +++
+ block/coroutines.h                   |  44 --------
- include/sysemu/event-loop-base.h |  41 +++++++++
+ include/block/block-io.h             |  22 ++--
- include/sysemu/iothread.h        |   6 +-
+ include/block/block_int-io.h         |   4 +-
- event-loop-base.c                | 140 +++++++++++++++++++++++++++++++
+ include/crypto/block.h               |  32 +++---
- iothread.c                       |  68 +++++----------
+ include/sysemu/block-backend-io.h    |  97 ++++++++++-------
- util/aio-posix.c                 |   1 +
+ block.c                              |  10 +-
- util/async.c                     |  20 +++++
+ block/blklogwrites.c                 |   6 +-
- util/main-loop.c                 |  65 ++++++++++++++
+ block/block-backend.c                | 150 +++++++++++---------------
- util/thread-pool.c               |  55 +++++++++++-
+ block/bochs.c                        |  10 +-
-files changed, 419 insertions(+), 69 deletions(-)
+ block/cloop.c                        |  12 +--
- create mode 100644 include/sysemu/event-loop-base.h
+ block/commit.c                       |   4 +-
- create mode 100644 event-loop-base.c
+ block/crypto.c                       |  58 +++++-----
  block/dmg.c                          |  36 +++----
  block/export/fuse.c                  |   4 +-
  block/io.c                           |  55 +---------
  block/parallels-ext.c                |   6 +-
  block/parallels.c                    |  14 +--
  block/qcow.c                         |  55 +++++-----
  block/qcow2-bitmap.c                 |  14 +--
  block/qcow2-cache.c                  |   9 +-
  block/qcow2-cluster.c                |  19 ++--
  block/qcow2-refcount.c               |  58 +++++-----
  block/qcow2-snapshot.c               |  53 +++++-----
  block/qcow2.c                        |  84 +++++++--------
  block/qed.c                          |  21 ++--
  block/vdi.c                          |  20 ++--
  block/vhdx-log.c                     |  23 ++--
  block/vhdx.c                         |  56 +++++-----
  block/vmdk.c                         |  80 +++++++-------
  block/vpc.c                          |  35 +++---
  block/vvfat.c                        |  11 +-
  crypto/block-luks.c                  |   8 +-
  crypto/block.c                       |   6 +-
  hw/arm/allwinner-h3.c                |   2 +-
  hw/arm/aspeed.c                      |   2 +-
  hw/block/block.c                     |   2 +-
  hw/block/fdc.c                       |  20 ++--
  hw/block/hd-geometry.c               |   2 +-
  hw/block/m25p80.c                    |   2 +-
  hw/block/nand.c                      |  47 ++++----
  hw/block/onenand.c                   |  32 +++---
  hw/block/pflash_cfi01.c              |   4 +-
  hw/block/pflash_cfi02.c              |   4 +-
  hw/ide/atapi.c                       |   4 +-
  hw/misc/mac_via.c                    |   6 +-
  hw/misc/sifive_u_otp.c               |  14 +--
  hw/nvram/eeprom_at24c.c              |   8 +-
  hw/nvram/spapr_nvram.c               |  16 +--
  hw/nvram/xlnx-bbram.c                |   4 +-
  hw/nvram/xlnx-efuse.c                |   4 +-
  hw/ppc/pnv_pnor.c                    |   6 +-
  hw/sd/sd.c                           |   4 +-
  migration/block.c                    |   8 +-
  nbd/server.c                         |   8 +-
  qemu-img.c                           |  41 +++----
  qemu-io-cmds.c                       |  20 ++--
  softmmu/vl.c                         |  42 ++++++--
  storage-daemon/qemu-storage-daemon.c |  17 ++-
  tests/unit/test-block-iothread.c     | 153 ++++++++++++++++++++++++---
  tests/unit/test-crypto-block.c       |  38 +++----
  block/meson.build                    |   1 +
  tests/qemu-iotests/108               |   5 +
  tests/qemu-iotests/223.out           |   4 +-
  tests/qemu-iotests/307.out           |   4 +-
  tests/qemu-iotests/mypy.ini          |   2 +-
 files changed, 856 insertions(+), 786 deletions(-)
 --
-.35.1
+.35.3

-New patch
+[PULL 01/35] block: Add a 'flags' param to bdrv_{pread, pwrite, pwrite_sync}()
+From: Alberto Faria <afaria@redhat.com>
+For consistency with other I/O functions, and in preparation to
+implement them using generated_co_wrapper.
+Callers were updated using this Coccinelle script:
+    @@ expression child, offset, buf, bytes; @@
+    - bdrv_pread(child, offset, buf, bytes)
+    + bdrv_pread(child, offset, buf, bytes, 0)
+    @@ expression child, offset, buf, bytes; @@
+    - bdrv_pwrite(child, offset, buf, bytes)
+    + bdrv_pwrite(child, offset, buf, bytes, 0)
+    @@ expression child, offset, buf, bytes; @@
+    - bdrv_pwrite_sync(child, offset, buf, bytes)
+    + bdrv_pwrite_sync(child, offset, buf, bytes, 0)
+Resulting overly-long lines were then fixed by hand.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+Message-Id: <20220609152744.3891847-2-afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/block/block-io.h         |  7 ++--
+ block/blklogwrites.c             |  4 +--
+ block/bochs.c                    |  6 ++--
+ block/cloop.c                    | 10 +++---
+ block/crypto.c                   |  4 +--
+ block/dmg.c                      | 24 +++++++-------
+ block/io.c                       | 13 ++++----
+ block/parallels-ext.c            |  4 +--
+ block/parallels.c                | 12 +++----
+ block/qcow.c                     | 27 ++++++++-------
+ block/qcow2-bitmap.c             | 14 ++++----
+ block/qcow2-cache.c              |  7 ++--
+ block/qcow2-cluster.c            | 21 ++++++------
+ block/qcow2-refcount.c           | 42 +++++++++++------------
+ block/qcow2-snapshot.c           | 39 +++++++++++-----------
+ block/qcow2.c                    | 44 ++++++++++++------------
+ block/qed.c                      |  8 ++---
+ block/vdi.c                      | 10 +++---
+ block/vhdx-log.c                 | 19 +++++------
+ block/vhdx.c                     | 32 ++++++++++--------
+ block/vmdk.c                     | 57 ++++++++++++++------------------
+ block/vpc.c                      | 19 ++++++-----
+ block/vvfat.c                    |  7 ++--
+ tests/unit/test-block-iothread.c |  8 ++---
+files changed, 219 insertions(+), 219 deletions(-)
+diff --git a/include/block/block-io.h b/include/block/block-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/block-io.h
++++ b/include/block/block-io.h
+@@ -XXX,XX +XXX,XX @@
+ int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
+                        int64_t bytes, BdrvRequestFlags flags);
+ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
+-int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes);
++int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
++               BdrvRequestFlags flags);
+ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
+-                int64_t bytes);
++                int64_t bytes, BdrvRequestFlags flags);
+ int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
+-                     const void *buf, int64_t bytes);
++                     const void *buf, int64_t bytes, BdrvRequestFlags flags);
+ /*
+  * Efficiently zero a region of the disk image.  Note that this is a regular
+  * I/O request like read or write and should have a reasonable size.  This
+diff --git a/block/blklogwrites.c b/block/blklogwrites.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/blklogwrites.c
++++ b/block/blklogwrites.c
+@@ -XXX,XX +XXX,XX @@ static uint64_t blk_log_writes_find_cur_log_sector(BdrvChild *log,
+     while (cur_idx < nr_entries) {
+         int read_ret = bdrv_pread(log, cur_sector << sector_bits, &cur_entry,
+-                                  sizeof(cur_entry));
++                                  sizeof(cur_entry), 0);
+         if (read_ret < 0) {
+             error_setg_errno(errp, -read_ret,
+                              "Failed to read log entry %"PRIu64, cur_idx);
+@@ -XXX,XX +XXX,XX @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
+             log_sb.nr_entries = cpu_to_le64(0);
+             log_sb.sectorsize = cpu_to_le32(BDRV_SECTOR_SIZE);
+         } else {
+-            ret = bdrv_pread(s->log_file, 0, &log_sb, sizeof(log_sb));
++            ret = bdrv_pread(s->log_file, 0, &log_sb, sizeof(log_sb), 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret, "Could not read log superblock");
+                 goto fail_log;
+diff --git a/block/bochs.c b/block/bochs.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/bochs.c
++++ b/block/bochs.c
+@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
++    ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs), 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
+     }
+     ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_bitmap,
+-                     s->catalog_size * 4);
++                     s->catalog_size * 4, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
+     /* read in bitmap for current extent */
+     ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8),
+-                     &bitmap_entry, 1);
++                     &bitmap_entry, 1, 0);
+     if (ret < 0) {
+         return ret;
+     }
+diff --git a/block/cloop.c b/block/cloop.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/cloop.c
++++ b/block/cloop.c
+@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
+     }
+     /* read header */
+-    ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
++    ret = bdrv_pread(bs->file, 128, &s->block_size, 4, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4);
++    ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
+         return -ENOMEM;
+     }
+-    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size);
++    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
+         int ret;
+         uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];
+-        ret = bdrv_pread(bs->file, s->offsets[block_num],
+-                         s->compressed_block, bytes);
++        ret = bdrv_pread(bs->file, s->offsets[block_num], s->compressed_block,
++                         bytes, 0);
+         if (ret != bytes) {
+             return -1;
+         }
+diff --git a/block/crypto.c b/block/crypto.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/crypto.c
++++ b/block/crypto.c
+@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
+     BlockDriverState *bs = opaque;
+     ssize_t ret;
+-    ret = bdrv_pread(bs->file, offset, buf, buflen);
++    ret = bdrv_pread(bs->file, offset, buf, buflen, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+         return ret;
+@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_write_func(QCryptoBlock *block,
+     BlockDriverState *bs = opaque;
+     ssize_t ret;
+-    ret = bdrv_pwrite(bs->file, offset, buf, buflen);
++    ret = bdrv_pwrite(bs->file, offset, buf, buflen, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not write encryption header");
+         return ret;
+diff --git a/block/dmg.c b/block/dmg.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/dmg.c
++++ b/block/dmg.c
+@@ -XXX,XX +XXX,XX @@ static int read_uint64(BlockDriverState *bs, int64_t offset, uint64_t *result)
+     uint64_t buffer;
+     int ret;
+-    ret = bdrv_pread(bs->file, offset, &buffer, 8);
++    ret = bdrv_pread(bs->file, offset, &buffer, 8, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int read_uint32(BlockDriverState *bs, int64_t offset, uint32_t *result)
+     uint32_t buffer;
+     int ret;
+-    ret = bdrv_pread(bs->file, offset, &buffer, 4);
++    ret = bdrv_pread(bs->file, offset, &buffer, 4, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int64_t dmg_find_koly_offset(BdrvChild *file, Error **errp)
+         offset = length - 511 - 512;
+     }
+     length = length < 515 ? length : 515;
+-    ret = bdrv_pread(file, offset, buffer, length);
++    ret = bdrv_pread(file, offset, buffer, length, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed while reading UDIF trailer");
+         return ret;
+@@ -XXX,XX +XXX,XX @@ static int dmg_read_resource_fork(BlockDriverState *bs, DmgHeaderState *ds,
+         offset += 4;
+         buffer = g_realloc(buffer, count);
+-        ret = bdrv_pread(bs->file, offset, buffer, count);
++        ret = bdrv_pread(bs->file, offset, buffer, count, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int dmg_read_plist_xml(BlockDriverState *bs, DmgHeaderState *ds,
+     buffer = g_malloc(info_length + 1);
+     buffer[info_length] = '\0';
+-    ret = bdrv_pread(bs->file, info_begin, buffer, info_length);
++    ret = bdrv_pread(bs->file, info_begin, buffer, info_length, 0);
+     if (ret != info_length) {
+         ret = -EINVAL;
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+         case UDZO: { /* zlib compressed */
+             /* we need to buffer, because only the chunk as whole can be
+              * inflated. */
+-            ret = bdrv_pread(bs->file, s->offsets[chunk],
+-                             s->compressed_chunk, s->lengths[chunk]);
++            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
++                             s->lengths[chunk], 0);
+             if (ret != s->lengths[chunk]) {
+                 return -1;
+             }
+@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+             }
+             /* we need to buffer, because only the chunk as whole can be
+              * inflated. */
+-            ret = bdrv_pread(bs->file, s->offsets[chunk],
+-                             s->compressed_chunk, s->lengths[chunk]);
++            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
++                             s->lengths[chunk], 0);
+             if (ret != s->lengths[chunk]) {
+                 return -1;
+             }
+@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+             }
+             /* we need to buffer, because only the chunk as whole can be
+              * inflated. */
+-            ret = bdrv_pread(bs->file, s->offsets[chunk],
+-                             s->compressed_chunk, s->lengths[chunk]);
++            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
++                             s->lengths[chunk], 0);
+             if (ret != s->lengths[chunk]) {
+                 return -1;
+             }
+@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+             break;
+         case UDRW: /* copy */
+             ret = bdrv_pread(bs->file, s->offsets[chunk],
+-                             s->uncompressed_chunk, s->lengths[chunk]);
++                             s->uncompressed_chunk, s->lengths[chunk], 0);
+             if (ret != s->lengths[chunk]) {
+                 return -1;
+             }
+diff --git a/block/io.c b/block/io.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/io.c
++++ b/block/io.c
+@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
+ }
+ /* See bdrv_pwrite() for the return codes */
+-int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes)
++int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
++               BdrvRequestFlags flags)
+ {
+     int ret;
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes)
+         return -EINVAL;
+     }
+-    ret = bdrv_preadv(child, offset, bytes, &qiov,  0);
++    ret = bdrv_preadv(child, offset, bytes, &qiov, flags);
+     return ret < 0 ? ret : bytes;
+ }
+@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes)
+   -EACCES      Trying to write a read-only device
+ */
+ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
+-                int64_t bytes)
++                int64_t bytes, BdrvRequestFlags flags)
+ {
+     int ret;
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+@@ -XXX,XX +XXX,XX @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
+         return -EINVAL;
+     }
+-    ret = bdrv_pwritev(child, offset, bytes, &qiov, 0);
++    ret = bdrv_pwritev(child, offset, bytes, &qiov, flags);
+     return ret < 0 ? ret : bytes;
+ }
+@@ -XXX,XX +XXX,XX @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
+  * Returns 0 on success, -errno in error cases.
+  */
+ int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
+-                     const void *buf, int64_t count)
++                     const void *buf, int64_t count, BdrvRequestFlags flags)
+ {
+     int ret;
+     IO_CODE();
+-    ret = bdrv_pwrite(child, offset, buf, count);
++    ret = bdrv_pwrite(child, offset, buf, count, flags);
+     if (ret < 0) {
+         return ret;
+     }
+diff --git a/block/parallels-ext.c b/block/parallels-ext.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/parallels-ext.c
++++ b/block/parallels-ext.c
+@@ -XXX,XX +XXX,XX @@ static int parallels_load_bitmap_data(BlockDriverState *bs,
+             bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
+         } else {
+             ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS, buf,
+-                             s->cluster_size);
++                             s->cluster_size, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret,
+                                  "Failed to read bitmap data cluster");
+@@ -XXX,XX +XXX,XX @@ int parallels_read_format_extension(BlockDriverState *bs,
+     assert(ext_off > 0);
+-    ret = bdrv_pread(bs->file, ext_off, ext_cluster, s->cluster_size);
++    ret = bdrv_pread(bs->file, ext_off, ext_cluster, s->cluster_size, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to read Format Extension cluster");
+         goto out;
+diff --git a/block/parallels.c b/block/parallels.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/parallels.c
++++ b/block/parallels.c
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs)
+         if (off + to_write > s->header_size) {
+             to_write = s->header_size - off;
+         }
+-        ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off,
+-                          to_write);
++        ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off, to_write,
++                          0);
+         if (ret < 0) {
+             qemu_co_mutex_unlock(&s->lock);
+             return ret;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
+     ret = 0;
+     if (flush_bat) {
+-        ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size);
++        ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size, 0);
+         if (ret < 0) {
+             res->check_errors++;
+             goto out;
+@@ -XXX,XX +XXX,XX @@ static int parallels_update_header(BlockDriverState *bs)
+     if (size > s->header_size) {
+         size = s->header_size;
+     }
+-    return bdrv_pwrite_sync(bs->file, 0, s->header, size);
++    return bdrv_pwrite_sync(bs->file, 0, s->header, size, 0);
+ }
+ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph));
++    ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph), 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
+         s->header_size = size;
+     }
+-    ret = bdrv_pread(bs->file, 0, s->header, s->header_size);
++    ret = bdrv_pread(bs->file, 0, s->header, s->header_size, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+diff --git a/block/qcow.c b/block/qcow.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow.c
++++ b/block/qcow.c
+@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
++    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
+     }
+     ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
+-               s->l1_size * sizeof(uint64_t));
++                     s->l1_size * sizeof(uint64_t), 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
+             goto fail;
+         }
+         ret = bdrv_pread(bs->file, header.backing_file_offset,
+-                   bs->auto_backing_file, len);
++                         bs->auto_backing_file, len, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+         BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
+         ret = bdrv_pwrite_sync(bs->file,
+                                s->l1_table_offset + l1_index * sizeof(tmp),
+-                               &tmp, sizeof(tmp));
++                               &tmp, sizeof(tmp), 0);
+         if (ret < 0) {
+             return ret;
+         }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+     if (new_l2_table) {
+         memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
+         ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
+-                               s->l2_size * sizeof(uint64_t));
++                               s->l2_size * sizeof(uint64_t), 0);
+         if (ret < 0) {
+             return ret;
+         }
+     } else {
+         ret = bdrv_pread(bs->file, l2_offset, l2_table,
+-                         s->l2_size * sizeof(uint64_t));
++                         s->l2_size * sizeof(uint64_t), 0);
+         if (ret < 0) {
+             return ret;
+         }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+             /* write the cluster content */
+             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+             ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache,
+-                              s->cluster_size);
++                              s->cluster_size, 0);
+             if (ret < 0) {
+                 return ret;
+             }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+                                 return -EIO;
+                             }
+                             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+-                            ret = bdrv_pwrite(bs->file,
+-                                              cluster_offset + i,
++                            ret = bdrv_pwrite(bs->file, cluster_offset + i,
+                                               s->cluster_data,
+-                                              BDRV_SECTOR_SIZE);
++                                              BDRV_SECTOR_SIZE, 0);
+                             if (ret < 0) {
+                                 return ret;
+                             }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+             BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
+         }
+         ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
+-                               &tmp, sizeof(tmp));
++                               &tmp, sizeof(tmp), 0);
+         if (ret < 0) {
+             return ret;
+         }
+@@ -XXX,XX +XXX,XX @@ static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
+         csize = cluster_offset >> (63 - s->cluster_bits);
+         csize &= (s->cluster_size - 1);
+         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
+-        ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize);
++        ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize, 0);
+         if (ret != csize)
+             return -1;
+         if (decompress_buffer(s->cluster_cache, s->cluster_size,
+@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
+     int ret;
+     memset(s->l1_table, 0, l1_length);
+-    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table,
+-            l1_length) < 0)
++    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table, l1_length,
++                         0) < 0)
+         return -1;
+     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
+                         PREALLOC_MODE_OFF, 0, NULL);
+diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-bitmap.c
++++ b/block/qcow2-bitmap.c
+@@ -XXX,XX +XXX,XX @@ static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
+     }
+     assert(tb->size <= BME_MAX_TABLE_SIZE);
+-    ret = bdrv_pread(bs->file, tb->offset,
+-                     table, tb->size * BME_TABLE_ENTRY_SIZE);
++    ret = bdrv_pread(bs->file, tb->offset, table,
++                     tb->size * BME_TABLE_ENTRY_SIZE, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int load_bitmap_data(BlockDriverState *bs,
+                  * already cleared */
+             }
+         } else {
+-            ret = bdrv_pread(bs->file, data_offset, buf, s->cluster_size);
++            ret = bdrv_pread(bs->file, data_offset, buf, s->cluster_size, 0);
+             if (ret < 0) {
+                 goto finish;
+             }
+@@ -XXX,XX +XXX,XX @@ static Qcow2BitmapList *bitmap_list_load(BlockDriverState *bs, uint64_t offset,
+     }
+     dir_end = dir + size;
+-    ret = bdrv_pread(bs->file, offset, dir, size);
++    ret = bdrv_pread(bs->file, offset, dir, size, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to read bitmap directory");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list,
+         goto fail;
+     }
+-    ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size);
++    ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static uint64_t *store_bitmap_data(BlockDriverState *bs,
+             goto fail;
+         }
+-        ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size);
++        ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
+                              bm_name);
+@@ -XXX,XX +XXX,XX @@ static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp)
+     }
+     bitmap_table_to_be(tb, tb_size);
+-    ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]));
++    ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]), 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
+                          bm_name);
+diff --git a/block/qcow2-cache.c b/block/qcow2-cache.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-cache.c
++++ b/block/qcow2-cache.c
+@@ -XXX,XX +XXX,XX @@ static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
+     }
+     ret = bdrv_pwrite(bs->file, c->entries[i].offset,
+-                      qcow2_cache_get_table_addr(c, i), c->table_size);
++                      qcow2_cache_get_table_addr(c, i), c->table_size, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
+             BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
+         }
+-        ret = bdrv_pread(bs->file, offset,
+-                         qcow2_cache_get_table_addr(c, i),
+-                         c->table_size);
++        ret = bdrv_pread(bs->file, offset, qcow2_cache_get_table_addr(c, i),
++                         c->table_size, 0);
+         if (ret < 0) {
+             return ret;
+         }
+diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-cluster.c
++++ b/block/qcow2-cluster.c
+@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
+     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE);
+     for(i = 0; i < s->l1_size; i++)
+         new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
+-    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset,
+-                           new_l1_table, new_l1_size2);
++    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, new_l1_table,
++                           new_l1_size2, 0);
+     if (ret < 0)
+         goto fail;
+     for(i = 0; i < s->l1_size; i++)
+@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
+     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);
+     stl_be_p(data, new_l1_size);
+     stq_be_p(data + 4, new_l1_table_offset);
+-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size),
+-                           data, sizeof(data));
++    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size), data,
++                           sizeof(data), 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)
+     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
+     ret = bdrv_pwrite_sync(bs->file,
+                            s->l1_table_offset + L1E_SIZE * l1_start_index,
+-                           buf, bufsize);
++                           buf, bufsize, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
+                                       (void **)&l2_slice);
+             } else {
+                 /* load inactive L2 tables from disk */
+-                ret = bdrv_pread(bs->file, slice_offset, l2_slice, slice_size2);
++                ret = bdrv_pread(bs->file, slice_offset, l2_slice,
++                                 slice_size2, 0);
+             }
+             if (ret < 0) {
+                 goto fail;
+@@ -XXX,XX +XXX,XX @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
+                         goto fail;
+                     }
+-                    ret = bdrv_pwrite(bs->file, slice_offset,
+-                                      l2_slice, slice_size2);
++                    ret = bdrv_pwrite(bs->file, slice_offset, l2_slice,
++                                      slice_size2, 0);
+                     if (ret < 0) {
+                         goto fail;
+                     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_expand_zero_clusters(BlockDriverState *bs,
+         l1_table = new_l1_table;
+-        ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset,
+-                         l1_table, l1_size2);
++        ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset, l1_table,
++                         l1_size2, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-refcount.c
++++ b/block/qcow2-refcount.c
+@@ -XXX,XX +XXX,XX @@ int qcow2_refcount_init(BlockDriverState *bs)
+         }
+         BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
+         ret = bdrv_pread(bs->file, s->refcount_table_offset,
+-                         s->refcount_table, refcount_table_size2);
++                         s->refcount_table, refcount_table_size2, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,
+         BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);
+         ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset +
+                                refcount_table_index * REFTABLE_ENTRY_SIZE,
+-            &data64, sizeof(data64));
++            &data64, sizeof(data64), 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
+     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);
+     ret = bdrv_pwrite_sync(bs->file, table_offset, new_table,
+-        table_size * REFTABLE_ENTRY_SIZE);
++                           table_size * REFTABLE_ENTRY_SIZE, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
+     data.d32 = cpu_to_be32(table_clusters);
+     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);
+     ret = bdrv_pwrite_sync(bs->file,
+-                           offsetof(QCowHeader, refcount_table_offset),
+-                           &data, sizeof(data));
++                           offsetof(QCowHeader, refcount_table_offset), &data,
++                           sizeof(data), 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
+         }
+         l1_allocated = true;
+-        ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2);
++        ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ fail:
+             cpu_to_be64s(&l1_table[i]);
+         }
+-        ret = bdrv_pwrite_sync(bs->file, l1_table_offset,
+-                               l1_table, l1_size2);
++        ret = bdrv_pwrite_sync(bs->file, l1_table_offset, l1_table, l1_size2,
++                               0);
+         for (i = 0; i < l1_size; i++) {
+             be64_to_cpus(&l1_table[i]);
+@@ -XXX,XX +XXX,XX @@ static int fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
+     }
+     ret = bdrv_pwrite_sync(bs->file, l2e_offset, &l2_table[idx],
+-                           l2_entry_size(s));
++                           l2_entry_size(s), 0);
+     if (ret < 0) {
+         fprintf(stderr, "ERROR: Failed to overwrite L2 "
+                 "table entry: %s\n", strerror(-ret));
+@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
+     bool metadata_overlap;
+     /* Read L2 table from disk */
+-    ret = bdrv_pread(bs->file, l2_offset, l2_table, l2_size_bytes);
++    ret = bdrv_pread(bs->file, l2_offset, l2_table, l2_size_bytes, 0);
+     if (ret < 0) {
+         fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
+         res->check_errors++;
+@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
+     }
+     /* Read L1 table entries from disk */
+-    ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size_bytes);
++    ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size_bytes, 0);
+     if (ret < 0) {
+         fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
+         res->check_errors++;
+@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
+         }
+         ret = bdrv_pread(bs->file, l2_offset, l2_table,
+-                         s->l2_size * l2_entry_size(s));
++                         s->l2_size * l2_entry_size(s), 0);
+         if (ret < 0) {
+             fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
+                     strerror(-ret));
+@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
+                 goto fail;
+             }
+-            ret = bdrv_pwrite(bs->file, l2_offset, l2_table,
+-                              s->cluster_size);
++            ret = bdrv_pwrite(bs->file, l2_offset, l2_table, s->cluster_size,
++                              0);
+             if (ret < 0) {
+                 fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
+                         strerror(-ret));
+@@ -XXX,XX +XXX,XX @@ static int rebuild_refcounts_write_refblocks(
+                                     refblock_index * s->cluster_size);
+         ret = bdrv_pwrite(bs->file, refblock_offset, on_disk_refblock,
+-                          s->cluster_size);
++                          s->cluster_size, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "ERROR writing refblock");
+             return ret;
+@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
+     assert(reftable_length < INT_MAX);
+     ret = bdrv_pwrite(bs->file, reftable_offset, on_disk_reftable,
+-                      reftable_length);
++                      reftable_length, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "ERROR writing reftable");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
+     ret = bdrv_pwrite_sync(bs->file,
+                            offsetof(QCowHeader, refcount_table_offset),
+                            &reftable_offset_and_clusters,
+-                           sizeof(reftable_offset_and_clusters));
++                           sizeof(reftable_offset_and_clusters), 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "ERROR setting reftable");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
+                 return -ENOMEM;
+             }
+-            ret = bdrv_pread(bs->file, l1_ofs, l1, l1_sz2);
++            ret = bdrv_pread(bs->file, l1_ofs, l1, l1_sz2, 0);
+             if (ret < 0) {
+                 g_free(l1);
+                 return ret;
+@@ -XXX,XX +XXX,XX @@ static int flush_refblock(BlockDriverState *bs, uint64_t **reftable,
+             return ret;
+         }
+-        ret = bdrv_pwrite(bs->file, offset, refblock, s->cluster_size);
++        ret = bdrv_pwrite(bs->file, offset, refblock, s->cluster_size, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to write refblock");
+             return ret;
+@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
+     }
+     ret = bdrv_pwrite(bs->file, new_reftable_offset, new_reftable,
+-                      new_reftable_size * REFTABLE_ENTRY_SIZE);
++                      new_reftable_size * REFTABLE_ENTRY_SIZE, 0);
+     for (i = 0; i < new_reftable_size; i++) {
+         be64_to_cpus(&new_reftable[i]);
+@@ -XXX,XX +XXX,XX @@ int qcow2_shrink_reftable(BlockDriverState *bs)
+     }
+     ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset, reftable_tmp,
+-                           s->refcount_table_size * REFTABLE_ENTRY_SIZE);
++                           s->refcount_table_size * REFTABLE_ENTRY_SIZE, 0);
+     /*
+      * If the write in the reftable failed the image may contain a partially
+      * overwritten reftable. In this case it would be better to clear the
+diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-snapshot.c
++++ b/block/qcow2-snapshot.c
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+         /* Read statically sized part of the snapshot header */
+         offset = ROUND_UP(offset, 8);
+-        ret = bdrv_pread(bs->file, offset, &h, sizeof(h));
++        ret = bdrv_pread(bs->file, offset, &h, sizeof(h), 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read snapshot table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+         /* Read known extra data */
+         ret = bdrv_pread(bs->file, offset, &extra,
+-                         MIN(sizeof(extra), sn->extra_data_size));
++                         MIN(sizeof(extra), sn->extra_data_size), 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read snapshot table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+             unknown_extra_data_size = sn->extra_data_size - sizeof(extra);
+             sn->unknown_extra_data = g_malloc(unknown_extra_data_size);
+             ret = bdrv_pread(bs->file, offset, sn->unknown_extra_data,
+-                             unknown_extra_data_size);
++                             unknown_extra_data_size, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret,
+                                  "Failed to read snapshot table");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+         /* Read snapshot ID */
+         sn->id_str = g_malloc(id_str_size + 1);
+-        ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size);
++        ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read snapshot table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+         /* Read snapshot name */
+         sn->name = g_malloc(name_size + 1);
+-        ret = bdrv_pread(bs->file, offset, sn->name, name_size);
++        ret = bdrv_pread(bs->file, offset, sn->name, name_size, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read snapshot table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
+         h.name_size = cpu_to_be16(name_size);
+         offset = ROUND_UP(offset, 8);
+-        ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h));
++        ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h), 0);
+         if (ret < 0) {
+             goto fail;
+         }
+         offset += sizeof(h);
+-        ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra));
++        ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra), 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
+             assert(sn->unknown_extra_data);
+             ret = bdrv_pwrite(bs->file, offset, sn->unknown_extra_data,
+-                              unknown_extra_data_size);
++                              unknown_extra_data_size, 0);
+             if (ret < 0) {
+                 goto fail;
+             }
+             offset += unknown_extra_data_size;
+         }
+-        ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size);
++        ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+         offset += id_str_size;
+-        ret = bdrv_pwrite(bs->file, offset, sn->name, name_size);
++        ret = bdrv_pwrite(bs->file, offset, sn->name, name_size, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
+     header_data.snapshots_offset    = cpu_to_be64(snapshots_offset);
+     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
+-                           &header_data, sizeof(header_data));
++                           &header_data, sizeof(header_data), 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
+     /* qcow2_do_open() discards this information in check mode */
+     ret = bdrv_pread(bs->file, offsetof(QCowHeader, nb_snapshots),
+-                     &snapshot_table_pointer, sizeof(snapshot_table_pointer));
++                     &snapshot_table_pointer, sizeof(snapshot_table_pointer),
++                     0);
+     if (ret < 0) {
+         result->check_errors++;
+         fprintf(stderr, "ERROR failed to read the snapshot table pointer from "
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
+         snapshot_table_pointer.nb_snapshots = cpu_to_be32(s->nb_snapshots);
+         ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
+                                &snapshot_table_pointer.nb_snapshots,
+-                               sizeof(snapshot_table_pointer.nb_snapshots));
++                               sizeof(snapshot_table_pointer.nb_snapshots), 0);
+         if (ret < 0) {
+             result->check_errors++;
+             fprintf(stderr, "ERROR failed to update the snapshot count in the "
+@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
+     }
+     ret = bdrv_pwrite(bs->file, sn->l1_table_offset, l1_table,
+-                      s->l1_size * L1E_SIZE);
++                      s->l1_size * L1E_SIZE, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, sn->l1_table_offset,
+-                     sn_l1_table, sn_l1_bytes);
++    ret = bdrv_pread(bs->file, sn->l1_table_offset, sn_l1_table, sn_l1_bytes,
++                     0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
+     }
+     ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, sn_l1_table,
+-                           cur_l1_bytes);
++                           cur_l1_bytes, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
+         return -ENOMEM;
+     }
+-    ret = bdrv_pread(bs->file, sn->l1_table_offset,
+-                     new_l1_table, new_l1_bytes);
++    ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_table,
++                     new_l1_bytes, 0);
+     if (ret < 0) {
+         error_setg(errp, "Failed to read l1 table for snapshot");
+         qemu_vfree(new_l1_table);
+diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.c
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
+         return -1;
+     }
+-    ret = bdrv_pread(bs->file,
+-                     s->crypto_header.offset + offset, buf, buflen);
++    ret = bdrv_pread(bs->file, s->crypto_header.offset + offset, buf, buflen,
++                     0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+         return -1;
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
+         return -1;
+     }
+-    ret = bdrv_pwrite(bs->file,
+-                      s->crypto_header.offset + offset, buf, buflen);
++    ret = bdrv_pwrite(bs->file, s->crypto_header.offset + offset, buf, buflen,
++                      0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+         return -1;
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+         printf("attempting to read extended header in offset %lu\n", offset);
+ #endif
+-        ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext));
++        ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext), 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
+                              "pread fail from offset %" PRIu64, offset);
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+                            sizeof(bs->backing_format));
+                 return 2;
+             }
+-            ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len);
++            ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
+                                  "Could not read format name");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
+             if (p_feature_table != NULL) {
+                 void *feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
+-                ret = bdrv_pread(bs->file, offset , feature_table, ext.len);
++                ret = bdrv_pread(bs->file, offset, feature_table, ext.len, 0);
+                 if (ret < 0) {
+                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
+                                      "Could not read table");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+                 return -EINVAL;
+             }
+-            ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len);
++            ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret,
+                                  "Unable to read CRYPTO header extension");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+                 break;
+             }
+-            ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len);
++            ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret, "bitmaps_ext: "
+                                  "Could not read ext header");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+         case QCOW2_EXT_MAGIC_DATA_FILE:
+         {
+             s->image_data_file = g_malloc0(ext.len + 1);
+-            ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len);
++            ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret,
+                                  "ERROR: Could not read data file name");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+                 uext->len = ext.len;
+                 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
+-                ret = bdrv_pread(bs->file, offset , uext->data, uext->len);
++                ret = bdrv_pread(bs->file, offset, uext->data, uext->len, 0);
+                 if (ret < 0) {
+                     error_setg_errno(errp, -ret, "ERROR: unknown extension: "
+                                      "Could not read data");
+@@ -XXX,XX +XXX,XX @@ int qcow2_mark_dirty(BlockDriverState *bs)
+     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
+     ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
+-                      &val, sizeof(val));
++                      &val, sizeof(val), 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+     uint64_t l1_vm_state_index;
+     bool update_header = false;
+-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
++    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read qcow2 header");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+         s->unknown_header_fields_size = header.header_length - sizeof(header);
+         s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
+         ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
+-                         s->unknown_header_fields_size);
++                         s->unknown_header_fields_size, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
+                              "fields");
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+             goto fail;
+         }
+         ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
+-                         s->l1_size * L1E_SIZE);
++                         s->l1_size * L1E_SIZE, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Could not read L1 table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+             goto fail;
+         }
+         ret = bdrv_pread(bs->file, header.backing_file_offset,
+-                         bs->auto_backing_file, len);
++                         bs->auto_backing_file, len, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Could not read backing file name");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ int qcow2_update_header(BlockDriverState *bs)
+     }
+     /* Write the new header */
+-    ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size);
++    ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+     /* write updated header.size */
+     offset = cpu_to_be64(offset);
+-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
+-                           &offset, sizeof(offset));
++    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), &offset,
++                           sizeof(offset), 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to update the image size");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
+     l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
+     l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
+     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
+-                           &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));
++                           &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls), 0);
+     if (ret < 0) {
+         goto fail_broken_refcounts;
+     }
+@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
+     /* Enter the first refblock into the reftable */
+     rt_entry = cpu_to_be64(2 * s->cluster_size);
+-    ret = bdrv_pwrite_sync(bs->file, s->cluster_size,
+-                           &rt_entry, sizeof(rt_entry));
++    ret = bdrv_pwrite_sync(bs->file, s->cluster_size, &rt_entry,
++                           sizeof(rt_entry), 0);
+     if (ret < 0) {
+         goto fail_broken_refcounts;
+     }
+diff --git a/block/qed.c b/block/qed.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qed.c
++++ b/block/qed.c
+@@ -XXX,XX +XXX,XX @@ int qed_write_header_sync(BDRVQEDState *s)
+     int ret;
+     qed_header_cpu_to_le(&s->header, &le);
+-    ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le));
++    ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le), 0);
+     if (ret != sizeof(le)) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int qed_read_string(BdrvChild *file, uint64_t offset, size_t n,
+     if (n >= buflen) {
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(file, offset, buf, n);
++    ret = bdrv_pread(file, offset, buf, n, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_do_open(BlockDriverState *bs, QDict *options,
+     int64_t file_size;
+     int ret;
+-    ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header));
++    ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header), 0);
+     if (ret < 0) {
+         error_setg(errp, "Failed to read QED header");
+         return ret;
+@@ -XXX,XX +XXX,XX @@ static int bdrv_qed_change_backing_file(BlockDriverState *bs,
+     }
+     /* Write new header */
+-    ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len);
++    ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len, 0);
+     g_free(buffer);
+     if (ret == 0) {
+         memcpy(&s->header, &new_header, sizeof(new_header));
+diff --git a/block/vdi.c b/block/vdi.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vdi.c
++++ b/block/vdi.c
+@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
+     logout("\n");
+-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
++    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
+     }
+     ret = bdrv_pread(bs->file, header.offset_bmap, s->bmap,
+-                     bmap_size * SECTOR_SIZE);
++                     bmap_size * SECTOR_SIZE, 0);
+     if (ret < 0) {
+         goto fail_free_bmap;
+     }
+@@ -XXX,XX +XXX,XX @@ vdi_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
+              * so this full-cluster write does not overlap a partial write
+              * of the same cluster, issued from the "else" branch.
+              */
+-            ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size);
++            ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size, 0);
+             qemu_co_rwlock_unlock(&s->bmap_lock);
+         } else {
+ nonallocating_write:
+@@ -XXX,XX +XXX,XX @@ nonallocating_write:
+         assert(VDI_IS_ALLOCATED(bmap_first));
+         *header = s->header;
+         vdi_header_to_le(header);
+-        ret = bdrv_pwrite(bs->file, 0, header, sizeof(*header));
++        ret = bdrv_pwrite(bs->file, 0, header, sizeof(*header), 0);
+         g_free(header);
+         if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ nonallocating_write:
+         logout("will write %u block map sectors starting from entry %u\n",
+                n_sectors, bmap_first);
+         ret = bdrv_pwrite(bs->file, offset * SECTOR_SIZE, base,
+-                          n_sectors * SECTOR_SIZE);
++                          n_sectors * SECTOR_SIZE, 0);
+     }
+     return ret < 0 ? ret : 0;
+diff --git a/block/vhdx-log.c b/block/vhdx-log.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vhdx-log.c
++++ b/block/vhdx-log.c
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_peek_hdr(BlockDriverState *bs, VHDXLogEntries *log,
+     offset = log->offset + read;
+-    ret = bdrv_pread(bs->file, offset, hdr, sizeof(VHDXLogEntryHeader));
++    ret = bdrv_pread(bs->file, offset, hdr, sizeof(VHDXLogEntryHeader), 0);
+     if (ret < 0) {
+         goto exit;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_read_sectors(BlockDriverState *bs, VHDXLogEntries *log,
+         }
+         offset = log->offset + read;
+-        ret = bdrv_pread(bs->file, offset, buffer, VHDX_LOG_SECTOR_SIZE);
++        ret = bdrv_pread(bs->file, offset, buffer, VHDX_LOG_SECTOR_SIZE, 0);
+         if (ret < 0) {
+             goto exit;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
+             /* full */
+             break;
+         }
+-        ret = bdrv_pwrite(bs->file, offset, buffer_tmp,
+-                          VHDX_LOG_SECTOR_SIZE);
++        ret = bdrv_pwrite(bs->file, offset, buffer_tmp, VHDX_LOG_SECTOR_SIZE,
++                          0);
+         if (ret < 0) {
+             goto exit;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush_desc(BlockDriverState *bs, VHDXLogDescriptor *desc,
+     /* count is only > 1 if we are writing zeroes */
+     for (i = 0; i < count; i++) {
+         ret = bdrv_pwrite_sync(bs->file, file_offset, buffer,
+-                               VHDX_LOG_SECTOR_SIZE);
++                               VHDX_LOG_SECTOR_SIZE, 0);
+         if (ret < 0) {
+             goto exit;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
+         if (i == 0 && leading_length) {
+             /* partial sector at the front of the buffer */
+             ret = bdrv_pread(bs->file, file_offset, merged_sector,
+-                             VHDX_LOG_SECTOR_SIZE);
++                             VHDX_LOG_SECTOR_SIZE, 0);
+             if (ret < 0) {
+                 goto exit;
+             }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
+             sector_write = merged_sector;
+         } else if (i == sectors - 1 && trailing_length) {
+             /* partial sector at the end of the buffer */
+-            ret = bdrv_pread(bs->file,
+-                            file_offset,
+-                            merged_sector + trailing_length,
+-                            VHDX_LOG_SECTOR_SIZE - trailing_length);
++            ret = bdrv_pread(bs->file, file_offset,
++                             merged_sector + trailing_length,
++                             VHDX_LOG_SECTOR_SIZE - trailing_length, 0);
+             if (ret < 0) {
+                 goto exit;
+             }
+diff --git a/block/vhdx.c b/block/vhdx.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vhdx.c
++++ b/block/vhdx.c
+@@ -XXX,XX +XXX,XX @@ static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr,
+     buffer = qemu_blockalign(bs_file, VHDX_HEADER_SIZE);
+     if (read) {
+         /* if true, we can't assume the extra reserved bytes are 0 */
+-        ret = bdrv_pread(file, offset, buffer, VHDX_HEADER_SIZE);
++        ret = bdrv_pread(file, offset, buffer, VHDX_HEADER_SIZE, 0);
+         if (ret < 0) {
+             goto exit;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr,
+     vhdx_header_le_export(hdr, header_le);
+     vhdx_update_checksum(buffer, VHDX_HEADER_SIZE,
+                          offsetof(VHDXHeader, checksum));
+-    ret = bdrv_pwrite_sync(file, offset, header_le, sizeof(VHDXHeader));
++    ret = bdrv_pwrite_sync(file, offset, header_le, sizeof(VHDXHeader), 0);
+ exit:
+     qemu_vfree(buffer);
+@@ -XXX,XX +XXX,XX @@ static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s,
+     /* We have to read the whole VHDX_HEADER_SIZE instead of
+      * sizeof(VHDXHeader), because the checksum is over the whole
+      * region */
+-    ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, buffer,
+-                     VHDX_HEADER_SIZE);
++    ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, buffer, VHDX_HEADER_SIZE,
++                     0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s,
+         }
+     }
+-    ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, buffer,
+-                     VHDX_HEADER_SIZE);
++    ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, buffer, VHDX_HEADER_SIZE,
++                     0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s)
+     buffer = qemu_blockalign(bs, VHDX_HEADER_BLOCK_SIZE);
+     ret = bdrv_pread(bs->file, VHDX_REGION_TABLE_OFFSET, buffer,
+-                     VHDX_HEADER_BLOCK_SIZE);
++                     VHDX_HEADER_BLOCK_SIZE, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+     buffer = qemu_blockalign(bs, VHDX_METADATA_TABLE_MAX_SIZE);
+     ret = bdrv_pread(bs->file, s->metadata_rt.file_offset, buffer,
+-                     VHDX_METADATA_TABLE_MAX_SIZE);
++                     VHDX_METADATA_TABLE_MAX_SIZE, 0);
+     if (ret < 0) {
+         goto exit;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+                      s->metadata_entries.file_parameters_entry.offset
+                                          + s->metadata_rt.file_offset,
+                      &s->params,
+-                     sizeof(s->params));
++                     sizeof(s->params),
++                     0);
+     if (ret < 0) {
+         goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+                      s->metadata_entries.virtual_disk_size_entry.offset
+                                            + s->metadata_rt.file_offset,
+                      &s->virtual_disk_size,
+-                     sizeof(uint64_t));
++                     sizeof(uint64_t),
++                     0);
+     if (ret < 0) {
+         goto exit;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+                      s->metadata_entries.logical_sector_size_entry.offset
+                                              + s->metadata_rt.file_offset,
+                      &s->logical_sector_size,
+-                     sizeof(uint32_t));
++                     sizeof(uint32_t),
++                     0);
+     if (ret < 0) {
+         goto exit;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+                      s->metadata_entries.phys_sector_size_entry.offset
+                                           + s->metadata_rt.file_offset,
+                      &s->physical_sector_size,
+-                     sizeof(uint32_t));
++                     sizeof(uint32_t),
++                     0);
+     if (ret < 0) {
+         goto exit;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
+     QLIST_INIT(&s->regions);
+     /* validate the file signature */
+-    ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t));
++    ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t), 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length);
++    ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+diff --git a/block/vmdk.c b/block/vmdk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vmdk.c
++++ b/block/vmdk.c
+@@ -XXX,XX +XXX,XX @@ static int vmdk_read_cid(BlockDriverState *bs, int parent, uint32_t *pcid)
+     int ret;
+     desc = g_malloc0(DESC_SIZE);
+-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
++    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
+     if (ret < 0) {
+         goto out;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
+     desc = g_malloc0(DESC_SIZE);
+     tmp_desc = g_malloc0(DESC_SIZE);
+-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
++    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
+     if (ret < 0) {
+         goto out;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
+         pstrcat(desc, DESC_SIZE, tmp_desc);
+     }
+-    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE);
++    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
+ out:
+     g_free(desc);
+@@ -XXX,XX +XXX,XX @@ static int vmdk_parent_open(BlockDriverState *bs)
+     int ret;
+     desc = g_malloc0(DESC_SIZE + 1);
+-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
++    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
+     if (ret < 0) {
+         goto out;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
+         return -ENOMEM;
+     }
+-    ret = bdrv_pread(extent->file,
+-                     extent->l1_table_offset,
+-                     extent->l1_table,
+-                     l1_size);
++    ret = bdrv_pread(extent->file, extent->l1_table_offset, extent->l1_table,
++                     l1_size, 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(extent->file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
+             ret = -ENOMEM;
+             goto fail_l1;
+         }
+-        ret = bdrv_pread(extent->file,
+-                         extent->l1_backup_table_offset,
+-                         extent->l1_backup_table,
+-                         l1_size);
++        ret = bdrv_pread(extent->file, extent->l1_backup_table_offset,
++                         extent->l1_backup_table, l1_size, 0);
+         if (ret < 0) {
+             bdrv_refresh_filename(extent->file->bs);
+             error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
+     VMDK3Header header;
+     VmdkExtent *extent = NULL;
+-    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
++    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header), 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_se_sparse(BlockDriverState *bs,
+     assert(sizeof(const_header) == SECTOR_SIZE);
+-    ret = bdrv_pread(file, 0, &const_header, sizeof(const_header));
++    ret = bdrv_pread(file, 0, &const_header, sizeof(const_header), 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_se_sparse(BlockDriverState *bs,
+     assert(sizeof(volatile_header) == SECTOR_SIZE);
+-    ret = bdrv_pread(file,
+-                     const_header.volatile_header_offset * SECTOR_SIZE,
+-                     &volatile_header, sizeof(volatile_header));
++    ret = bdrv_pread(file, const_header.volatile_header_offset * SECTOR_SIZE,
++                     &volatile_header, sizeof(volatile_header), 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static char *vmdk_read_desc(BdrvChild *file, uint64_t desc_offset, Error **errp)
+     size = MIN(size, (1 << 20) - 1);  /* avoid unbounded allocation */
+     buf = g_malloc(size + 1);
+-    ret = bdrv_pread(file, desc_offset, buf, size);
++    ret = bdrv_pread(file, desc_offset, buf, size, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read from file");
+         g_free(buf);
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
+     int64_t l1_backup_offset = 0;
+     bool compressed;
+-    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
++    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header), 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
+             } QEMU_PACKED eos_marker;
+         } QEMU_PACKED footer;
+-        ret = bdrv_pread(file,
+-            bs->file->bs->total_sectors * 512 - 1536,
+-            &footer, sizeof(footer));
++        ret = bdrv_pread(file, bs->file->bs->total_sectors * 512 - 1536,
++                         &footer, sizeof(footer), 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read footer");
+             return ret;
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+             /* qcow2 emits this on bs->file instead of bs->backing */
+             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
+             ret = bdrv_pread(bs->backing, offset, whole_grain,
+-                             skip_start_bytes);
++                             skip_start_bytes, 0);
+             if (ret < 0) {
+                 ret = VMDK_ERROR;
+                 goto exit;
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+         }
+         BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
+         ret = bdrv_pwrite(extent->file, cluster_offset, whole_grain,
+-                          skip_start_bytes);
++                          skip_start_bytes, 0);
+         if (ret < 0) {
+             ret = VMDK_ERROR;
+             goto exit;
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
+             ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
+                              whole_grain + skip_end_bytes,
+-                             cluster_bytes - skip_end_bytes);
++                             cluster_bytes - skip_end_bytes, 0);
+             if (ret < 0) {
+                 ret = VMDK_ERROR;
+                 goto exit;
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+         BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
+         ret = bdrv_pwrite(extent->file, cluster_offset + skip_end_bytes,
+                           whole_grain + skip_end_bytes,
+-                          cluster_bytes - skip_end_bytes);
++                          cluster_bytes - skip_end_bytes, 0);
+         if (ret < 0) {
+             ret = VMDK_ERROR;
+             goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
+     if (bdrv_pwrite(extent->file,
+                 ((int64_t)m_data->l2_offset * 512)
+                     + (m_data->l2_index * sizeof(offset)),
+-                &offset, sizeof(offset)) < 0) {
++                &offset, sizeof(offset), 0) < 0) {
+         return VMDK_ERROR;
+     }
+     /* update backup L2 table */
+@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
+         if (bdrv_pwrite(extent->file,
+                     ((int64_t)m_data->l2_offset * 512)
+                         + (m_data->l2_index * sizeof(offset)),
+-                    &offset, sizeof(offset)) < 0) {
++                    &offset, sizeof(offset), 0) < 0) {
+             return VMDK_ERROR;
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+     if (bdrv_pread(extent->file,
+                 (int64_t)l2_offset * 512,
+                 l2_table,
+-                l2_size_bytes
++                l2_size_bytes,
++                0
+             ) != l2_size_bytes) {
+         return VMDK_ERROR;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
+     cluster_buf = g_malloc(buf_bytes);
+     uncomp_buf = g_malloc(cluster_bytes);
+     BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
+-    ret = bdrv_pread(extent->file,
+-                cluster_offset,
+-                cluster_buf, buf_bytes);
++    ret = bdrv_pread(extent->file, cluster_offset, cluster_buf, buf_bytes, 0);
+     if (ret < 0) {
+         goto out;
+     }
+diff --git a/block/vpc.c b/block/vpc.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vpc.c
++++ b/block/vpc.c
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, 0, &s->footer, sizeof(s->footer));
++    ret = bdrv_pread(bs->file, 0, &s->footer, sizeof(s->footer), 0);
+     if (ret < 0) {
+         error_setg(errp, "Unable to read VHD header");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+         }
+         /* If a fixed disk, the footer is found only at the end of the file */
+-        ret = bdrv_pread(bs->file, offset - sizeof(*footer),
+-                         footer, sizeof(*footer));
++        ret = bdrv_pread(bs->file, offset - sizeof(*footer), footer,
++                         sizeof(*footer), 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+     if (disk_type == VHD_DYNAMIC) {
+         ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset),
+-                         &dyndisk_header, sizeof(dyndisk_header));
++                         &dyndisk_header, sizeof(dyndisk_header), 0);
+         if (ret < 0) {
+             error_setg(errp, "Error reading dynamic VHD header");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+         s->bat_offset = be64_to_cpu(dyndisk_header.table_offset);
+         ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable,
+-                         pagetable_size);
++                         pagetable_size, 0);
+         if (ret < 0) {
+             error_setg(errp, "Error reading pagetable");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
+         s->last_bitmap_offset = bitmap_offset;
+         memset(bitmap, 0xff, s->bitmap_size);
+-        r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);
++        r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size,
++                             0);
+         if (r < 0) {
+             *err = r;
+             return -2;
+@@ -XXX,XX +XXX,XX @@ static int rewrite_footer(BlockDriverState *bs)
+     BDRVVPCState *s = bs->opaque;
+     int64_t offset = s->free_data_block_offset;
+-    ret = bdrv_pwrite_sync(bs->file, offset, &s->footer, sizeof(s->footer));
++    ret = bdrv_pwrite_sync(bs->file, offset, &s->footer, sizeof(s->footer), 0);
+     if (ret < 0)
+         return ret;
+@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
+     /* Initialize the block's bitmap */
+     memset(bitmap, 0xff, s->bitmap_size);
+     ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
+-        s->bitmap_size);
++                           s->bitmap_size, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
+     /* Write BAT entry to disk */
+     bat_offset = s->bat_offset + (4 * index);
+     bat_value = cpu_to_be32(s->pagetable[index]);
+-    ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4);
++    ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4, 0);
+     if (ret < 0)
+         goto fail;
+diff --git a/block/vvfat.c b/block/vvfat.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vvfat.c
++++ b/block/vvfat.c
+@@ -XXX,XX +XXX,XX @@ static int vvfat_read(BlockDriverState *bs, int64_t sector_num,
+                              " allocated\n", sector_num,
+                              n >> BDRV_SECTOR_BITS));
+                 if (bdrv_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE,
+-                               buf + i * 0x200, n) < 0) {
++                               buf + i * 0x200, n, 0) < 0) {
+                     return -1;
+                 }
+                 i += (n >> BDRV_SECTOR_BITS) - 1;
+@@ -XXX,XX +XXX,XX @@ static uint32_t get_cluster_count_for_direntry(BDRVVVFATState* s,
+                             return -1;
+                         }
+                         res = bdrv_pwrite(s->qcow, offset * BDRV_SECTOR_SIZE,
+-                                          s->cluster_buffer, BDRV_SECTOR_SIZE);
++                                          s->cluster_buffer, BDRV_SECTOR_SIZE,
++                                          0);
+                         if (res < 0) {
+                             return -2;
+                         }
+@@ -XXX,XX +XXX,XX @@ DLOG(checkpoint());
+      */
+ DLOG(fprintf(stderr, "Write to qcow backend: %d + %d\n", (int)sector_num, nb_sectors));
+     ret = bdrv_pwrite(s->qcow, sector_num * BDRV_SECTOR_SIZE, buf,
+-                      nb_sectors * BDRV_SECTOR_SIZE);
++                      nb_sectors * BDRV_SECTOR_SIZE, 0);
+     if (ret < 0) {
+         fprintf(stderr, "Error writing to qcow backend\n");
+         return ret;
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pread(BdrvChild *c)
+     int ret;
+     /* Success */
+-    ret = bdrv_pread(c, 0, buf, sizeof(buf));
++    ret = bdrv_pread(c, 0, buf, sizeof(buf), 0);
+     g_assert_cmpint(ret, ==, 512);
+     /* Early error: Negative offset */
+-    ret = bdrv_pread(c, -2, buf, sizeof(buf));
++    ret = bdrv_pread(c, -2, buf, sizeof(buf), 0);
+     g_assert_cmpint(ret, ==, -EIO);
+ }
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pwrite(BdrvChild *c)
+     int ret;
+     /* Success */
+-    ret = bdrv_pwrite(c, 0, buf, sizeof(buf));
++    ret = bdrv_pwrite(c, 0, buf, sizeof(buf), 0);
+     g_assert_cmpint(ret, ==, 512);
+     /* Early error: Negative offset */
+-    ret = bdrv_pwrite(c, -2, buf, sizeof(buf));
++    ret = bdrv_pwrite(c, -2, buf, sizeof(buf), 0);
+     g_assert_cmpint(ret, ==, -EIO);
+ }
+--
+.35.3

-New patch
+[PULL 02/35] block: Change bdrv_{pread, pwrite, pwrite_sync}() param order
+From: Alberto Faria <afaria@redhat.com>
+Swap 'buf' and 'bytes' around for consistency with
+bdrv_co_{pread,pwrite}(), and in preparation to implement these
+functions using generated_co_wrapper.
+Callers were updated using this Coccinelle script:
+    @@ expression child, offset, buf, bytes, flags; @@
+    - bdrv_pread(child, offset, buf, bytes, flags)
+    + bdrv_pread(child, offset, bytes, buf, flags)
+    @@ expression child, offset, buf, bytes, flags; @@
+    - bdrv_pwrite(child, offset, buf, bytes, flags)
+    + bdrv_pwrite(child, offset, bytes, buf, flags)
+    @@ expression child, offset, buf, bytes, flags; @@
+    - bdrv_pwrite_sync(child, offset, buf, bytes, flags)
+    + bdrv_pwrite_sync(child, offset, bytes, buf, flags)
+Resulting overly-long lines were then fixed by hand.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+Message-Id: <20220609152744.3891847-3-afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/block/block-io.h         | 10 +++---
+ block/blklogwrites.c             |  6 ++--
+ block/bochs.c                    | 10 +++---
+ block/cloop.c                    | 10 +++---
+ block/crypto.c                   |  4 +--
+ block/dmg.c                      | 26 +++++++--------
+ block/io.c                       | 12 +++----
+ block/parallels-ext.c            |  6 ++--
+ block/parallels.c                | 10 +++---
+ block/qcow.c                     | 34 +++++++++----------
+ block/qcow2-bitmap.c             | 14 ++++----
+ block/qcow2-cache.c              |  8 ++---
+ block/qcow2-cluster.c            | 22 ++++++-------
+ block/qcow2-refcount.c           | 56 +++++++++++++++++---------------
+ block/qcow2-snapshot.c           | 48 +++++++++++++--------------
+ block/qcow2.c                    | 47 ++++++++++++++-------------
+ block/qed.c                      |  8 ++---
+ block/vdi.c                      | 14 ++++----
+ block/vhdx-log.c                 | 18 +++++-----
+ block/vhdx.c                     | 28 ++++++++--------
+ block/vmdk.c                     | 50 ++++++++++++++--------------
+ block/vpc.c                      | 22 ++++++-------
+ block/vvfat.c                    | 10 +++---
+ tests/unit/test-block-iothread.c |  8 ++---
+files changed, 242 insertions(+), 239 deletions(-)
+diff --git a/include/block/block-io.h b/include/block/block-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/block-io.h
++++ b/include/block/block-io.h
+@@ -XXX,XX +XXX,XX @@
+ int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
+                        int64_t bytes, BdrvRequestFlags flags);
+ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
+-int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
++int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
+                BdrvRequestFlags flags);
+-int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
+-                int64_t bytes, BdrvRequestFlags flags);
+-int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
+-                     const void *buf, int64_t bytes, BdrvRequestFlags flags);
++int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
++                const void *buf, BdrvRequestFlags flags);
++int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
++                     const void *buf, BdrvRequestFlags flags);
+ /*
+  * Efficiently zero a region of the disk image.  Note that this is a regular
+  * I/O request like read or write and should have a reasonable size.  This
+diff --git a/block/blklogwrites.c b/block/blklogwrites.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/blklogwrites.c
++++ b/block/blklogwrites.c
+@@ -XXX,XX +XXX,XX @@ static uint64_t blk_log_writes_find_cur_log_sector(BdrvChild *log,
+     struct log_write_entry cur_entry;
+     while (cur_idx < nr_entries) {
+-        int read_ret = bdrv_pread(log, cur_sector << sector_bits, &cur_entry,
+-                                  sizeof(cur_entry), 0);
++        int read_ret = bdrv_pread(log, cur_sector << sector_bits,
++                                  sizeof(cur_entry), &cur_entry, 0);
+         if (read_ret < 0) {
+             error_setg_errno(errp, -read_ret,
+                              "Failed to read log entry %"PRIu64, cur_idx);
+@@ -XXX,XX +XXX,XX @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
+             log_sb.nr_entries = cpu_to_le64(0);
+             log_sb.sectorsize = cpu_to_le32(BDRV_SECTOR_SIZE);
+         } else {
+-            ret = bdrv_pread(s->log_file, 0, &log_sb, sizeof(log_sb), 0);
++            ret = bdrv_pread(s->log_file, 0, sizeof(log_sb), &log_sb, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret, "Could not read log superblock");
+                 goto fail_log;
+diff --git a/block/bochs.c b/block/bochs.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/bochs.c
++++ b/block/bochs.c
+@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs), 0);
++    ret = bdrv_pread(bs->file, 0, sizeof(bochs), &bochs, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
+         return -ENOMEM;
+     }
+-    ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_bitmap,
+-                     s->catalog_size * 4, 0);
++    ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_size * 4,
++                     s->catalog_bitmap, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
+         (s->extent_blocks + s->bitmap_blocks));
+     /* read in bitmap for current extent */
+-    ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8),
+-                     &bitmap_entry, 1, 0);
++    ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8), 1,
++                     &bitmap_entry, 0);
+     if (ret < 0) {
+         return ret;
+     }
+diff --git a/block/cloop.c b/block/cloop.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/cloop.c
++++ b/block/cloop.c
+@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
+     }
+     /* read header */
+-    ret = bdrv_pread(bs->file, 128, &s->block_size, 4, 0);
++    ret = bdrv_pread(bs->file, 128, 4, &s->block_size, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4, 0);
++    ret = bdrv_pread(bs->file, 128 + 4, 4, &s->n_blocks, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
+         return -ENOMEM;
+     }
+-    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size, 0);
++    ret = bdrv_pread(bs->file, 128 + 4 + 4, offsets_size, s->offsets, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
+         int ret;
+         uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];
+-        ret = bdrv_pread(bs->file, s->offsets[block_num], s->compressed_block,
+-                         bytes, 0);
++        ret = bdrv_pread(bs->file, s->offsets[block_num], bytes,
++                         s->compressed_block, 0);
+         if (ret != bytes) {
+             return -1;
+         }
+diff --git a/block/crypto.c b/block/crypto.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/crypto.c
++++ b/block/crypto.c
+@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
+     BlockDriverState *bs = opaque;
+     ssize_t ret;
+-    ret = bdrv_pread(bs->file, offset, buf, buflen, 0);
++    ret = bdrv_pread(bs->file, offset, buflen, buf, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+         return ret;
+@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_write_func(QCryptoBlock *block,
+     BlockDriverState *bs = opaque;
+     ssize_t ret;
+-    ret = bdrv_pwrite(bs->file, offset, buf, buflen, 0);
++    ret = bdrv_pwrite(bs->file, offset, buflen, buf, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not write encryption header");
+         return ret;
+diff --git a/block/dmg.c b/block/dmg.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/dmg.c
++++ b/block/dmg.c
+@@ -XXX,XX +XXX,XX @@ static int read_uint64(BlockDriverState *bs, int64_t offset, uint64_t *result)
+     uint64_t buffer;
+     int ret;
+-    ret = bdrv_pread(bs->file, offset, &buffer, 8, 0);
++    ret = bdrv_pread(bs->file, offset, 8, &buffer, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int read_uint32(BlockDriverState *bs, int64_t offset, uint32_t *result)
+     uint32_t buffer;
+     int ret;
+-    ret = bdrv_pread(bs->file, offset, &buffer, 4, 0);
++    ret = bdrv_pread(bs->file, offset, 4, &buffer, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int64_t dmg_find_koly_offset(BdrvChild *file, Error **errp)
+         offset = length - 511 - 512;
+     }
+     length = length < 515 ? length : 515;
+-    ret = bdrv_pread(file, offset, buffer, length, 0);
++    ret = bdrv_pread(file, offset, length, buffer, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed while reading UDIF trailer");
+         return ret;
+@@ -XXX,XX +XXX,XX @@ static int dmg_read_resource_fork(BlockDriverState *bs, DmgHeaderState *ds,
+         offset += 4;
+         buffer = g_realloc(buffer, count);
+-        ret = bdrv_pread(bs->file, offset, buffer, count, 0);
++        ret = bdrv_pread(bs->file, offset, count, buffer, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int dmg_read_plist_xml(BlockDriverState *bs, DmgHeaderState *ds,
+     buffer = g_malloc(info_length + 1);
+     buffer[info_length] = '\0';
+-    ret = bdrv_pread(bs->file, info_begin, buffer, info_length, 0);
++    ret = bdrv_pread(bs->file, info_begin, info_length, buffer, 0);
+     if (ret != info_length) {
+         ret = -EINVAL;
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+         case UDZO: { /* zlib compressed */
+             /* we need to buffer, because only the chunk as whole can be
+              * inflated. */
+-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
+-                             s->lengths[chunk], 0);
++            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
++                             s->compressed_chunk, 0);
+             if (ret != s->lengths[chunk]) {
+                 return -1;
+             }
+@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+             }
+             /* we need to buffer, because only the chunk as whole can be
+              * inflated. */
+-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
+-                             s->lengths[chunk], 0);
++            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
++                             s->compressed_chunk, 0);
+             if (ret != s->lengths[chunk]) {
+                 return -1;
+             }
+@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+             }
+             /* we need to buffer, because only the chunk as whole can be
+              * inflated. */
+-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
+-                             s->lengths[chunk], 0);
++            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
++                             s->compressed_chunk, 0);
+             if (ret != s->lengths[chunk]) {
+                 return -1;
+             }
+@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+             }
+             break;
+         case UDRW: /* copy */
+-            ret = bdrv_pread(bs->file, s->offsets[chunk],
+-                             s->uncompressed_chunk, s->lengths[chunk], 0);
++            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
++                             s->uncompressed_chunk, 0);
+             if (ret != s->lengths[chunk]) {
+                 return -1;
+             }
+diff --git a/block/io.c b/block/io.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/io.c
++++ b/block/io.c
+@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
+ }
+ /* See bdrv_pwrite() for the return codes */
+-int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
++int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
+                BdrvRequestFlags flags)
+ {
+     int ret;
+@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
+   -EINVAL      Invalid offset or number of bytes
+   -EACCES      Trying to write a read-only device
+ */
+-int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
+-                int64_t bytes, BdrvRequestFlags flags)
++int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
++                const void *buf, BdrvRequestFlags flags)
+ {
+     int ret;
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+@@ -XXX,XX +XXX,XX @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
+  *
+  * Returns 0 on success, -errno in error cases.
+  */
+-int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
+-                     const void *buf, int64_t count, BdrvRequestFlags flags)
++int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
++                     const void *buf, BdrvRequestFlags flags)
+ {
+     int ret;
+     IO_CODE();
+-    ret = bdrv_pwrite(child, offset, buf, count, flags);
++    ret = bdrv_pwrite(child, offset, bytes, buf, flags);
+     if (ret < 0) {
+         return ret;
+     }
+diff --git a/block/parallels-ext.c b/block/parallels-ext.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/parallels-ext.c
++++ b/block/parallels-ext.c
+@@ -XXX,XX +XXX,XX @@ static int parallels_load_bitmap_data(BlockDriverState *bs,
+         if (entry == 1) {
+             bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
+         } else {
+-            ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS, buf,
+-                             s->cluster_size, 0);
++            ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS,
++                             s->cluster_size, buf, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret,
+                                  "Failed to read bitmap data cluster");
+@@ -XXX,XX +XXX,XX @@ int parallels_read_format_extension(BlockDriverState *bs,
+     assert(ext_off > 0);
+-    ret = bdrv_pread(bs->file, ext_off, ext_cluster, s->cluster_size, 0);
++    ret = bdrv_pread(bs->file, ext_off, s->cluster_size, ext_cluster, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to read Format Extension cluster");
+         goto out;
+diff --git a/block/parallels.c b/block/parallels.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/parallels.c
++++ b/block/parallels.c
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs)
+         if (off + to_write > s->header_size) {
+             to_write = s->header_size - off;
+         }
+-        ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off, to_write,
++        ret = bdrv_pwrite(bs->file, off, to_write, (uint8_t *)s->header + off,
+);
+         if (ret < 0) {
+             qemu_co_mutex_unlock(&s->lock);
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
+     ret = 0;
+     if (flush_bat) {
+-        ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size, 0);
++        ret = bdrv_pwrite_sync(bs->file, 0, s->header_size, s->header, 0);
+         if (ret < 0) {
+             res->check_errors++;
+             goto out;
+@@ -XXX,XX +XXX,XX @@ static int parallels_update_header(BlockDriverState *bs)
+     if (size > s->header_size) {
+         size = s->header_size;
+     }
+-    return bdrv_pwrite_sync(bs->file, 0, s->header, size, 0);
++    return bdrv_pwrite_sync(bs->file, 0, size, s->header, 0);
+ }
+ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph), 0);
++    ret = bdrv_pread(bs->file, 0, sizeof(ph), &ph, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
+         s->header_size = size;
+     }
+-    ret = bdrv_pread(bs->file, 0, s->header, s->header_size, 0);
++    ret = bdrv_pread(bs->file, 0, s->header_size, s->header, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+diff --git a/block/qcow.c b/block/qcow.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow.c
++++ b/block/qcow.c
+@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
++    ret = bdrv_pread(bs->file, 0, sizeof(header), &header, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
+-                     s->l1_size * sizeof(uint64_t), 0);
++    ret = bdrv_pread(bs->file, s->l1_table_offset,
++                     s->l1_size * sizeof(uint64_t), s->l1_table, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
+             ret = -EINVAL;
+             goto fail;
+         }
+-        ret = bdrv_pread(bs->file, header.backing_file_offset,
+-                         bs->auto_backing_file, len, 0);
++        ret = bdrv_pread(bs->file, header.backing_file_offset, len,
++                         bs->auto_backing_file, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+         BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
+         ret = bdrv_pwrite_sync(bs->file,
+                                s->l1_table_offset + l1_index * sizeof(tmp),
+-                               &tmp, sizeof(tmp), 0);
++                               sizeof(tmp), &tmp, 0);
+         if (ret < 0) {
+             return ret;
+         }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+     BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
+     if (new_l2_table) {
+         memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
+-        ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
+-                               s->l2_size * sizeof(uint64_t), 0);
++        ret = bdrv_pwrite_sync(bs->file, l2_offset,
++                               s->l2_size * sizeof(uint64_t), l2_table, 0);
+         if (ret < 0) {
+             return ret;
+         }
+     } else {
+-        ret = bdrv_pread(bs->file, l2_offset, l2_table,
+-                         s->l2_size * sizeof(uint64_t), 0);
++        ret = bdrv_pread(bs->file, l2_offset, s->l2_size * sizeof(uint64_t),
++                         l2_table, 0);
+         if (ret < 0) {
+             return ret;
+         }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+             cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);
+             /* write the cluster content */
+             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+-            ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache,
+-                              s->cluster_size, 0);
++            ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_size,
++                              s->cluster_cache, 0);
+             if (ret < 0) {
+                 return ret;
+             }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+                             }
+                             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+                             ret = bdrv_pwrite(bs->file, cluster_offset + i,
+-                                              s->cluster_data,
+-                                              BDRV_SECTOR_SIZE, 0);
++                                              BDRV_SECTOR_SIZE,
++                                              s->cluster_data, 0);
+                             if (ret < 0) {
+                                 return ret;
+                             }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+             BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
+         }
+         ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
+-                               &tmp, sizeof(tmp), 0);
++                               sizeof(tmp), &tmp, 0);
+         if (ret < 0) {
+             return ret;
+         }
+@@ -XXX,XX +XXX,XX @@ static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
+         csize = cluster_offset >> (63 - s->cluster_bits);
+         csize &= (s->cluster_size - 1);
+         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
+-        ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize, 0);
++        ret = bdrv_pread(bs->file, coffset, csize, s->cluster_data, 0);
+         if (ret != csize)
+             return -1;
+         if (decompress_buffer(s->cluster_cache, s->cluster_size,
+@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
+     int ret;
+     memset(s->l1_table, 0, l1_length);
+-    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table, l1_length,
++    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, l1_length, s->l1_table,
+) < 0)
+         return -1;
+     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
+diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-bitmap.c
++++ b/block/qcow2-bitmap.c
+@@ -XXX,XX +XXX,XX @@ static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
+     }
+     assert(tb->size <= BME_MAX_TABLE_SIZE);
+-    ret = bdrv_pread(bs->file, tb->offset, table,
+-                     tb->size * BME_TABLE_ENTRY_SIZE, 0);
++    ret = bdrv_pread(bs->file, tb->offset, tb->size * BME_TABLE_ENTRY_SIZE,
++                     table, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int load_bitmap_data(BlockDriverState *bs,
+                  * already cleared */
+             }
+         } else {
+-            ret = bdrv_pread(bs->file, data_offset, buf, s->cluster_size, 0);
++            ret = bdrv_pread(bs->file, data_offset, s->cluster_size, buf, 0);
+             if (ret < 0) {
+                 goto finish;
+             }
+@@ -XXX,XX +XXX,XX @@ static Qcow2BitmapList *bitmap_list_load(BlockDriverState *bs, uint64_t offset,
+     }
+     dir_end = dir + size;
+-    ret = bdrv_pread(bs->file, offset, dir, size, 0);
++    ret = bdrv_pread(bs->file, offset, size, dir, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to read bitmap directory");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list,
+         goto fail;
+     }
+-    ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size, 0);
++    ret = bdrv_pwrite(bs->file, dir_offset, dir_size, dir, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static uint64_t *store_bitmap_data(BlockDriverState *bs,
+             goto fail;
+         }
+-        ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size, 0);
++        ret = bdrv_pwrite(bs->file, off, s->cluster_size, buf, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
+                              bm_name);
+@@ -XXX,XX +XXX,XX @@ static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp)
+     }
+     bitmap_table_to_be(tb, tb_size);
+-    ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]), 0);
++    ret = bdrv_pwrite(bs->file, tb_offset, tb_size * sizeof(tb[0]), tb, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
+                          bm_name);
+diff --git a/block/qcow2-cache.c b/block/qcow2-cache.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-cache.c
++++ b/block/qcow2-cache.c
+@@ -XXX,XX +XXX,XX @@ static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
+         BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
+     }
+-    ret = bdrv_pwrite(bs->file, c->entries[i].offset,
+-                      qcow2_cache_get_table_addr(c, i), c->table_size, 0);
++    ret = bdrv_pwrite(bs->file, c->entries[i].offset, c->table_size,
++                      qcow2_cache_get_table_addr(c, i), 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
+             BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
+         }
+-        ret = bdrv_pread(bs->file, offset, qcow2_cache_get_table_addr(c, i),
+-                         c->table_size, 0);
++        ret = bdrv_pread(bs->file, offset, c->table_size,
++                         qcow2_cache_get_table_addr(c, i), 0);
+         if (ret < 0) {
+             return ret;
+         }
+diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-cluster.c
++++ b/block/qcow2-cluster.c
+@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
+     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE);
+     for(i = 0; i < s->l1_size; i++)
+         new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
+-    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, new_l1_table,
+-                           new_l1_size2, 0);
++    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, new_l1_size2,
++                           new_l1_table, 0);
+     if (ret < 0)
+         goto fail;
+     for(i = 0; i < s->l1_size; i++)
+@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
+     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);
+     stl_be_p(data, new_l1_size);
+     stq_be_p(data + 4, new_l1_table_offset);
+-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size), data,
+-                           sizeof(data), 0);
++    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size),
++                           sizeof(data), data, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)
+     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
+     ret = bdrv_pwrite_sync(bs->file,
+                            s->l1_table_offset + L1E_SIZE * l1_start_index,
+-                           buf, bufsize, 0);
++                           bufsize, buf, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
+                                       (void **)&l2_slice);
+             } else {
+                 /* load inactive L2 tables from disk */
+-                ret = bdrv_pread(bs->file, slice_offset, l2_slice,
+-                                 slice_size2, 0);
++                ret = bdrv_pread(bs->file, slice_offset, slice_size2,
++                                 l2_slice, 0);
+             }
+             if (ret < 0) {
+                 goto fail;
+@@ -XXX,XX +XXX,XX @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
+                         goto fail;
+                     }
+-                    ret = bdrv_pwrite(bs->file, slice_offset, l2_slice,
+-                                      slice_size2, 0);
++                    ret = bdrv_pwrite(bs->file, slice_offset, slice_size2,
++                                      l2_slice, 0);
+                     if (ret < 0) {
+                         goto fail;
+                     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_expand_zero_clusters(BlockDriverState *bs,
+         l1_table = new_l1_table;
+-        ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset, l1_table,
+-                         l1_size2, 0);
++        ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset, l1_size2,
++                         l1_table, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-refcount.c
++++ b/block/qcow2-refcount.c
+@@ -XXX,XX +XXX,XX @@ int qcow2_refcount_init(BlockDriverState *bs)
+         }
+         BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
+         ret = bdrv_pread(bs->file, s->refcount_table_offset,
+-                         s->refcount_table, refcount_table_size2, 0);
++                         refcount_table_size2, s->refcount_table, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,
+         BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);
+         ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset +
+                                refcount_table_index * REFTABLE_ENTRY_SIZE,
+-            &data64, sizeof(data64), 0);
++            sizeof(data64), &data64, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
+     }
+     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);
+-    ret = bdrv_pwrite_sync(bs->file, table_offset, new_table,
+-                           table_size * REFTABLE_ENTRY_SIZE, 0);
++    ret = bdrv_pwrite_sync(bs->file, table_offset,
++                           table_size * REFTABLE_ENTRY_SIZE, new_table, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
+     data.d32 = cpu_to_be32(table_clusters);
+     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);
+     ret = bdrv_pwrite_sync(bs->file,
+-                           offsetof(QCowHeader, refcount_table_offset), &data,
+-                           sizeof(data), 0);
++                           offsetof(QCowHeader, refcount_table_offset),
++                           sizeof(data), &data, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
+         }
+         l1_allocated = true;
+-        ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2, 0);
++        ret = bdrv_pread(bs->file, l1_table_offset, l1_size2, l1_table, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ fail:
+             cpu_to_be64s(&l1_table[i]);
+         }
+-        ret = bdrv_pwrite_sync(bs->file, l1_table_offset, l1_table, l1_size2,
++        ret = bdrv_pwrite_sync(bs->file, l1_table_offset, l1_size2, l1_table,
+);
+         for (i = 0; i < l1_size; i++) {
+@@ -XXX,XX +XXX,XX @@ static int fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
+         goto fail;
+     }
+-    ret = bdrv_pwrite_sync(bs->file, l2e_offset, &l2_table[idx],
+-                           l2_entry_size(s), 0);
++    ret = bdrv_pwrite_sync(bs->file, l2e_offset, l2_entry_size(s),
++                           &l2_table[idx], 0);
+     if (ret < 0) {
+         fprintf(stderr, "ERROR: Failed to overwrite L2 "
+                 "table entry: %s\n", strerror(-ret));
+@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
+     bool metadata_overlap;
+     /* Read L2 table from disk */
+-    ret = bdrv_pread(bs->file, l2_offset, l2_table, l2_size_bytes, 0);
++    ret = bdrv_pread(bs->file, l2_offset, l2_size_bytes, l2_table, 0);
+     if (ret < 0) {
+         fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
+         res->check_errors++;
+@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
+     }
+     /* Read L1 table entries from disk */
+-    ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size_bytes, 0);
++    ret = bdrv_pread(bs->file, l1_table_offset, l1_size_bytes, l1_table, 0);
+     if (ret < 0) {
+         fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
+         res->check_errors++;
+@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
+             }
+         }
+-        ret = bdrv_pread(bs->file, l2_offset, l2_table,
+-                         s->l2_size * l2_entry_size(s), 0);
++        ret = bdrv_pread(bs->file, l2_offset, s->l2_size * l2_entry_size(s),
++                         l2_table, 0);
+         if (ret < 0) {
+             fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
+                     strerror(-ret));
+@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
+                 goto fail;
+             }
+-            ret = bdrv_pwrite(bs->file, l2_offset, l2_table, s->cluster_size,
++            ret = bdrv_pwrite(bs->file, l2_offset, s->cluster_size, l2_table,
+);
+             if (ret < 0) {
+                 fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
+@@ -XXX,XX +XXX,XX @@ static int rebuild_refcounts_write_refblocks(
+         on_disk_refblock = (void *)((char *) *refcount_table +
+                                     refblock_index * s->cluster_size);
+-        ret = bdrv_pwrite(bs->file, refblock_offset, on_disk_refblock,
+-                          s->cluster_size, 0);
++        ret = bdrv_pwrite(bs->file, refblock_offset, s->cluster_size,
++                          on_disk_refblock, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "ERROR writing refblock");
+             return ret;
+@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
+     }
+     assert(reftable_length < INT_MAX);
+-    ret = bdrv_pwrite(bs->file, reftable_offset, on_disk_reftable,
+-                      reftable_length, 0);
++    ret = bdrv_pwrite(bs->file, reftable_offset, reftable_length,
++                      on_disk_reftable, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "ERROR writing reftable");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
+         cpu_to_be32(reftable_clusters);
+     ret = bdrv_pwrite_sync(bs->file,
+                            offsetof(QCowHeader, refcount_table_offset),
+-                           &reftable_offset_and_clusters,
+-                           sizeof(reftable_offset_and_clusters), 0);
++                           sizeof(reftable_offset_and_clusters),
++                           &reftable_offset_and_clusters, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "ERROR setting reftable");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
+                 return -ENOMEM;
+             }
+-            ret = bdrv_pread(bs->file, l1_ofs, l1, l1_sz2, 0);
++            ret = bdrv_pread(bs->file, l1_ofs, l1_sz2, l1, 0);
+             if (ret < 0) {
+                 g_free(l1);
+                 return ret;
+@@ -XXX,XX +XXX,XX @@ static int flush_refblock(BlockDriverState *bs, uint64_t **reftable,
+             return ret;
+         }
+-        ret = bdrv_pwrite(bs->file, offset, refblock, s->cluster_size, 0);
++        ret = bdrv_pwrite(bs->file, offset, s->cluster_size, refblock, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to write refblock");
+             return ret;
+@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
+         cpu_to_be64s(&new_reftable[i]);
+     }
+-    ret = bdrv_pwrite(bs->file, new_reftable_offset, new_reftable,
+-                      new_reftable_size * REFTABLE_ENTRY_SIZE, 0);
++    ret = bdrv_pwrite(bs->file, new_reftable_offset,
++                      new_reftable_size * REFTABLE_ENTRY_SIZE, new_reftable,
++                      0);
+     for (i = 0; i < new_reftable_size; i++) {
+         be64_to_cpus(&new_reftable[i]);
+@@ -XXX,XX +XXX,XX @@ int qcow2_shrink_reftable(BlockDriverState *bs)
+         reftable_tmp[i] = unused_block ? 0 : cpu_to_be64(s->refcount_table[i]);
+     }
+-    ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset, reftable_tmp,
+-                           s->refcount_table_size * REFTABLE_ENTRY_SIZE, 0);
++    ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset,
++                           s->refcount_table_size * REFTABLE_ENTRY_SIZE,
++                           reftable_tmp, 0);
+     /*
+      * If the write in the reftable failed the image may contain a partially
+      * overwritten reftable. In this case it would be better to clear the
+diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-snapshot.c
++++ b/block/qcow2-snapshot.c
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+         /* Read statically sized part of the snapshot header */
+         offset = ROUND_UP(offset, 8);
+-        ret = bdrv_pread(bs->file, offset, &h, sizeof(h), 0);
++        ret = bdrv_pread(bs->file, offset, sizeof(h), &h, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read snapshot table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+         }
+         /* Read known extra data */
+-        ret = bdrv_pread(bs->file, offset, &extra,
+-                         MIN(sizeof(extra), sn->extra_data_size), 0);
++        ret = bdrv_pread(bs->file, offset,
++                         MIN(sizeof(extra), sn->extra_data_size), &extra, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read snapshot table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+             /* Store unknown extra data */
+             unknown_extra_data_size = sn->extra_data_size - sizeof(extra);
+             sn->unknown_extra_data = g_malloc(unknown_extra_data_size);
+-            ret = bdrv_pread(bs->file, offset, sn->unknown_extra_data,
+-                             unknown_extra_data_size, 0);
++            ret = bdrv_pread(bs->file, offset, unknown_extra_data_size,
++                             sn->unknown_extra_data, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret,
+                                  "Failed to read snapshot table");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+         /* Read snapshot ID */
+         sn->id_str = g_malloc(id_str_size + 1);
+-        ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size, 0);
++        ret = bdrv_pread(bs->file, offset, id_str_size, sn->id_str, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read snapshot table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
+         /* Read snapshot name */
+         sn->name = g_malloc(name_size + 1);
+-        ret = bdrv_pread(bs->file, offset, sn->name, name_size, 0);
++        ret = bdrv_pread(bs->file, offset, name_size, sn->name, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read snapshot table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
+         h.name_size = cpu_to_be16(name_size);
+         offset = ROUND_UP(offset, 8);
+-        ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h), 0);
++        ret = bdrv_pwrite(bs->file, offset, sizeof(h), &h, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+         offset += sizeof(h);
+-        ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra), 0);
++        ret = bdrv_pwrite(bs->file, offset, sizeof(extra), &extra, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
+             assert(unknown_extra_data_size <= BDRV_REQUEST_MAX_BYTES);
+             assert(sn->unknown_extra_data);
+-            ret = bdrv_pwrite(bs->file, offset, sn->unknown_extra_data,
+-                              unknown_extra_data_size, 0);
++            ret = bdrv_pwrite(bs->file, offset, unknown_extra_data_size,
++                              sn->unknown_extra_data, 0);
+             if (ret < 0) {
+                 goto fail;
+             }
+             offset += unknown_extra_data_size;
+         }
+-        ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size, 0);
++        ret = bdrv_pwrite(bs->file, offset, id_str_size, sn->id_str, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+         offset += id_str_size;
+-        ret = bdrv_pwrite(bs->file, offset, sn->name, name_size, 0);
++        ret = bdrv_pwrite(bs->file, offset, name_size, sn->name, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
+     header_data.snapshots_offset    = cpu_to_be64(snapshots_offset);
+     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
+-                           &header_data, sizeof(header_data), 0);
++                           sizeof(header_data), &header_data, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
+     /* qcow2_do_open() discards this information in check mode */
+     ret = bdrv_pread(bs->file, offsetof(QCowHeader, nb_snapshots),
+-                     &snapshot_table_pointer, sizeof(snapshot_table_pointer),
++                     sizeof(snapshot_table_pointer), &snapshot_table_pointer,
+);
+     if (ret < 0) {
+         result->check_errors++;
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
+         snapshot_table_pointer.nb_snapshots = cpu_to_be32(s->nb_snapshots);
+         ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
+-                               &snapshot_table_pointer.nb_snapshots,
+-                               sizeof(snapshot_table_pointer.nb_snapshots), 0);
++                               sizeof(snapshot_table_pointer.nb_snapshots),
++                               &snapshot_table_pointer.nb_snapshots, 0);
+         if (ret < 0) {
+             result->check_errors++;
+             fprintf(stderr, "ERROR failed to update the snapshot count in the "
+@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
+         goto fail;
+     }
+-    ret = bdrv_pwrite(bs->file, sn->l1_table_offset, l1_table,
+-                      s->l1_size * L1E_SIZE, 0);
++    ret = bdrv_pwrite(bs->file, sn->l1_table_offset, s->l1_size * L1E_SIZE,
++                      l1_table, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, sn->l1_table_offset, sn_l1_table, sn_l1_bytes,
++    ret = bdrv_pread(bs->file, sn->l1_table_offset, sn_l1_bytes, sn_l1_table,
+);
+     if (ret < 0) {
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
+         goto fail;
+     }
+-    ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, sn_l1_table,
+-                           cur_l1_bytes, 0);
++    ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, cur_l1_bytes,
++                           sn_l1_table, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
+         return -ENOMEM;
+     }
+-    ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_table,
+-                     new_l1_bytes, 0);
++    ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_bytes,
++                     new_l1_table, 0);
+     if (ret < 0) {
+         error_setg(errp, "Failed to read l1 table for snapshot");
+         qemu_vfree(new_l1_table);
+diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.c
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
+         return -1;
+     }
+-    ret = bdrv_pread(bs->file, s->crypto_header.offset + offset, buf, buflen,
++    ret = bdrv_pread(bs->file, s->crypto_header.offset + offset, buflen, buf,
+);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
+         return -1;
+     }
+-    ret = bdrv_pwrite(bs->file, s->crypto_header.offset + offset, buf, buflen,
++    ret = bdrv_pwrite(bs->file, s->crypto_header.offset + offset, buflen, buf,
+);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+         printf("attempting to read extended header in offset %lu\n", offset);
+ #endif
+-        ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext), 0);
++        ret = bdrv_pread(bs->file, offset, sizeof(ext), &ext, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
+                              "pread fail from offset %" PRIu64, offset);
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+                            sizeof(bs->backing_format));
+                 return 2;
+             }
+-            ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len, 0);
++            ret = bdrv_pread(bs->file, offset, ext.len, bs->backing_format, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
+                                  "Could not read format name");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
+             if (p_feature_table != NULL) {
+                 void *feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
+-                ret = bdrv_pread(bs->file, offset, feature_table, ext.len, 0);
++                ret = bdrv_pread(bs->file, offset, ext.len, feature_table, 0);
+                 if (ret < 0) {
+                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
+                                      "Could not read table");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+                 return -EINVAL;
+             }
+-            ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len, 0);
++            ret = bdrv_pread(bs->file, offset, ext.len, &s->crypto_header, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret,
+                                  "Unable to read CRYPTO header extension");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+                 break;
+             }
+-            ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len, 0);
++            ret = bdrv_pread(bs->file, offset, ext.len, &bitmaps_ext, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret, "bitmaps_ext: "
+                                  "Could not read ext header");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+         case QCOW2_EXT_MAGIC_DATA_FILE:
+         {
+             s->image_data_file = g_malloc0(ext.len + 1);
+-            ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len, 0);
++            ret = bdrv_pread(bs->file, offset, ext.len, s->image_data_file, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret,
+                                  "ERROR: Could not read data file name");
+@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+                 uext->len = ext.len;
+                 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
+-                ret = bdrv_pread(bs->file, offset, uext->data, uext->len, 0);
++                ret = bdrv_pread(bs->file, offset, uext->len, uext->data, 0);
+                 if (ret < 0) {
+                     error_setg_errno(errp, -ret, "ERROR: unknown extension: "
+                                      "Could not read data");
+@@ -XXX,XX +XXX,XX @@ int qcow2_mark_dirty(BlockDriverState *bs)
+     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
+     ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
+-                      &val, sizeof(val), 0);
++                      sizeof(val), &val, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+     uint64_t l1_vm_state_index;
+     bool update_header = false;
+-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
++    ret = bdrv_pread(bs->file, 0, sizeof(header), &header, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read qcow2 header");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+     if (header.header_length > sizeof(header)) {
+         s->unknown_header_fields_size = header.header_length - sizeof(header);
+         s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
+-        ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
+-                         s->unknown_header_fields_size, 0);
++        ret = bdrv_pread(bs->file, sizeof(header),
++                         s->unknown_header_fields_size,
++                         s->unknown_header_fields, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
+                              "fields");
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+             ret = -ENOMEM;
+             goto fail;
+         }
+-        ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
+-                         s->l1_size * L1E_SIZE, 0);
++        ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_size * L1E_SIZE,
++                         s->l1_table, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Could not read L1 table");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+             ret = -EINVAL;
+             goto fail;
+         }
+-        ret = bdrv_pread(bs->file, header.backing_file_offset,
+-                         bs->auto_backing_file, len, 0);
++        ret = bdrv_pread(bs->file, header.backing_file_offset, len,
++                         bs->auto_backing_file, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Could not read backing file name");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ int qcow2_update_header(BlockDriverState *bs)
+     }
+     /* Write the new header */
+-    ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size, 0);
++    ret = bdrv_pwrite(bs->file, 0, s->cluster_size, header, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+     /* write updated header.size */
+     offset = cpu_to_be64(offset);
+-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), &offset,
+-                           sizeof(offset), 0);
++    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
++                           sizeof(offset), &offset, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to update the image size");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
+     l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
+     l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
+     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
+-                           &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls), 0);
++                           sizeof(l1_ofs_rt_ofs_cls), &l1_ofs_rt_ofs_cls, 0);
+     if (ret < 0) {
+         goto fail_broken_refcounts;
+     }
+@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
+     /* Enter the first refblock into the reftable */
+     rt_entry = cpu_to_be64(2 * s->cluster_size);
+-    ret = bdrv_pwrite_sync(bs->file, s->cluster_size, &rt_entry,
+-                           sizeof(rt_entry), 0);
++    ret = bdrv_pwrite_sync(bs->file, s->cluster_size, sizeof(rt_entry),
++                           &rt_entry, 0);
+     if (ret < 0) {
+         goto fail_broken_refcounts;
+     }
+diff --git a/block/qed.c b/block/qed.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qed.c
++++ b/block/qed.c
+@@ -XXX,XX +XXX,XX @@ int qed_write_header_sync(BDRVQEDState *s)
+     int ret;
+     qed_header_cpu_to_le(&s->header, &le);
+-    ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le), 0);
++    ret = bdrv_pwrite(s->bs->file, 0, sizeof(le), &le, 0);
+     if (ret != sizeof(le)) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int qed_read_string(BdrvChild *file, uint64_t offset, size_t n,
+     if (n >= buflen) {
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(file, offset, buf, n, 0);
++    ret = bdrv_pread(file, offset, n, buf, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_do_open(BlockDriverState *bs, QDict *options,
+     int64_t file_size;
+     int ret;
+-    ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header), 0);
++    ret = bdrv_pread(bs->file, 0, sizeof(le_header), &le_header, 0);
+     if (ret < 0) {
+         error_setg(errp, "Failed to read QED header");
+         return ret;
+@@ -XXX,XX +XXX,XX @@ static int bdrv_qed_change_backing_file(BlockDriverState *bs,
+     }
+     /* Write new header */
+-    ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len, 0);
++    ret = bdrv_pwrite_sync(bs->file, 0, buffer_len, buffer, 0);
+     g_free(buffer);
+     if (ret == 0) {
+         memcpy(&s->header, &new_header, sizeof(new_header));
+diff --git a/block/vdi.c b/block/vdi.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vdi.c
++++ b/block/vdi.c
+@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
+     logout("\n");
+-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
++    ret = bdrv_pread(bs->file, 0, sizeof(header), &header, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, header.offset_bmap, s->bmap,
+-                     bmap_size * SECTOR_SIZE, 0);
++    ret = bdrv_pread(bs->file, header.offset_bmap, bmap_size * SECTOR_SIZE,
++                     s->bmap, 0);
+     if (ret < 0) {
+         goto fail_free_bmap;
+     }
+@@ -XXX,XX +XXX,XX @@ vdi_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
+              * so this full-cluster write does not overlap a partial write
+              * of the same cluster, issued from the "else" branch.
+              */
+-            ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size, 0);
++            ret = bdrv_pwrite(bs->file, data_offset, s->block_size, block, 0);
+             qemu_co_rwlock_unlock(&s->bmap_lock);
+         } else {
+ nonallocating_write:
+@@ -XXX,XX +XXX,XX @@ nonallocating_write:
+         assert(VDI_IS_ALLOCATED(bmap_first));
+         *header = s->header;
+         vdi_header_to_le(header);
+-        ret = bdrv_pwrite(bs->file, 0, header, sizeof(*header), 0);
++        ret = bdrv_pwrite(bs->file, 0, sizeof(*header), header, 0);
+         g_free(header);
+         if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ nonallocating_write:
+         base = ((uint8_t *)&s->bmap[0]) + bmap_first * SECTOR_SIZE;
+         logout("will write %u block map sectors starting from entry %u\n",
+                n_sectors, bmap_first);
+-        ret = bdrv_pwrite(bs->file, offset * SECTOR_SIZE, base,
+-                          n_sectors * SECTOR_SIZE, 0);
++        ret = bdrv_pwrite(bs->file, offset * SECTOR_SIZE,
++                          n_sectors * SECTOR_SIZE, base, 0);
+     }
+     return ret < 0 ? ret : 0;
+diff --git a/block/vhdx-log.c b/block/vhdx-log.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vhdx-log.c
++++ b/block/vhdx-log.c
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_peek_hdr(BlockDriverState *bs, VHDXLogEntries *log,
+     offset = log->offset + read;
+-    ret = bdrv_pread(bs->file, offset, hdr, sizeof(VHDXLogEntryHeader), 0);
++    ret = bdrv_pread(bs->file, offset, sizeof(VHDXLogEntryHeader), hdr, 0);
+     if (ret < 0) {
+         goto exit;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_read_sectors(BlockDriverState *bs, VHDXLogEntries *log,
+         }
+         offset = log->offset + read;
+-        ret = bdrv_pread(bs->file, offset, buffer, VHDX_LOG_SECTOR_SIZE, 0);
++        ret = bdrv_pread(bs->file, offset, VHDX_LOG_SECTOR_SIZE, buffer, 0);
+         if (ret < 0) {
+             goto exit;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
+             /* full */
+             break;
+         }
+-        ret = bdrv_pwrite(bs->file, offset, buffer_tmp, VHDX_LOG_SECTOR_SIZE,
++        ret = bdrv_pwrite(bs->file, offset, VHDX_LOG_SECTOR_SIZE, buffer_tmp,
+);
+         if (ret < 0) {
+             goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush_desc(BlockDriverState *bs, VHDXLogDescriptor *desc,
+     /* count is only > 1 if we are writing zeroes */
+     for (i = 0; i < count; i++) {
+-        ret = bdrv_pwrite_sync(bs->file, file_offset, buffer,
+-                               VHDX_LOG_SECTOR_SIZE, 0);
++        ret = bdrv_pwrite_sync(bs->file, file_offset, VHDX_LOG_SECTOR_SIZE,
++                               buffer, 0);
+         if (ret < 0) {
+             goto exit;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
+         if (i == 0 && leading_length) {
+             /* partial sector at the front of the buffer */
+-            ret = bdrv_pread(bs->file, file_offset, merged_sector,
+-                             VHDX_LOG_SECTOR_SIZE, 0);
++            ret = bdrv_pread(bs->file, file_offset, VHDX_LOG_SECTOR_SIZE,
++                             merged_sector, 0);
+             if (ret < 0) {
+                 goto exit;
+             }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
+         } else if (i == sectors - 1 && trailing_length) {
+             /* partial sector at the end of the buffer */
+             ret = bdrv_pread(bs->file, file_offset,
+-                             merged_sector + trailing_length,
+-                             VHDX_LOG_SECTOR_SIZE - trailing_length, 0);
++                             VHDX_LOG_SECTOR_SIZE - trailing_length,
++                             merged_sector + trailing_length, 0);
+             if (ret < 0) {
+                 goto exit;
+             }
+diff --git a/block/vhdx.c b/block/vhdx.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vhdx.c
++++ b/block/vhdx.c
+@@ -XXX,XX +XXX,XX @@ static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr,
+     buffer = qemu_blockalign(bs_file, VHDX_HEADER_SIZE);
+     if (read) {
+         /* if true, we can't assume the extra reserved bytes are 0 */
+-        ret = bdrv_pread(file, offset, buffer, VHDX_HEADER_SIZE, 0);
++        ret = bdrv_pread(file, offset, VHDX_HEADER_SIZE, buffer, 0);
+         if (ret < 0) {
+             goto exit;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr,
+     vhdx_header_le_export(hdr, header_le);
+     vhdx_update_checksum(buffer, VHDX_HEADER_SIZE,
+                          offsetof(VHDXHeader, checksum));
+-    ret = bdrv_pwrite_sync(file, offset, header_le, sizeof(VHDXHeader), 0);
++    ret = bdrv_pwrite_sync(file, offset, sizeof(VHDXHeader), header_le, 0);
+ exit:
+     qemu_vfree(buffer);
+@@ -XXX,XX +XXX,XX @@ static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s,
+     /* We have to read the whole VHDX_HEADER_SIZE instead of
+      * sizeof(VHDXHeader), because the checksum is over the whole
+      * region */
+-    ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, buffer, VHDX_HEADER_SIZE,
++    ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, VHDX_HEADER_SIZE, buffer,
+);
+     if (ret < 0) {
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s,
+         }
+     }
+-    ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, buffer, VHDX_HEADER_SIZE,
++    ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, VHDX_HEADER_SIZE, buffer,
+);
+     if (ret < 0) {
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s)
+      * whole block */
+     buffer = qemu_blockalign(bs, VHDX_HEADER_BLOCK_SIZE);
+-    ret = bdrv_pread(bs->file, VHDX_REGION_TABLE_OFFSET, buffer,
+-                     VHDX_HEADER_BLOCK_SIZE, 0);
++    ret = bdrv_pread(bs->file, VHDX_REGION_TABLE_OFFSET,
++                     VHDX_HEADER_BLOCK_SIZE, buffer, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+     buffer = qemu_blockalign(bs, VHDX_METADATA_TABLE_MAX_SIZE);
+-    ret = bdrv_pread(bs->file, s->metadata_rt.file_offset, buffer,
+-                     VHDX_METADATA_TABLE_MAX_SIZE, 0);
++    ret = bdrv_pread(bs->file, s->metadata_rt.file_offset,
++                     VHDX_METADATA_TABLE_MAX_SIZE, buffer, 0);
+     if (ret < 0) {
+         goto exit;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+     ret = bdrv_pread(bs->file,
+                      s->metadata_entries.file_parameters_entry.offset
+                                          + s->metadata_rt.file_offset,
+-                     &s->params,
+                      sizeof(s->params),
++                     &s->params,
+);
+     if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+     ret = bdrv_pread(bs->file,
+                      s->metadata_entries.virtual_disk_size_entry.offset
+                                            + s->metadata_rt.file_offset,
+-                     &s->virtual_disk_size,
+                      sizeof(uint64_t),
++                     &s->virtual_disk_size,
+);
+     if (ret < 0) {
+         goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+     ret = bdrv_pread(bs->file,
+                      s->metadata_entries.logical_sector_size_entry.offset
+                                              + s->metadata_rt.file_offset,
+-                     &s->logical_sector_size,
+                      sizeof(uint32_t),
++                     &s->logical_sector_size,
+);
+     if (ret < 0) {
+         goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
+     ret = bdrv_pread(bs->file,
+                      s->metadata_entries.phys_sector_size_entry.offset
+                                           + s->metadata_rt.file_offset,
+-                     &s->physical_sector_size,
+                      sizeof(uint32_t),
++                     &s->physical_sector_size,
+);
+     if (ret < 0) {
+         goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
+     QLIST_INIT(&s->regions);
+     /* validate the file signature */
+-    ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t), 0);
++    ret = bdrv_pread(bs->file, 0, sizeof(uint64_t), &signature, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length, 0);
++    ret = bdrv_pread(bs->file, s->bat_offset, s->bat_rt.length, s->bat, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+diff --git a/block/vmdk.c b/block/vmdk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vmdk.c
++++ b/block/vmdk.c
+@@ -XXX,XX +XXX,XX @@ static int vmdk_read_cid(BlockDriverState *bs, int parent, uint32_t *pcid)
+     int ret;
+     desc = g_malloc0(DESC_SIZE);
+-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
++    ret = bdrv_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
+     if (ret < 0) {
+         goto out;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
+     desc = g_malloc0(DESC_SIZE);
+     tmp_desc = g_malloc0(DESC_SIZE);
+-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
++    ret = bdrv_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
+     if (ret < 0) {
+         goto out;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
+         pstrcat(desc, DESC_SIZE, tmp_desc);
+     }
+-    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
++    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
+ out:
+     g_free(desc);
+@@ -XXX,XX +XXX,XX @@ static int vmdk_parent_open(BlockDriverState *bs)
+     int ret;
+     desc = g_malloc0(DESC_SIZE + 1);
+-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
++    ret = bdrv_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
+     if (ret < 0) {
+         goto out;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
+         return -ENOMEM;
+     }
+-    ret = bdrv_pread(extent->file, extent->l1_table_offset, extent->l1_table,
+-                     l1_size, 0);
++    ret = bdrv_pread(extent->file, extent->l1_table_offset, l1_size,
++                     extent->l1_table, 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(extent->file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
+             goto fail_l1;
+         }
+         ret = bdrv_pread(extent->file, extent->l1_backup_table_offset,
+-                         extent->l1_backup_table, l1_size, 0);
++                         l1_size, extent->l1_backup_table, 0);
+         if (ret < 0) {
+             bdrv_refresh_filename(extent->file->bs);
+             error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
+     VMDK3Header header;
+     VmdkExtent *extent = NULL;
+-    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header), 0);
++    ret = bdrv_pread(file, sizeof(magic), sizeof(header), &header, 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_se_sparse(BlockDriverState *bs,
+     assert(sizeof(const_header) == SECTOR_SIZE);
+-    ret = bdrv_pread(file, 0, &const_header, sizeof(const_header), 0);
++    ret = bdrv_pread(file, 0, sizeof(const_header), &const_header, 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_se_sparse(BlockDriverState *bs,
+     assert(sizeof(volatile_header) == SECTOR_SIZE);
+     ret = bdrv_pread(file, const_header.volatile_header_offset * SECTOR_SIZE,
+-                     &volatile_header, sizeof(volatile_header), 0);
++                     sizeof(volatile_header), &volatile_header, 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static char *vmdk_read_desc(BdrvChild *file, uint64_t desc_offset, Error **errp)
+     size = MIN(size, (1 << 20) - 1);  /* avoid unbounded allocation */
+     buf = g_malloc(size + 1);
+-    ret = bdrv_pread(file, desc_offset, buf, size, 0);
++    ret = bdrv_pread(file, desc_offset, size, buf, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read from file");
+         g_free(buf);
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
+     int64_t l1_backup_offset = 0;
+     bool compressed;
+-    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header), 0);
++    ret = bdrv_pread(file, sizeof(magic), sizeof(header), &header, 0);
+     if (ret < 0) {
+         bdrv_refresh_filename(file->bs);
+         error_setg_errno(errp, -ret,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
+         } QEMU_PACKED footer;
+         ret = bdrv_pread(file, bs->file->bs->total_sectors * 512 - 1536,
+-                         &footer, sizeof(footer), 0);
++                         sizeof(footer), &footer, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to read footer");
+             return ret;
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+         if (copy_from_backing) {
+             /* qcow2 emits this on bs->file instead of bs->backing */
+             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
+-            ret = bdrv_pread(bs->backing, offset, whole_grain,
+-                             skip_start_bytes, 0);
++            ret = bdrv_pread(bs->backing, offset, skip_start_bytes,
++                             whole_grain, 0);
+             if (ret < 0) {
+                 ret = VMDK_ERROR;
+                 goto exit;
+             }
+         }
+         BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
+-        ret = bdrv_pwrite(extent->file, cluster_offset, whole_grain,
+-                          skip_start_bytes, 0);
++        ret = bdrv_pwrite(extent->file, cluster_offset, skip_start_bytes,
++                          whole_grain, 0);
+         if (ret < 0) {
+             ret = VMDK_ERROR;
+             goto exit;
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+             /* qcow2 emits this on bs->file instead of bs->backing */
+             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
+             ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
+-                             whole_grain + skip_end_bytes,
+-                             cluster_bytes - skip_end_bytes, 0);
++                             cluster_bytes - skip_end_bytes,
++                             whole_grain + skip_end_bytes, 0);
+             if (ret < 0) {
+                 ret = VMDK_ERROR;
+                 goto exit;
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+         }
+         BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
+         ret = bdrv_pwrite(extent->file, cluster_offset + skip_end_bytes,
+-                          whole_grain + skip_end_bytes,
+-                          cluster_bytes - skip_end_bytes, 0);
++                          cluster_bytes - skip_end_bytes,
++                          whole_grain + skip_end_bytes, 0);
+         if (ret < 0) {
+             ret = VMDK_ERROR;
+             goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
+     if (bdrv_pwrite(extent->file,
+                 ((int64_t)m_data->l2_offset * 512)
+                     + (m_data->l2_index * sizeof(offset)),
+-                &offset, sizeof(offset), 0) < 0) {
++                sizeof(offset), &offset, 0) < 0) {
+         return VMDK_ERROR;
+     }
+     /* update backup L2 table */
+@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
+         if (bdrv_pwrite(extent->file,
+                     ((int64_t)m_data->l2_offset * 512)
+                         + (m_data->l2_index * sizeof(offset)),
+-                    &offset, sizeof(offset), 0) < 0) {
++                    sizeof(offset), &offset, 0) < 0) {
+             return VMDK_ERROR;
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+     BLKDBG_EVENT(extent->file, BLKDBG_L2_LOAD);
+     if (bdrv_pread(extent->file,
+                 (int64_t)l2_offset * 512,
+-                l2_table,
+                 l2_size_bytes,
++                l2_table,
+             ) != l2_size_bytes) {
+         return VMDK_ERROR;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
+     cluster_buf = g_malloc(buf_bytes);
+     uncomp_buf = g_malloc(cluster_bytes);
+     BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
+-    ret = bdrv_pread(extent->file, cluster_offset, cluster_buf, buf_bytes, 0);
++    ret = bdrv_pread(extent->file, cluster_offset, buf_bytes, cluster_buf, 0);
+     if (ret < 0) {
+         goto out;
+     }
+diff --git a/block/vpc.c b/block/vpc.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vpc.c
++++ b/block/vpc.c
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+         goto fail;
+     }
+-    ret = bdrv_pread(bs->file, 0, &s->footer, sizeof(s->footer), 0);
++    ret = bdrv_pread(bs->file, 0, sizeof(s->footer), &s->footer, 0);
+     if (ret < 0) {
+         error_setg(errp, "Unable to read VHD header");
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+         }
+         /* If a fixed disk, the footer is found only at the end of the file */
+-        ret = bdrv_pread(bs->file, offset - sizeof(*footer), footer,
+-                         sizeof(*footer), 0);
++        ret = bdrv_pread(bs->file, offset - sizeof(*footer), sizeof(*footer),
++                         footer, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+     if (disk_type == VHD_DYNAMIC) {
+         ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset),
+-                         &dyndisk_header, sizeof(dyndisk_header), 0);
++                         sizeof(dyndisk_header), &dyndisk_header, 0);
+         if (ret < 0) {
+             error_setg(errp, "Error reading dynamic VHD header");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+         s->bat_offset = be64_to_cpu(dyndisk_header.table_offset);
+-        ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable,
+-                         pagetable_size, 0);
++        ret = bdrv_pread(bs->file, s->bat_offset, pagetable_size,
++                         s->pagetable, 0);
+         if (ret < 0) {
+             error_setg(errp, "Error reading pagetable");
+             goto fail;
+@@ -XXX,XX +XXX,XX @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
+         s->last_bitmap_offset = bitmap_offset;
+         memset(bitmap, 0xff, s->bitmap_size);
+-        r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size,
++        r = bdrv_pwrite_sync(bs->file, bitmap_offset, s->bitmap_size, bitmap,
+);
+         if (r < 0) {
+             *err = r;
+@@ -XXX,XX +XXX,XX @@ static int rewrite_footer(BlockDriverState *bs)
+     BDRVVPCState *s = bs->opaque;
+     int64_t offset = s->free_data_block_offset;
+-    ret = bdrv_pwrite_sync(bs->file, offset, &s->footer, sizeof(s->footer), 0);
++    ret = bdrv_pwrite_sync(bs->file, offset, sizeof(s->footer), &s->footer, 0);
+     if (ret < 0)
+         return ret;
+@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
+     /* Initialize the block's bitmap */
+     memset(bitmap, 0xff, s->bitmap_size);
+-    ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
+-                           s->bitmap_size, 0);
++    ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset,
++                           s->bitmap_size, bitmap, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
+     /* Write BAT entry to disk */
+     bat_offset = s->bat_offset + (4 * index);
+     bat_value = cpu_to_be32(s->pagetable[index]);
+-    ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4, 0);
++    ret = bdrv_pwrite_sync(bs->file, bat_offset, 4, &bat_value, 0);
+     if (ret < 0)
+         goto fail;
+diff --git a/block/vvfat.c b/block/vvfat.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vvfat.c
++++ b/block/vvfat.c
+@@ -XXX,XX +XXX,XX @@ static int vvfat_read(BlockDriverState *bs, int64_t sector_num,
+                 DLOG(fprintf(stderr, "sectors %" PRId64 "+%" PRId64
+                              " allocated\n", sector_num,
+                              n >> BDRV_SECTOR_BITS));
+-                if (bdrv_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE,
+-                               buf + i * 0x200, n, 0) < 0) {
++                if (bdrv_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE, n,
++                               buf + i * 0x200, 0) < 0) {
+                     return -1;
+                 }
+                 i += (n >> BDRV_SECTOR_BITS) - 1;
+@@ -XXX,XX +XXX,XX @@ static uint32_t get_cluster_count_for_direntry(BDRVVVFATState* s,
+                             return -1;
+                         }
+                         res = bdrv_pwrite(s->qcow, offset * BDRV_SECTOR_SIZE,
+-                                          s->cluster_buffer, BDRV_SECTOR_SIZE,
++                                          BDRV_SECTOR_SIZE, s->cluster_buffer,
+);
+                         if (res < 0) {
+                             return -2;
+@@ -XXX,XX +XXX,XX @@ DLOG(checkpoint());
+      * Use qcow backend. Commit later.
+      */
+ DLOG(fprintf(stderr, "Write to qcow backend: %d + %d\n", (int)sector_num, nb_sectors));
+-    ret = bdrv_pwrite(s->qcow, sector_num * BDRV_SECTOR_SIZE, buf,
+-                      nb_sectors * BDRV_SECTOR_SIZE, 0);
++    ret = bdrv_pwrite(s->qcow, sector_num * BDRV_SECTOR_SIZE,
++                      nb_sectors * BDRV_SECTOR_SIZE, buf, 0);
+     if (ret < 0) {
+         fprintf(stderr, "Error writing to qcow backend\n");
+         return ret;
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pread(BdrvChild *c)
+     int ret;
+     /* Success */
+-    ret = bdrv_pread(c, 0, buf, sizeof(buf), 0);
++    ret = bdrv_pread(c, 0, sizeof(buf), buf, 0);
+     g_assert_cmpint(ret, ==, 512);
+     /* Early error: Negative offset */
+-    ret = bdrv_pread(c, -2, buf, sizeof(buf), 0);
++    ret = bdrv_pread(c, -2, sizeof(buf), buf, 0);
+     g_assert_cmpint(ret, ==, -EIO);
+ }
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pwrite(BdrvChild *c)
+     int ret;
+     /* Success */
+-    ret = bdrv_pwrite(c, 0, buf, sizeof(buf), 0);
++    ret = bdrv_pwrite(c, 0, sizeof(buf), buf, 0);
+     g_assert_cmpint(ret, ==, 512);
+     /* Early error: Negative offset */
+-    ret = bdrv_pwrite(c, -2, buf, sizeof(buf), 0);
++    ret = bdrv_pwrite(c, -2, sizeof(buf), buf, 0);
+     g_assert_cmpint(ret, ==, -EIO);
+ }
+--
+.35.3

-New patch
+[PULL 03/35] block: Make bdrv_{pread,pwrite}() return 0 on success
+From: Alberto Faria <afaria@redhat.com>
 They currently return the value of their 'bytes' parameter on success.
 Make them return 0 instead, for consistency with other I/O functions and
 in preparation to implement them using generated_co_wrapper. This also
 makes it clear that short reads/writes are not possible.
 The few callers that rely on the previous behavior are adjusted
 accordingly by hand.
 Signed-off-by: Alberto Faria <afaria@redhat.com>
 Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-Id: <20220609152744.3891847-4-afaria@redhat.com>
 Reviewed-by: Hanna Reitz <hreitz@redhat.com>
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
  block/cloop.c                    |  2 +-
  block/crypto.c                   |  4 ++--
  block/dmg.c                      | 10 +++++-----
  block/io.c                       | 10 ++--------
  block/qcow.c                     |  2 +-
  block/qcow2.c                    |  4 ++--
  block/qed.c                      |  7 +------
  block/vdi.c                      |  2 +-
  block/vmdk.c                     |  5 ++---
  tests/unit/test-block-iothread.c |  4 ++--
 files changed, 19 insertions(+), 31 deletions(-)
 diff --git a/block/cloop.c b/block/cloop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/cloop.c
 +++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
          ret = bdrv_pread(bs->file, s->offsets[block_num], bytes,
                           s->compressed_block, 0);
 -        if (ret != bytes) {
 +        if (ret < 0) {
              return -1;
          }
 diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/crypto.c
 +++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
          error_setg_errno(errp, -ret, "Could not read encryption header");
          return ret;
      }
 -    return ret;
 +    return buflen;
  }
  static ssize_t block_crypto_write_func(QCryptoBlock *block,
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_write_func(QCryptoBlock *block,
          error_setg_errno(errp, -ret, "Could not write encryption header");
          return ret;
      }
 -    return ret;
 +    return buflen;
  }
 diff --git a/block/dmg.c b/block/dmg.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/dmg.c
 +++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_read_plist_xml(BlockDriverState *bs, DmgHeaderState *ds,
      buffer = g_malloc(info_length + 1);
      buffer[info_length] = '\0';
      ret = bdrv_pread(bs->file, info_begin, info_length, buffer, 0);
 -    if (ret != info_length) {
 +    if (ret < 0) {
          ret = -EINVAL;
          goto fail;
      }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
               * inflated. */
              ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
                               s->compressed_chunk, 0);
 -            if (ret != s->lengths[chunk]) {
 +            if (ret < 0) {
                  return -1;
              }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
               * inflated. */
              ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
                               s->compressed_chunk, 0);
 -            if (ret != s->lengths[chunk]) {
 +            if (ret < 0) {
                  return -1;
              }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
               * inflated. */
              ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
                               s->compressed_chunk, 0);
 -            if (ret != s->lengths[chunk]) {
 +            if (ret < 0) {
                  return -1;
              }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
          case UDRW: /* copy */
              ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
                               s->uncompressed_chunk, 0);
 -            if (ret != s->lengths[chunk]) {
 +            if (ret < 0) {
                  return -1;
              }
              break;
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
  int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
                 BdrvRequestFlags flags)
  {
 -    int ret;
      QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
      IO_CODE();
@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
          return -EINVAL;
      }
 -    ret = bdrv_preadv(child, offset, bytes, &qiov, flags);
 -
 -    return ret < 0 ? ret : bytes;
 +    return bdrv_preadv(child, offset, bytes, &qiov, flags);
  }
  /* Return no. of bytes on success or < 0 on error. Important errors are:
@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
  int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
                  const void *buf, BdrvRequestFlags flags)
  {
 -    int ret;
      QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
      IO_CODE();
@@ -XXX,XX +XXX,XX @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
          return -EINVAL;
      }
 -    ret = bdrv_pwritev(child, offset, bytes, &qiov, flags);
 -
 -    return ret < 0 ? ret : bytes;
 +    return bdrv_pwritev(child, offset, bytes, &qiov, flags);
  }
  /*
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
          csize &= (s->cluster_size - 1);
          BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
          ret = bdrv_pread(bs->file, coffset, csize, s->cluster_data, 0);
 -        if (ret != csize)
 +        if (ret < 0)
              return -1;
          if (decompress_buffer(s->cluster_cache, s->cluster_size,
                                s->cluster_data, csize) < 0) {
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
          error_setg_errno(errp, -ret, "Could not read encryption header");
          return -1;
      }
 -    return ret;
 +    return buflen;
  }
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
          error_setg_errno(errp, -ret, "Could not read encryption header");
          return -1;
      }
 -    return ret;
 +    return buflen;
  }
  static QDict*
 diff --git a/block/qed.c b/block/qed.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed.c
 +++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static void qed_header_cpu_to_le(const QEDHeader *cpu, QEDHeader *le)
  int qed_write_header_sync(BDRVQEDState *s)
  {
      QEDHeader le;
 -    int ret;
      qed_header_cpu_to_le(&s->header, &le);
 -    ret = bdrv_pwrite(s->bs->file, 0, sizeof(le), &le, 0);
 -    if (ret != sizeof(le)) {
 -        return ret;
 -    }
 -    return 0;
 +    return bdrv_pwrite(s->bs->file, 0, sizeof(le), &le, 0);
  }
  /**
 diff --git a/block/vdi.c b/block/vdi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vdi.c
 +++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
                            n_sectors * SECTOR_SIZE, base, 0);
      }
 -    return ret < 0 ? ret : 0;
 +    return ret;
  }
  static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
 diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vmdk.c
 +++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_parent_open(BlockDriverState *bs)
      if (ret < 0) {
          goto out;
      }
 -    ret = 0;
      p_name = strstr(desc, "parentFileNameHint");
      if (p_name != NULL) {
@@ -XXX,XX +XXX,XX @@ static char *vmdk_read_desc(BdrvChild *file, uint64_t desc_offset, Error **errp)
          g_free(buf);
          return NULL;
      }
 -    buf[ret] = 0;
 +    buf[size] = 0;
      return buf;
  }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
                  l2_size_bytes,
                  l2_table,
 -            ) != l2_size_bytes) {
 +            ) < 0) {
          return VMDK_ERROR;
      }
 diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/unit/test-block-iothread.c
 +++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pread(BdrvChild *c)
      /* Success */
      ret = bdrv_pread(c, 0, sizeof(buf), buf, 0);
 -    g_assert_cmpint(ret, ==, 512);
 +    g_assert_cmpint(ret, ==, 0);
      /* Early error: Negative offset */
      ret = bdrv_pread(c, -2, sizeof(buf), buf, 0);
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pwrite(BdrvChild *c)
      /* Success */
      ret = bdrv_pwrite(c, 0, sizeof(buf), buf, 0);
 -    g_assert_cmpint(ret, ==, 512);
 +    g_assert_cmpint(ret, ==, 0);
      /* Early error: Negative offset */
      ret = bdrv_pwrite(c, -2, sizeof(buf), buf, 0);
 --
 .35.3

-New patch
+[PULL 04/35] crypto: Make block callbacks return 0 on success
+From: Alberto Faria <afaria@redhat.com>
+They currently return the value of their headerlen/buflen parameter on
+success. Returning 0 instead makes it clear that short reads/writes are
+not possible.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20220609152744.3891847-5-afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/crypto/block.h         | 32 ++++++++++-----------
+ block/crypto.c                 | 52 +++++++++++++++++-----------------
+ block/qcow2.c                  | 22 +++++++-------
+ crypto/block-luks.c            |  8 +++---
+ crypto/block.c                 |  6 ++--
+ tests/unit/test-crypto-block.c | 38 ++++++++++++-------------
+files changed, 79 insertions(+), 79 deletions(-)
+diff --git a/include/crypto/block.h b/include/crypto/block.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/crypto/block.h
++++ b/include/crypto/block.h
+@@ -XXX,XX +XXX,XX @@ typedef struct QCryptoBlock QCryptoBlock;
+ /* See also QCryptoBlockFormat, QCryptoBlockCreateOptions
+  * and QCryptoBlockOpenOptions in qapi/crypto.json */
+-typedef ssize_t (*QCryptoBlockReadFunc)(QCryptoBlock *block,
+-                                        size_t offset,
+-                                        uint8_t *buf,
+-                                        size_t buflen,
+-                                        void *opaque,
+-                                        Error **errp);
++typedef int (*QCryptoBlockReadFunc)(QCryptoBlock *block,
++                                    size_t offset,
++                                    uint8_t *buf,
++                                    size_t buflen,
++                                    void *opaque,
++                                    Error **errp);
+-typedef ssize_t (*QCryptoBlockInitFunc)(QCryptoBlock *block,
+-                                        size_t headerlen,
+-                                        void *opaque,
+-                                        Error **errp);
++typedef int (*QCryptoBlockInitFunc)(QCryptoBlock *block,
++                                    size_t headerlen,
++                                    void *opaque,
++                                    Error **errp);
+-typedef ssize_t (*QCryptoBlockWriteFunc)(QCryptoBlock *block,
+-                                         size_t offset,
+-                                         const uint8_t *buf,
+-                                         size_t buflen,
+-                                         void *opaque,
+-                                         Error **errp);
++typedef int (*QCryptoBlockWriteFunc)(QCryptoBlock *block,
++                                     size_t offset,
++                                     const uint8_t *buf,
++                                     size_t buflen,
++                                     void *opaque,
++                                     Error **errp);
+ /**
+  * qcrypto_block_has_format:
+diff --git a/block/crypto.c b/block/crypto.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/crypto.c
++++ b/block/crypto.c
+@@ -XXX,XX +XXX,XX @@ static int block_crypto_probe_generic(QCryptoBlockFormat format,
+ }
+-static ssize_t block_crypto_read_func(QCryptoBlock *block,
+-                                      size_t offset,
+-                                      uint8_t *buf,
+-                                      size_t buflen,
+-                                      void *opaque,
+-                                      Error **errp)
++static int block_crypto_read_func(QCryptoBlock *block,
++                                  size_t offset,
++                                  uint8_t *buf,
++                                  size_t buflen,
++                                  void *opaque,
++                                  Error **errp)
+ {
+     BlockDriverState *bs = opaque;
+     ssize_t ret;
+@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+         return ret;
+     }
+-    return buflen;
++    return 0;
+ }
+-static ssize_t block_crypto_write_func(QCryptoBlock *block,
+-                                       size_t offset,
+-                                       const uint8_t *buf,
+-                                       size_t buflen,
+-                                       void *opaque,
+-                                       Error **errp)
++static int block_crypto_write_func(QCryptoBlock *block,
++                                   size_t offset,
++                                   const uint8_t *buf,
++                                   size_t buflen,
++                                   void *opaque,
++                                   Error **errp)
+ {
+     BlockDriverState *bs = opaque;
+     ssize_t ret;
+@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_write_func(QCryptoBlock *block,
+         error_setg_errno(errp, -ret, "Could not write encryption header");
+         return ret;
+     }
+-    return buflen;
++    return 0;
+ }
+@@ -XXX,XX +XXX,XX @@ struct BlockCryptoCreateData {
+ };
+-static ssize_t block_crypto_create_write_func(QCryptoBlock *block,
+-                                              size_t offset,
+-                                              const uint8_t *buf,
+-                                              size_t buflen,
+-                                              void *opaque,
+-                                              Error **errp)
++static int block_crypto_create_write_func(QCryptoBlock *block,
++                                          size_t offset,
++                                          const uint8_t *buf,
++                                          size_t buflen,
++                                          void *opaque,
++                                          Error **errp)
+ {
+     struct BlockCryptoCreateData *data = opaque;
+     ssize_t ret;
+@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_create_write_func(QCryptoBlock *block,
+         error_setg_errno(errp, -ret, "Could not write encryption header");
+         return ret;
+     }
+-    return ret;
++    return 0;
+ }
+-static ssize_t block_crypto_create_init_func(QCryptoBlock *block,
+-                                             size_t headerlen,
+-                                             void *opaque,
+-                                             Error **errp)
++static int block_crypto_create_init_func(QCryptoBlock *block,
++                                         size_t headerlen,
++                                         void *opaque,
++                                         Error **errp)
+ {
+     struct BlockCryptoCreateData *data = opaque;
+     Error *local_error = NULL;
+@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_create_init_func(QCryptoBlock *block,
+                        data->prealloc, 0, &local_error);
+     if (ret >= 0) {
+-        return ret;
++        return 0;
+     }
+ error:
+diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.c
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
+ }
+-static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
+-                                          uint8_t *buf, size_t buflen,
+-                                          void *opaque, Error **errp)
++static int qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
++                                      uint8_t *buf, size_t buflen,
++                                      void *opaque, Error **errp)
+ {
+     BlockDriverState *bs = opaque;
+     BDRVQcow2State *s = bs->opaque;
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+         return -1;
+     }
+-    return buflen;
++    return 0;
+ }
+-static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
+-                                          void *opaque, Error **errp)
++static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
++                                      void *opaque, Error **errp)
+ {
+     BlockDriverState *bs = opaque;
+     BDRVQcow2State *s = bs->opaque;
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
+         return -1;
+     }
+-    return ret;
++    return 0;
+ }
+-static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
+-                                           const uint8_t *buf, size_t buflen,
+-                                           void *opaque, Error **errp)
++static int qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
++                                       const uint8_t *buf, size_t buflen,
++                                       void *opaque, Error **errp)
+ {
+     BlockDriverState *bs = opaque;
+     BDRVQcow2State *s = bs->opaque;
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
+         error_setg_errno(errp, -ret, "Could not read encryption header");
+         return -1;
+     }
+-    return buflen;
++    return 0;
+ }
+ static QDict*
+diff --git a/crypto/block-luks.c b/crypto/block-luks.c
+index XXXXXXX..XXXXXXX 100644
+--- a/crypto/block-luks.c
++++ b/crypto/block-luks.c
+@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_load_header(QCryptoBlock *block,
+                                 void *opaque,
+                                 Error **errp)
+ {
+-    ssize_t rv;
++    int rv;
+     size_t i;
+     QCryptoBlockLUKS *luks = block->opaque;
+@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_store_key(QCryptoBlock *block,
+                   QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
+                   splitkey, splitkeylen,
+                   opaque,
+-                  errp) != splitkeylen) {
++                  errp) < 0) {
+         goto cleanup;
+     }
+@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_load_key(QCryptoBlock *block,
+     g_autofree uint8_t *splitkey = NULL;
+     size_t splitkeylen;
+     g_autofree uint8_t *possiblekey = NULL;
+-    ssize_t rv;
++    int rv;
+     g_autoptr(QCryptoCipher) cipher = NULL;
+     uint8_t keydigest[QCRYPTO_BLOCK_LUKS_DIGEST_LEN];
+     g_autoptr(QCryptoIVGen) ivgen = NULL;
+@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_erase_key(QCryptoBlock *block,
+                       garbagesplitkey,
+                       splitkeylen,
+                       opaque,
+-                      &local_err) != splitkeylen) {
++                      &local_err) < 0) {
+             error_propagate(errp, local_err);
+             return -1;
+         }
+diff --git a/crypto/block.c b/crypto/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/crypto/block.c
++++ b/crypto/block.c
+@@ -XXX,XX +XXX,XX @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
+ }
+-static ssize_t qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
++static int qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
+         size_t headerlen, void *opaque, Error **errp)
+ {
+     size_t *headerlenp = opaque;
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
+ }
+-static ssize_t qcrypto_block_headerlen_hdr_write_func(QCryptoBlock *block,
++static int qcrypto_block_headerlen_hdr_write_func(QCryptoBlock *block,
+         size_t offset, const uint8_t *buf, size_t buflen,
+         void *opaque, Error **errp)
+ {
+     /* Discard the bytes, we're not actually writing to an image */
+-    return buflen;
++    return 0;
+ }
+diff --git a/tests/unit/test-crypto-block.c b/tests/unit/test-crypto-block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-crypto-block.c
++++ b/tests/unit/test-crypto-block.c
+@@ -XXX,XX +XXX,XX @@ static struct QCryptoBlockTestData {
+ };
+-static ssize_t test_block_read_func(QCryptoBlock *block,
+-                                    size_t offset,
+-                                    uint8_t *buf,
+-                                    size_t buflen,
+-                                    void *opaque,
+-                                    Error **errp)
++static int test_block_read_func(QCryptoBlock *block,
++                                size_t offset,
++                                uint8_t *buf,
++                                size_t buflen,
++                                void *opaque,
++                                Error **errp)
+ {
+     Buffer *header = opaque;
+@@ -XXX,XX +XXX,XX @@ static ssize_t test_block_read_func(QCryptoBlock *block,
+     memcpy(buf, header->buffer + offset, buflen);
+-    return buflen;
++    return 0;
+ }
+-static ssize_t test_block_init_func(QCryptoBlock *block,
+-                                    size_t headerlen,
+-                                    void *opaque,
+-                                    Error **errp)
++static int test_block_init_func(QCryptoBlock *block,
++                                size_t headerlen,
++                                void *opaque,
++                                Error **errp)
+ {
+     Buffer *header = opaque;
+@@ -XXX,XX +XXX,XX @@ static ssize_t test_block_init_func(QCryptoBlock *block,
+     buffer_reserve(header, headerlen);
+-    return headerlen;
++    return 0;
+ }
+-static ssize_t test_block_write_func(QCryptoBlock *block,
+-                                     size_t offset,
+-                                     const uint8_t *buf,
+-                                     size_t buflen,
+-                                     void *opaque,
+-                                     Error **errp)
++static int test_block_write_func(QCryptoBlock *block,
++                                 size_t offset,
++                                 const uint8_t *buf,
++                                 size_t buflen,
++                                 void *opaque,
++                                 Error **errp)
+ {
+     Buffer *header = opaque;
+@@ -XXX,XX +XXX,XX @@ static ssize_t test_block_write_func(QCryptoBlock *block,
+     memcpy(header->buffer + offset, buf, buflen);
+     header->offset = offset + buflen;
+-    return buflen;
++    return 0;
+ }
+--
+.35.3

-New patch
+[PULL 05/35] block: Make bdrv_co_pwrite() take a const buffer
+From: Alberto Faria <afaria@redhat.com>
+It does not mutate the buffer.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20220609152744.3891847-6-afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/block/block_int-io.h | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+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 @@ static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
+ }
+ static inline int coroutine_fn bdrv_co_pwrite(BdrvChild *child,
+-    int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags)
++    int64_t offset, unsigned int bytes, const void *buf, BdrvRequestFlags flags)
+ {
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+     IO_CODE();
+--
+.35.3

-New patch
+[PULL 06/35] block: Make 'bytes' param of bdrv_co_{pread, pwrite, preadv, pwritev}() an int64_t
+From: Alberto Faria <afaria@redhat.com>
+For consistency with other I/O functions, and in preparation to
+implement bdrv_{pread,pwrite}() using generated_co_wrapper.
+unsigned int fits in int64_t, so all callers remain correct.
+bdrv_check_request32() is called further down the stack and causes -EIO
+to be returned if 'bytes' is negative or greater than
+BDRV_REQUEST_MAX_BYTES, which in turns never exceeds SIZE_MAX.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Message-Id: <20220609152744.3891847-7-afaria@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/coroutines.h           | 4 ++--
+ include/block/block_int-io.h | 4 ++--
+files changed, 4 insertions(+), 4 deletions(-)
+diff --git a/block/coroutines.h b/block/coroutines.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/coroutines.h
++++ b/block/coroutines.h
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_do_flush(BlockBackend *blk);
+  */
+ int generated_co_wrapper
+-bdrv_preadv(BdrvChild *child, int64_t offset, unsigned int bytes,
++bdrv_preadv(BdrvChild *child, int64_t offset, int64_t bytes,
+             QEMUIOVector *qiov, BdrvRequestFlags flags);
+ int generated_co_wrapper
+-bdrv_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes,
++bdrv_pwritev(BdrvChild *child, int64_t offset, int64_t bytes,
+              QEMUIOVector *qiov, BdrvRequestFlags flags);
+ int generated_co_wrapper
+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 @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
+     QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags);
+ static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
+-    int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags)
++    int64_t offset, int64_t bytes, void *buf, BdrvRequestFlags flags)
+ {
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+     IO_CODE();
+@@ -XXX,XX +XXX,XX @@ static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
+ }
+ static inline int coroutine_fn bdrv_co_pwrite(BdrvChild *child,
+-    int64_t offset, unsigned int bytes, const void *buf, BdrvRequestFlags flags)
++    int64_t offset, int64_t bytes, const void *buf, BdrvRequestFlags flags)
+ {
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+     IO_CODE();
+--
+.35.3

-[PULL 1/3] Introduce event-loop-base abstract class
+[PULL 07/35] block: Implement bdrv_{pread, pwrite, pwrite_zeroes}() using generated_co_wrapper
-From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
+From: Alberto Faria <afaria@redhat.com>
-Introduce the 'event-loop-base' abstract class, it'll hold the
+bdrv_{pread,pwrite}() now return -EIO instead of -EINVAL when 'bytes' is
-properties common to all event loops and provide the necessary hooks for
+negative, making them consistent with bdrv_{preadv,pwritev}() and
-their creation and maintenance. Then have iothread inherit from it.
+bdrv_co_{pread,pwrite,preadv,pwritev}().
-EventLoopBaseClass is defined as user creatable and provides a hook for
+bdrv_pwrite_zeroes() now also calls trace_bdrv_co_pwrite_zeroes() and
-its children to attach themselves to the user creatable class 'complete'
+clears the BDRV_REQ_MAY_UNMAP flag when appropriate, which it didn't
-function. It also provides an update_params() callback to propagate
+previously.
 property changes onto its children.
-The new 'event-loop-base' class will live in the root directory. It is
+Signed-off-by: Alberto Faria <afaria@redhat.com>
-built on its own using the 'link_whole' option (there are no direct
+Message-Id: <20220609152744.3891847-8-afaria@redhat.com>
-function dependencies between the class and its children, it all happens
+Reviewed-by: Eric Blake <eblake@redhat.com>
-trough 'constructor' magic). And also imposes new compilation
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
-dependencies:
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
  include/block/block-io.h | 15 +++++++++------
  block/io.c               | 41 ----------------------------------------
 files changed, 9 insertions(+), 47 deletions(-)
-    qom <- event-loop-base <- blockdev (iothread.c)
+diff --git a/include/block/block-io.h b/include/block/block-io.h
 And in subsequent patches:
     qom <- event-loop-base <- qemuutil (util/main-loop.c)
 All this forced some amount of reordering in meson.build:
  - Moved qom build definition before qemuutil. Doing it the other way
    around (i.e. moving qemuutil after qom) isn't possible as a lot of
    core libraries that live in between the two depend on it.
  - Process the 'hw' subdir earlier, as it introduces files into the
    'qom' source set.
 No functional changes intended.
 Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Message-id: 20220425075723.20019-2-nsaenzju@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  qapi/qom.json                    |  22 +++++--
  meson.build                      |  23 ++++---
  include/sysemu/event-loop-base.h |  36 +++++++++++
  include/sysemu/iothread.h        |   6 +-
  event-loop-base.c                | 104 +++++++++++++++++++++++++++++++
  iothread.c                       |  65 ++++++-------------
 files changed, 192 insertions(+), 64 deletions(-)
  create mode 100644 include/sysemu/event-loop-base.h
  create mode 100644 event-loop-base.c
 diff --git a/qapi/qom.json b/qapi/qom.json
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/qom.json
+--- a/include/block/block-io.h
-+++ b/qapi/qom.json
++++ b/include/block/block-io.h
 @@ -XXX,XX +XXX,XX @@
-             '*repeat': 'bool',
+  * to catch when they are accidentally called by the wrong API.
-             '*grab-toggle': 'GrabToggleKeys' } }
+  */
-+##
+-int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
-+# @EventLoopBaseProperties:
+-                       int64_t bytes, BdrvRequestFlags flags);
-+#
++int generated_co_wrapper bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
-+# Common properties for event loops
++                                            int64_t bytes,
-+#
++                                            BdrvRequestFlags flags);
-+# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
+ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
-+#                 0 means that the engine will use its default.
+-int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
-+#                 (default: 0)
+-               BdrvRequestFlags flags);
-+#
+-int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
-+# Since: 7.1
+-                const void *buf, BdrvRequestFlags flags);
-+##
++int generated_co_wrapper bdrv_pread(BdrvChild *child, int64_t offset,
-+{ 'struct': 'EventLoopBaseProperties',
++                                    int64_t bytes, void *buf,
-+  'data': { '*aio-max-batch': 'int' } }
++                                    BdrvRequestFlags flags);
-+
++int generated_co_wrapper bdrv_pwrite(BdrvChild *child, int64_t offset,
- ##
++                                     int64_t bytes, const void *buf,
- # @IothreadProperties:
++                                     BdrvRequestFlags flags);
- #
+ int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
-@@ -XXX,XX +XXX,XX @@
+                      const void *buf, BdrvRequestFlags flags);
- #               algorithm detects it is spending too long polling without
+ /*
- #               encountering events. 0 selects a default behaviour (default: 0)
+diff --git a/block/io.c b/block/io.c
  #
 -# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
 -#                 0 means that the engine will use its default
 -#                 (default:0, since 6.1)
 +# The @aio-max-batch option is available since 6.1.
  #
  # Since: 2.0
  ##
  { 'struct': 'IothreadProperties',
 +  'base': 'EventLoopBaseProperties',
    'data': { '*poll-max-ns': 'int',
              '*poll-grow': 'int',
 -            '*poll-shrink': 'int',
 -            '*aio-max-batch': 'int' } }
 +            '*poll-shrink': 'int' } }
  ##
  # @MemoryBackendProperties:
 diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
---- a/meson.build
+--- a/block/io.c
-+++ b/meson.build
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ subdir('qom')
+@@ -XXX,XX +XXX,XX @@ static int bdrv_check_request32(int64_t offset, int64_t bytes,
- subdir('authz')
+     return 0;
- subdir('crypto')
+ }
- subdir('ui')
-+subdir('hw')
+-int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
+-                       int64_t bytes, BdrvRequestFlags flags)
+-{
- if enable_modules
+-    IO_CODE();
-@@ -XXX,XX +XXX,XX @@ if enable_modules
+-    return bdrv_pwritev(child, offset, bytes, NULL,
-   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
+-                        BDRV_REQ_ZERO_WRITE | flags);
- endif
+-}
 +qom_ss = qom_ss.apply(config_host, strict: false)
 +libqom = static_library('qom', qom_ss.sources() + genh,
 +                        dependencies: [qom_ss.dependencies()],
 +                        name_suffix: 'fa')
 +qom = declare_dependency(link_whole: libqom)
 +
 +event_loop_base = files('event-loop-base.c')
 +event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
 +                                 build_by_default: true)
 +event_loop_base = declare_dependency(link_whole: event_loop_base,
 +                                     dependencies: [qom])
 +
  stub_ss = stub_ss.apply(config_all, strict: false)
  util_ss.add_all(trace_ss)
@@ -XXX,XX +XXX,XX @@ subdir('monitor')
  subdir('net')
  subdir('replay')
  subdir('semihosting')
 -subdir('hw')
  subdir('tcg')
  subdir('fpu')
  subdir('accel')
@@ -XXX,XX +XXX,XX @@ qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
                               capture: true,
                               command: [undefsym, nm, '@INPUT@'])
 -qom_ss = qom_ss.apply(config_host, strict: false)
 -libqom = static_library('qom', qom_ss.sources() + genh,
 -                        dependencies: [qom_ss.dependencies()],
 -                        name_suffix: 'fa')
 -
--qom = declare_dependency(link_whole: libqom)
+ /*
--
+  * Completely zero out a block device with the help of bdrv_pwrite_zeroes.
- authz_ss = authz_ss.apply(config_host, strict: false)
+  * The operation is sped up by checking the block status and only writing
- libauthz = static_library('authz', authz_ss.sources() + genh,
+@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
                            dependencies: [authz_ss.dependencies()],
@@ -XXX,XX +XXX,XX @@ libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
                               build_by_default: false)
  blockdev = declare_dependency(link_whole: [libblockdev],
 -                              dependencies: [block])
 +                              dependencies: [block, event_loop_base])
  qmp_ss = qmp_ss.apply(config_host, strict: false)
  libqmp = static_library('qmp', qmp_ss.sources() + genh,
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@
 +/*
 + * QEMU event-loop backend
 + *
 + * Copyright (C) 2022 Red Hat Inc
 + *
 + * Authors:
 + *  Nicolas Saenz Julienne <nsaenzju@redhat.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 QEMU_EVENT_LOOP_BASE_H
 +#define QEMU_EVENT_LOOP_BASE_H
 +
 +#include "qom/object.h"
 +#include "block/aio.h"
 +#include "qemu/typedefs.h"
 +
 +#define TYPE_EVENT_LOOP_BASE         "event-loop-base"
 +OBJECT_DECLARE_TYPE(EventLoopBase, EventLoopBaseClass,
 +                    EVENT_LOOP_BASE)
 +
 +struct EventLoopBaseClass {
 +    ObjectClass parent_class;
 +
 +    void (*init)(EventLoopBase *base, Error **errp);
 +    void (*update_params)(EventLoopBase *base, Error **errp);
 +};
 +
 +struct EventLoopBase {
 +    Object parent;
 +
 +    /* AioContext AIO engine parameters */
 +    int64_t aio_max_batch;
 +};
 +#endif
 diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/iothread.h
 +++ b/include/sysemu/iothread.h
@@ -XXX,XX +XXX,XX @@
  #include "block/aio.h"
  #include "qemu/thread.h"
  #include "qom/object.h"
 +#include "sysemu/event-loop-base.h"
  #define TYPE_IOTHREAD "iothread"
  struct IOThread {
 -    Object parent_obj;
 +    EventLoopBase parent_obj;
      QemuThread thread;
      AioContext *ctx;
@@ -XXX,XX +XXX,XX @@ struct IOThread {
      int64_t poll_max_ns;
      int64_t poll_grow;
      int64_t poll_shrink;
 -
 -    /* AioContext AIO engine parameters */
 -    int64_t aio_max_batch;
  };
  typedef struct IOThread IOThread;
 diff --git a/event-loop-base.c b/event-loop-base.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * QEMU event-loop base
 + *
 + * Copyright (C) 2022 Red Hat Inc
 + *
 + * Authors:
 + *  Stefan Hajnoczi <stefanha@redhat.com>
 + *  Nicolas Saenz Julienne <nsaenzju@redhat.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 "qom/object_interfaces.h"
 +#include "qapi/error.h"
 +#include "sysemu/event-loop-base.h"
 +
 +typedef struct {
 +    const char *name;
 +    ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
 +} EventLoopBaseParamInfo;
 +
 +static EventLoopBaseParamInfo aio_max_batch_info = {
 +    "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
 +};
 +
 +static void event_loop_base_get_param(Object *obj, Visitor *v,
 +        const char *name, void *opaque, Error **errp)
 +{
 +    EventLoopBase *event_loop_base = EVENT_LOOP_BASE(obj);
 +    EventLoopBaseParamInfo *info = opaque;
 +    int64_t *field = (void *)event_loop_base + info->offset;
 +
 +    visit_type_int64(v, name, field, errp);
 +}
 +
 +static void event_loop_base_set_param(Object *obj, Visitor *v,
 +        const char *name, void *opaque, Error **errp)
 +{
 +    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(obj);
 +    EventLoopBase *base = EVENT_LOOP_BASE(obj);
 +    EventLoopBaseParamInfo *info = opaque;
 +    int64_t *field = (void *)base + info->offset;
 +    int64_t value;
 +
 +    if (!visit_type_int64(v, name, &value, errp)) {
 +        return;
 +    }
 +
 +    if (value < 0) {
 +        error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
 +                   info->name, INT64_MAX);
 +        return;
 +    }
 +
 +    *field = value;
 +
 +    if (bc->update_params) {
 +        bc->update_params(base, errp);
 +    }
 +
 +    return;
 +}
 +
 +static void event_loop_base_complete(UserCreatable *uc, Error **errp)
 +{
 +    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
 +    EventLoopBase *base = EVENT_LOOP_BASE(uc);
 +
 +    if (bc->init) {
 +        bc->init(base, errp);
 +    }
 +}
 +
 +static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
 +{
 +    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
 +    ucc->complete = event_loop_base_complete;
 +
 +    object_class_property_add(klass, "aio-max-batch", "int",
 +                              event_loop_base_get_param,
 +                              event_loop_base_set_param,
 +                              NULL, &aio_max_batch_info);
 +}
 +
 +static const TypeInfo event_loop_base_info = {
 +    .name = TYPE_EVENT_LOOP_BASE,
 +    .parent = TYPE_OBJECT,
 +    .instance_size = sizeof(EventLoopBase),
 +    .class_size = sizeof(EventLoopBaseClass),
 +    .class_init = event_loop_base_class_init,
 +    .abstract = true,
 +    .interfaces = (InterfaceInfo[]) {
 +        { TYPE_USER_CREATABLE },
 +        { }
 +    }
 +};
 +
 +static void register_types(void)
 +{
 +    type_register_static(&event_loop_base_info);
 +}
 +type_init(register_types);
 diff --git a/iothread.c b/iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/iothread.c
 +++ b/iothread.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/module.h"
  #include "block/aio.h"
  #include "block/block.h"
 +#include "sysemu/event-loop-base.h"
  #include "sysemu/iothread.h"
  #include "qapi/error.h"
  #include "qapi/qapi-commands-misc.h"
@@ -XXX,XX +XXX,XX @@ static void iothread_init_gcontext(IOThread *iothread)
      iothread->main_loop = g_main_loop_new(iothread->worker_context, TRUE);
  }
 -static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
 +static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
  {
 +    IOThread *iothread = IOTHREAD(base);
      ERRP_GUARD();
 +    if (!iothread->ctx) {
 +        return;
 +    }
 +
      aio_context_set_poll_params(iothread->ctx,
                                  iothread->poll_max_ns,
                                  iothread->poll_grow,
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
      }
      aio_context_set_aio_params(iothread->ctx,
 -                               iothread->aio_max_batch,
 +                               iothread->parent_obj.aio_max_batch,
                                 errp);
  }
 -static void iothread_complete(UserCreatable *obj, Error **errp)
 +
 +static void iothread_init(EventLoopBase *base, Error **errp)
  {
      Error *local_error = NULL;
 -    IOThread *iothread = IOTHREAD(obj);
 +    IOThread *iothread = IOTHREAD(base);
      char *thread_name;
      iothread->stopping = false;
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
       */
      iothread_init_gcontext(iothread);
 -    iothread_set_aio_context_params(iothread, &local_error);
 +    iothread_set_aio_context_params(base, &local_error);
      if (local_error) {
          error_propagate(errp, local_error);
          aio_context_unref(iothread->ctx);
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
       * to inherit.
       */
      thread_name = g_strdup_printf("IO %s",
 -                        object_get_canonical_path_component(OBJECT(obj)));
 +                        object_get_canonical_path_component(OBJECT(base)));
      qemu_thread_create(&iothread->thread, thread_name, iothread_run,
                         iothread, QEMU_THREAD_JOINABLE);
      g_free(thread_name);
@@ -XXX,XX +XXX,XX @@ static IOThreadParamInfo poll_grow_info = {
  static IOThreadParamInfo poll_shrink_info = {
      "poll-shrink", offsetof(IOThread, poll_shrink),
  };
 -static IOThreadParamInfo aio_max_batch_info = {
 -    "aio-max-batch", offsetof(IOThread, aio_max_batch),
 -};
  static void iothread_get_param(Object *obj, Visitor *v,
          const char *name, IOThreadParamInfo *info, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
      }
  }
--static void iothread_get_aio_param(Object *obj, Visitor *v,
+-/* See bdrv_pwrite() for the return codes */
--        const char *name, void *opaque, Error **errp)
+-int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
 -               BdrvRequestFlags flags)
 -{
--    IOThreadParamInfo *info = opaque;
+-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
 -    IO_CODE();
 -
--    iothread_get_param(obj, v, name, info, errp);
+-    if (bytes < 0) {
 -        return -EINVAL;
 -    }
 -
 -    return bdrv_preadv(child, offset, bytes, &qiov, flags);
 -}
 -
--static void iothread_set_aio_param(Object *obj, Visitor *v,
+-/* Return no. of bytes on success or < 0 on error. Important errors are:
--        const char *name, void *opaque, Error **errp)
+-  -EIO         generic I/O error (may happen for all errors)
 -  -ENOMEDIUM   No media inserted.
 -  -EINVAL      Invalid offset or number of bytes
 -  -EACCES      Trying to write a read-only device
 -*/
 -int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
 -                const void *buf, BdrvRequestFlags flags)
 -{
--    IOThread *iothread = IOTHREAD(obj);
+-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
--    IOThreadParamInfo *info = opaque;
+-    IO_CODE();
 -
--    if (!iothread_set_param(obj, v, name, info, errp)) {
+-    if (bytes < 0) {
--        return;
+-        return -EINVAL;
 -    }
 -
--    if (iothread->ctx) {
+-    return bdrv_pwritev(child, offset, bytes, &qiov, flags);
 -        aio_context_set_aio_params(iothread->ctx,
 -                                   iothread->aio_max_batch,
 -                                   errp);
 -    }
 -}
 -
- static void iothread_class_init(ObjectClass *klass, void *class_data)
+ /*
- {
+  * Writes to the file and ensures that no writes are reordered across this
--    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
+  * request (acts as a barrier)
 -    ucc->complete = iothread_complete;
 +    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(klass);
 +
 +    bc->init = iothread_init;
 +    bc->update_params = iothread_set_aio_context_params;
      object_class_property_add(klass, "poll-max-ns", "int",
                                iothread_get_poll_param,
@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *class_data)
                                iothread_get_poll_param,
                                iothread_set_poll_param,
                                NULL, &poll_shrink_info);
 -    object_class_property_add(klass, "aio-max-batch", "int",
 -                              iothread_get_aio_param,
 -                              iothread_set_aio_param,
 -                              NULL, &aio_max_batch_info);
  }
  static const TypeInfo iothread_info = {
      .name = TYPE_IOTHREAD,
 -    .parent = TYPE_OBJECT,
 +    .parent = TYPE_EVENT_LOOP_BASE,
      .class_init = iothread_class_init,
      .instance_size = sizeof(IOThread),
      .instance_init = iothread_instance_init,
      .instance_finalize = iothread_instance_finalize,
 -    .interfaces = (InterfaceInfo[]) {
 -        {TYPE_USER_CREATABLE},
 -        {}
 -    },
  };
  static void iothread_register_types(void)
@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)
      info->poll_max_ns = iothread->poll_max_ns;
      info->poll_grow = iothread->poll_grow;
      info->poll_shrink = iothread->poll_shrink;
 -    info->aio_max_batch = iothread->aio_max_batch;
 +    info->aio_max_batch = iothread->parent_obj.aio_max_batch;
      QAPI_LIST_APPEND(*tail, info);
      return 0;
 --
-.35.1
+.35.3

-New patch
+[PULL 08/35] block: Add bdrv_co_pwrite_sync()
+From: Alberto Faria <afaria@redhat.com>
+Also convert bdrv_pwrite_sync() to being implemented using
+generated_co_wrapper.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20220609152744.3891847-9-afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/block/block-io.h | 8 ++++++--
+ block/io.c               | 9 +++++----
+files changed, 11 insertions(+), 6 deletions(-)
+diff --git a/include/block/block-io.h b/include/block/block-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/block-io.h
++++ b/include/block/block-io.h
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper bdrv_pread(BdrvChild *child, int64_t offset,
+ int generated_co_wrapper bdrv_pwrite(BdrvChild *child, int64_t offset,
+                                      int64_t bytes, const void *buf,
+                                      BdrvRequestFlags flags);
+-int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
+-                     const void *buf, BdrvRequestFlags flags);
++int generated_co_wrapper bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
++                                          int64_t bytes, const void *buf,
++                                          BdrvRequestFlags flags);
++int coroutine_fn bdrv_co_pwrite_sync(BdrvChild *child, int64_t offset,
++                                     int64_t bytes, const void *buf,
++                                     BdrvRequestFlags flags);
+ /*
+  * Efficiently zero a region of the disk image.  Note that this is a regular
+  * I/O request like read or write and should have a reasonable size.  This
+diff --git a/block/io.c b/block/io.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/io.c
++++ b/block/io.c
+@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
+  *
+  * Returns 0 on success, -errno in error cases.
+  */
+-int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
+-                     const void *buf, BdrvRequestFlags flags)
++int coroutine_fn bdrv_co_pwrite_sync(BdrvChild *child, int64_t offset,
++                                     int64_t bytes, const void *buf,
++                                     BdrvRequestFlags flags)
+ {
+     int ret;
+     IO_CODE();
+-    ret = bdrv_pwrite(child, offset, bytes, buf, flags);
++    ret = bdrv_co_pwrite(child, offset, bytes, buf, flags);
+     if (ret < 0) {
+         return ret;
+     }
+-    ret = bdrv_flush(child->bs);
++    ret = bdrv_co_flush(child->bs);
+     if (ret < 0) {
+         return ret;
+     }
+--
+.35.3

-New patch
+[PULL 09/35] block: Use bdrv_co_pwrite_sync() when caller is coroutine_fn
+From: Alberto Faria <afaria@redhat.com>
+Convert uses of bdrv_pwrite_sync() into bdrv_co_pwrite_sync() when the
+callers are already coroutine_fn.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20220609152744.3891847-10-afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/parallels.c      | 2 +-
+ block/qcow2-snapshot.c | 6 +++---
+ block/qcow2.c          | 4 ++--
+files changed, 6 insertions(+), 6 deletions(-)
+diff --git a/block/parallels.c b/block/parallels.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/parallels.c
++++ b/block/parallels.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
+     ret = 0;
+     if (flush_bat) {
+-        ret = bdrv_pwrite_sync(bs->file, 0, s->header_size, s->header, 0);
++        ret = bdrv_co_pwrite_sync(bs->file, 0, s->header_size, s->header, 0);
+         if (ret < 0) {
+             res->check_errors++;
+             goto out;
+diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-snapshot.c
++++ b/block/qcow2-snapshot.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
+         assert(fix & BDRV_FIX_ERRORS);
+         snapshot_table_pointer.nb_snapshots = cpu_to_be32(s->nb_snapshots);
+-        ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
+-                               sizeof(snapshot_table_pointer.nb_snapshots),
+-                               &snapshot_table_pointer.nb_snapshots, 0);
++        ret = bdrv_co_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
++                                  sizeof(snapshot_table_pointer.nb_snapshots),
++                                  &snapshot_table_pointer.nb_snapshots, 0);
+         if (ret < 0) {
+             result->check_errors++;
+             fprintf(stderr, "ERROR failed to update the snapshot count in the "
+diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.c
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+     /* write updated header.size */
+     offset = cpu_to_be64(offset);
+-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
+-                           sizeof(offset), &offset, 0);
++    ret = bdrv_co_pwrite_sync(bs->file, offsetof(QCowHeader, size),
++                              sizeof(offset), &offset, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to update the image size");
+         goto fail;
+--
+.35.3

-New patch
+[PULL 10/35] block/qcow2: Use bdrv_pwrite_sync() in qcow2_mark_dirty()
+From: Alberto Faria <afaria@redhat.com>
+Use bdrv_pwrite_sync() instead of calling bdrv_pwrite() and bdrv_flush()
+separately.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20220609152744.3891847-11-afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/qcow2.c | 9 +++------
+file changed, 3 insertions(+), 6 deletions(-)
+diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.c
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ int qcow2_mark_dirty(BlockDriverState *bs)
+     }
+     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
+-    ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
+-                      sizeof(val), &val, 0);
+-    if (ret < 0) {
+-        return ret;
+-    }
+-    ret = bdrv_flush(bs->file->bs);
++    ret = bdrv_pwrite_sync(bs->file,
++                           offsetof(QCowHeader, incompatible_features),
++                           sizeof(val), &val, 0);
+     if (ret < 0) {
+         return ret;
+     }
+--
+.35.3

-New patch
+[PULL 11/35] tests/qemu-iotests: hotfix for 307, 223 output
+From: John Snow <jsnow@redhat.com>
+Fixes: 58a6fdcc
+Signed-off-by: John Snow <jsnow@redhat.com>
+Tested-by: Daniel P. Berrangé <berrange@redhat.com>
+Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+Message-Id: <20220616142659.3184115-2-jsnow@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ tests/qemu-iotests/223.out | 4 ++--
+ tests/qemu-iotests/307.out | 4 ++--
+files changed, 4 insertions(+), 4 deletions(-)
+diff --git a/tests/qemu-iotests/223.out b/tests/qemu-iotests/223.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/223.out
++++ b/tests/qemu-iotests/223.out
+@@ -XXX,XX +XXX,XX @@ exports available: 3
+  export: 'n2'
+   description: some text
+   size:  4194304
+-  flags: 0xced ( flush fua trim zeroes df cache fast-zero )
++  flags: 0xded ( flush fua trim zeroes df multi cache fast-zero )
+   min block: 1
+   opt block: 4096
+   max block: 33554432
+@@ -XXX,XX +XXX,XX @@ exports available: 3
+  export: 'n2'
+   description: some text
+   size:  4194304
+-  flags: 0xced ( flush fua trim zeroes df cache fast-zero )
++  flags: 0xded ( flush fua trim zeroes df multi cache fast-zero )
+   min block: 1
+   opt block: 4096
+   max block: 33554432
+diff --git a/tests/qemu-iotests/307.out b/tests/qemu-iotests/307.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/307.out
++++ b/tests/qemu-iotests/307.out
+@@ -XXX,XX +XXX,XX @@ exports available: 2
+  export: 'export1'
+   description: This is the writable second export
+   size:  67108864
+-  flags: 0xced ( flush fua trim zeroes df cache fast-zero )
++  flags: 0xded ( flush fua trim zeroes df multi cache fast-zero )
+   min block: XXX
+   opt block: XXX
+   max block: XXX
+@@ -XXX,XX +XXX,XX @@ exports available: 1
+  export: 'export1'
+   description: This is the writable second export
+   size:  67108864
+-  flags: 0xced ( flush fua trim zeroes df cache fast-zero )
++  flags: 0xded ( flush fua trim zeroes df multi cache fast-zero )
+   min block: XXX
+   opt block: XXX
+   max block: XXX
+--
+.35.3

-New patch
+[PULL 12/35] tests/qemu-iotests: skip 108 when FUSE is not loaded
+From: John Snow <jsnow@redhat.com>
+In certain container environments we may not have FUSE at all, so skip
+the test in this circumstance too.
+Signed-off-by: John Snow <jsnow@redhat.com>
+Message-Id: <20220616142659.3184115-3-jsnow@redhat.com>
+Reviewed-by: Thomas Huth <thuth@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ tests/qemu-iotests/108 | 5 +++++
+file changed, 5 insertions(+)
+diff --git a/tests/qemu-iotests/108 b/tests/qemu-iotests/108
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/108
++++ b/tests/qemu-iotests/108
+@@ -XXX,XX +XXX,XX @@ if sudo -n losetup &>/dev/null; then
+ else
+     loopdev=false
++    # Check for usable FUSE in the host environment:
++    if test ! -c "/dev/fuse"; then
++        _notrun 'No passwordless sudo nor usable /dev/fuse'
++    fi
++
+     # QSD --export fuse will either yield "Parameter 'id' is missing"
+     # or "Invalid parameter 'fuse'", depending on whether there is
+     # FUSE support or not.
+--
+.35.3

-New patch
+[PULL 13/35] block: Make blk_{pread,pwrite}() return 0 on success
+From: Alberto Faria <afaria@redhat.com>
+They currently return the value of their 'bytes' parameter on success.
+Make them return 0 instead, for consistency with other I/O functions and
+in preparation to implement them using generated_co_wrapper. This also
+makes it clear that short reads/writes are not possible.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Message-Id: <20220705161527.1054072-2-afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block.c                          |  8 +++++---
+ block/block-backend.c            |  7 ++-----
+ block/qcow.c                     |  6 +++---
+ hw/block/m25p80.c                |  2 +-
+ hw/misc/mac_via.c                |  4 ++--
+ hw/misc/sifive_u_otp.c           |  2 +-
+ hw/nvram/eeprom_at24c.c          |  8 ++++----
+ hw/nvram/spapr_nvram.c           | 14 +++++++-------
+ hw/ppc/pnv_pnor.c                |  2 +-
+ qemu-img.c                       | 25 +++++++++----------------
+ qemu-io-cmds.c                   | 18 ++++++++++++------
+ tests/unit/test-block-iothread.c |  4 ++--
+files changed, 49 insertions(+), 51 deletions(-)
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ static int find_image_format(BlockBackend *file, const char *filename,
+         return ret;
+     }
+-    drv = bdrv_probe_all(buf, ret, filename);
++    drv = bdrv_probe_all(buf, sizeof(buf), filename);
+     if (!drv) {
+         error_setg(errp, "Could not determine image format: No compatible "
+                    "driver found");
+-        ret = -ENOENT;
++        *pdrv = NULL;
++        return -ENOENT;
+     }
++
+     *pdrv = drv;
+-    return ret;
++    return 0;
+ }
+ /**
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes)
+     ret = blk_do_preadv(blk, offset, bytes, &qiov, 0);
+     blk_dec_in_flight(blk);
+-    return ret < 0 ? ret : bytes;
++    return ret;
+ }
+ int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes,
+                BdrvRequestFlags flags)
+ {
+-    int ret;
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+     IO_OR_GS_CODE();
+-    ret = blk_pwritev_part(blk, offset, bytes, &qiov, 0, flags);
+-
+-    return ret < 0 ? ret : bytes;
++    return blk_pwritev_part(blk, offset, bytes, &qiov, 0, flags);
+ }
+ int64_t blk_getlength(BlockBackend *blk)
+diff --git a/block/qcow.c b/block/qcow.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow.c
++++ b/block/qcow.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
+     /* write all the data */
+     ret = blk_pwrite(qcow_blk, 0, &header, sizeof(header), 0);
+-    if (ret != sizeof(header)) {
++    if (ret < 0) {
+         goto exit;
+     }
+     if (qcow_opts->has_backing_file) {
+         ret = blk_pwrite(qcow_blk, sizeof(header),
+                          qcow_opts->backing_file, backing_filename_len, 0);
+-        if (ret != backing_filename_len) {
++        if (ret < 0) {
+             goto exit;
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
+          i++) {
+         ret = blk_pwrite(qcow_blk, header_size + BDRV_SECTOR_SIZE * i,
+                          tmp, BDRV_SECTOR_SIZE, 0);
+-        if (ret != BDRV_SECTOR_SIZE) {
++        if (ret < 0) {
+             g_free(tmp);
+             goto exit;
+         }
+diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/m25p80.c
++++ b/hw/block/m25p80.c
+@@ -XXX,XX +XXX,XX @@ static void m25p80_realize(SSIPeripheral *ss, Error **errp)
+         trace_m25p80_binding(s);
+         s->storage = blk_blockalign(s->blk, s->size);
+-        if (blk_pread(s->blk, 0, s->storage, s->size) != s->size) {
++        if (blk_pread(s->blk, 0, s->storage, s->size) < 0) {
+             error_setg(errp, "failed to read the initial flash content");
+             return;
+         }
+diff --git a/hw/misc/mac_via.c b/hw/misc/mac_via.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/misc/mac_via.c
++++ b/hw/misc/mac_via.c
+@@ -XXX,XX +XXX,XX @@ static void mos6522_q800_via1_realize(DeviceState *dev, Error **errp)
+             return;
+         }
+-        len = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM));
+-        if (len != sizeof(v1s->PRAM)) {
++        ret = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM));
++        if (ret < 0) {
+             error_setg(errp, "can't read PRAM contents");
+             return;
+         }
+diff --git a/hw/misc/sifive_u_otp.c b/hw/misc/sifive_u_otp.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/misc/sifive_u_otp.c
++++ b/hw/misc/sifive_u_otp.c
+@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)
+                 return;
+             }
+-            if (blk_pread(s->blk, 0, s->fuse, filesize) != filesize) {
++            if (blk_pread(s->blk, 0, s->fuse, filesize) < 0) {
+                 error_setg(errp, "failed to read the initial flash content");
+                 return;
+             }
+diff --git a/hw/nvram/eeprom_at24c.c b/hw/nvram/eeprom_at24c.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/nvram/eeprom_at24c.c
++++ b/hw/nvram/eeprom_at24c.c
+@@ -XXX,XX +XXX,XX @@ int at24c_eeprom_event(I2CSlave *s, enum i2c_event event)
+     case I2C_START_RECV:
+         DPRINTK("clear\n");
+         if (ee->blk && ee->changed) {
+-            int len = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
+-            if (len != ee->rsize) {
++            int ret = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
++            if (ret < 0) {
+                 ERR(TYPE_AT24C_EE
+                         " : failed to write backing file\n");
+             }
+@@ -XXX,XX +XXX,XX @@ void at24c_eeprom_reset(DeviceState *state)
+     memset(ee->mem, 0, ee->rsize);
+     if (ee->blk) {
+-        int len = blk_pread(ee->blk, 0, ee->mem, ee->rsize);
++        int ret = blk_pread(ee->blk, 0, ee->mem, ee->rsize);
+-        if (len != ee->rsize) {
++        if (ret < 0) {
+             ERR(TYPE_AT24C_EE
+                     " : Failed initial sync with backing file\n");
+         }
+diff --git a/hw/nvram/spapr_nvram.c b/hw/nvram/spapr_nvram.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/nvram/spapr_nvram.c
++++ b/hw/nvram/spapr_nvram.c
+@@ -XXX,XX +XXX,XX @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
+ {
+     SpaprNvram *nvram = spapr->nvram;
+     hwaddr offset, buffer, len;
+-    int alen;
++    int ret;
+     void *membuf;
+     if ((nargs != 3) || (nret != 2)) {
+@@ -XXX,XX +XXX,XX @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
+     membuf = cpu_physical_memory_map(buffer, &len, false);
+-    alen = len;
++    ret = 0;
+     if (nvram->blk) {
+-        alen = blk_pwrite(nvram->blk, offset, membuf, len, 0);
++        ret = blk_pwrite(nvram->blk, offset, membuf, len, 0);
+     }
+     assert(nvram->buf);
+@@ -XXX,XX +XXX,XX @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
+     cpu_physical_memory_unmap(membuf, len, 0, len);
+-    rtas_st(rets, 0, (alen < len) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
+-    rtas_st(rets, 1, (alen < 0) ? 0 : alen);
++    rtas_st(rets, 0, (ret < 0) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
++    rtas_st(rets, 1, (ret < 0) ? 0 : len);
+ }
+ static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
+     }
+     if (nvram->blk) {
+-        int alen = blk_pread(nvram->blk, 0, nvram->buf, nvram->size);
++        ret = blk_pread(nvram->blk, 0, nvram->buf, nvram->size);
+-        if (alen != nvram->size) {
++        if (ret < 0) {
+             error_setg(errp, "can't read spapr-nvram contents");
+             return;
+         }
+diff --git a/hw/ppc/pnv_pnor.c b/hw/ppc/pnv_pnor.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/ppc/pnv_pnor.c
++++ b/hw/ppc/pnv_pnor.c
+@@ -XXX,XX +XXX,XX @@ static void pnv_pnor_realize(DeviceState *dev, Error **errp)
+         s->storage = blk_blockalign(s->blk, s->size);
+-        if (blk_pread(s->blk, 0, s->storage, s->size) != s->size) {
++        if (blk_pread(s->blk, 0, s->storage, s->size) < 0) {
+             error_setg(errp, "failed to read the initial flash content");
+             return;
+         }
+diff --git a/qemu-img.c b/qemu-img.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-img.c
++++ b/qemu-img.c
+@@ -XXX,XX +XXX,XX @@ static int img_dd(int argc, char **argv)
+     in.buf = g_new(uint8_t, in.bsz);
+     for (out_pos = 0; in_pos < size; block_count++) {
+-        int in_ret, out_ret;
++        int bytes = (in_pos + in.bsz > size) ? size - in_pos : in.bsz;
+-        if (in_pos + in.bsz > size) {
+-            in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos);
+-        } else {
+-            in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz);
+-        }
+-        if (in_ret < 0) {
++        ret = blk_pread(blk1, in_pos, in.buf, bytes);
++        if (ret < 0) {
+             error_report("error while reading from input image file: %s",
+-                         strerror(-in_ret));
+-            ret = -1;
++                         strerror(-ret));
+             goto out;
+         }
+-        in_pos += in_ret;
++        in_pos += bytes;
+-        out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0);
+-
+-        if (out_ret < 0) {
++        ret = blk_pwrite(blk2, out_pos, in.buf, bytes, 0);
++        if (ret < 0) {
+             error_report("error while writing to output image file: %s",
+-                         strerror(-out_ret));
+-            ret = -1;
++                         strerror(-ret));
+             goto out;
+         }
+-        out_pos += out_ret;
++        out_pos += bytes;
+     }
+ out:
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-io-cmds.c
++++ b/qemu-io-cmds.c
+@@ -XXX,XX +XXX,XX @@ fail:
+ static int do_pread(BlockBackend *blk, char *buf, int64_t offset,
+                     int64_t bytes, int64_t *total)
+ {
++    int ret;
++
+     if (bytes > INT_MAX) {
+         return -ERANGE;
+     }
+-    *total = blk_pread(blk, offset, (uint8_t *)buf, bytes);
+-    if (*total < 0) {
+-        return *total;
++    ret = blk_pread(blk, offset, (uint8_t *)buf, bytes);
++    if (ret < 0) {
++        return ret;
+     }
++    *total = bytes;
+     return 1;
+ }
+ static int do_pwrite(BlockBackend *blk, char *buf, int64_t offset,
+                      int64_t bytes, int flags, int64_t *total)
+ {
++    int ret;
++
+     if (bytes > INT_MAX) {
+         return -ERANGE;
+     }
+-    *total = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags);
+-    if (*total < 0) {
+-        return *total;
++    ret = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags);
++    if (ret < 0) {
++        return ret;
+     }
++    *total = bytes;
+     return 1;
+ }
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pread(BlockBackend *blk)
+     /* Success */
+     ret = blk_pread(blk, 0, buf, sizeof(buf));
+-    g_assert_cmpint(ret, ==, 512);
++    g_assert_cmpint(ret, ==, 0);
+     /* Early error: Negative offset */
+     ret = blk_pread(blk, -2, buf, sizeof(buf));
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwrite(BlockBackend *blk)
+     /* Success */
+     ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
+-    g_assert_cmpint(ret, ==, 512);
++    g_assert_cmpint(ret, ==, 0);
+     /* Early error: Negative offset */
+     ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);
+--
+.35.3

-New patch
+[PULL 14/35] block: Add a 'flags' param to blk_pread()
+From: Alberto Faria <afaria@redhat.com>
 For consistency with other I/O functions, and in preparation to
 implement it using generated_co_wrapper.
 Callers were updated using this Coccinelle script:
@@ expression blk, offset, buf, bytes; @@
     - blk_pread(blk, offset, buf, bytes)
     + blk_pread(blk, offset, buf, bytes, 0)
 It had no effect on hw/block/nand.c, presumably due to the #if, so that
 file was updated manually.
 Overly-long lines were then fixed by hand.
 Signed-off-by: Alberto Faria <afaria@redhat.com>
 Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Greg Kurz <groug@kaod.org>
 Reviewed-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20220705161527.1054072-3-afaria@redhat.com>
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
  include/sysemu/block-backend-io.h |  3 ++-
  block.c                           |  2 +-
  block/block-backend.c             |  5 +++--
  block/commit.c                    |  2 +-
  block/export/fuse.c               |  2 +-
  hw/arm/allwinner-h3.c             |  2 +-
  hw/arm/aspeed.c                   |  2 +-
  hw/block/block.c                  |  2 +-
  hw/block/fdc.c                    |  6 +++---
  hw/block/hd-geometry.c            |  2 +-
  hw/block/m25p80.c                 |  2 +-
  hw/block/nand.c                   | 12 ++++++------
  hw/block/onenand.c                | 12 ++++++------
  hw/ide/atapi.c                    |  4 ++--
  hw/misc/mac_via.c                 |  2 +-
  hw/misc/sifive_u_otp.c            |  4 ++--
  hw/nvram/eeprom_at24c.c           |  2 +-
  hw/nvram/spapr_nvram.c            |  2 +-
  hw/nvram/xlnx-bbram.c             |  2 +-
  hw/nvram/xlnx-efuse.c             |  2 +-
  hw/ppc/pnv_pnor.c                 |  2 +-
  hw/sd/sd.c                        |  2 +-
  migration/block.c                 |  4 ++--
  nbd/server.c                      |  4 ++--
  qemu-img.c                        | 12 ++++++------
  qemu-io-cmds.c                    |  2 +-
  tests/unit/test-block-iothread.c  |  4 ++--
 files changed, 52 insertions(+), 50 deletions(-)
 diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/block-backend-io.h
 +++ b/include/sysemu/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
   * the "I/O or GS" API.
   */
 -int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes);
 +int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes,
 +              BdrvRequestFlags flags);
  int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes,
                 BdrvRequestFlags flags);
  int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int find_image_format(BlockBackend *file, const char *filename,
          return ret;
      }
 -    ret = blk_pread(file, 0, buf, sizeof(buf));
 +    ret = blk_pread(file, 0, buf, sizeof(buf), 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "Could not read image for determining its "
                           "format");
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
                          flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
  }
 -int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes)
 +int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes,
 +              BdrvRequestFlags flags)
  {
      int ret;
      QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
      IO_OR_GS_CODE();
      blk_inc_in_flight(blk);
 -    ret = blk_do_preadv(blk, offset, bytes, &qiov, 0);
 +    ret = blk_do_preadv(blk, offset, bytes, &qiov, flags);
      blk_dec_in_flight(blk);
      return ret;
 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 @@ int bdrv_commit(BlockDriverState *bs)
              goto ro_cleanup;
          }
          if (ret) {
 -            ret = blk_pread(src, offset, buf, n);
 +            ret = blk_pread(src, offset, buf, n, 0);
              if (ret < 0) {
                  goto ro_cleanup;
              }
 diff --git a/block/export/fuse.c b/block/export/fuse.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/export/fuse.c
 +++ b/block/export/fuse.c
@@ -XXX,XX +XXX,XX @@ static void fuse_read(fuse_req_t req, fuse_ino_t inode,
          return;
      }
 -    ret = blk_pread(exp->common.blk, offset, buf, size);
 +    ret = blk_pread(exp->common.blk, offset, buf, size, 0);
      if (ret >= 0) {
          fuse_reply_buf(req, buf, size);
      } else {
 diff --git a/hw/arm/allwinner-h3.c b/hw/arm/allwinner-h3.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/arm/allwinner-h3.c
 +++ b/hw/arm/allwinner-h3.c
@@ -XXX,XX +XXX,XX @@ void allwinner_h3_bootrom_setup(AwH3State *s, BlockBackend *blk)
      const int64_t rom_size = 32 * KiB;
      g_autofree uint8_t *buffer = g_new0(uint8_t, rom_size);
 -    if (blk_pread(blk, 8 * KiB, buffer, rom_size) < 0) {
 +    if (blk_pread(blk, 8 * KiB, buffer, rom_size, 0) < 0) {
          error_setg(&error_fatal, "%s: failed to read BlockBackend data",
                     __func__);
          return;
 diff --git a/hw/arm/aspeed.c b/hw/arm/aspeed.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/arm/aspeed.c
 +++ b/hw/arm/aspeed.c
@@ -XXX,XX +XXX,XX @@ static void write_boot_rom(DriveInfo *dinfo, hwaddr addr, size_t rom_size,
      }
      storage = g_malloc0(rom_size);
 -    if (blk_pread(blk, 0, storage, rom_size) < 0) {
 +    if (blk_pread(blk, 0, storage, rom_size, 0) < 0) {
          error_setg(errp, "failed to read the initial flash content");
          return;
      }
 diff --git a/hw/block/block.c b/hw/block/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/block.c
 +++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blk_check_size_and_read_all(BlockBackend *blk, void *buf, hwaddr size,
       * block device and read only on demand.
       */
      assert(size <= BDRV_REQUEST_MAX_BYTES);
 -    ret = blk_pread(blk, 0, buf, size);
 +    ret = blk_pread(blk, 0, buf, size, 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "can't read block backend");
          return false;
 diff --git a/hw/block/fdc.c b/hw/block/fdc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/fdc.c
 +++ b/hw/block/fdc.c
@@ -XXX,XX +XXX,XX @@ int fdctrl_transfer_handler(void *opaque, int nchan, int dma_pos, int dma_len)
          if (fdctrl->data_dir != FD_DIR_WRITE ||
              len < FD_SECTOR_LEN || rel_pos != 0) {
              /* READ & SCAN commands and realign to a sector for WRITE */
 -            if (blk_pread(cur_drv->blk, fd_offset(cur_drv),
 -                          fdctrl->fifo, BDRV_SECTOR_SIZE) < 0) {
 +            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
 +                          BDRV_SECTOR_SIZE, 0) < 0) {
                  FLOPPY_DPRINTF("Floppy: error getting sector %d\n",
                                 fd_sector(cur_drv));
                  /* Sure, image size is too small... */
@@ -XXX,XX +XXX,XX @@ static uint32_t fdctrl_read_data(FDCtrl *fdctrl)
                      return 0;
                  }
              if (blk_pread(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
 -                          BDRV_SECTOR_SIZE)
 +                          BDRV_SECTOR_SIZE, 0)
                  < 0) {
                  FLOPPY_DPRINTF("error getting sector %d\n",
                                 fd_sector(cur_drv));
 diff --git a/hw/block/hd-geometry.c b/hw/block/hd-geometry.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/hd-geometry.c
 +++ b/hw/block/hd-geometry.c
@@ -XXX,XX +XXX,XX @@ static int guess_disk_lchs(BlockBackend *blk,
      blk_get_geometry(blk, &nb_sectors);
 -    if (blk_pread(blk, 0, buf, BDRV_SECTOR_SIZE) < 0) {
 +    if (blk_pread(blk, 0, buf, BDRV_SECTOR_SIZE, 0) < 0) {
          return -1;
      }
      /* test msdos magic */
 diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/m25p80.c
 +++ b/hw/block/m25p80.c
@@ -XXX,XX +XXX,XX @@ static void m25p80_realize(SSIPeripheral *ss, Error **errp)
          trace_m25p80_binding(s);
          s->storage = blk_blockalign(s->blk, s->size);
 -        if (blk_pread(s->blk, 0, s->storage, s->size) < 0) {
 +        if (blk_pread(s->blk, 0, s->storage, s->size, 0) < 0) {
              error_setg(errp, "failed to read the initial flash content");
              return;
          }
 diff --git a/hw/block/nand.c b/hw/block/nand.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/nand.c
 +++ b/hw/block/nand.c
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_write_, NAND_PAGE_SIZE)(NANDFlashState *s)
          off = (s->addr & PAGE_MASK) + s->offset;
          soff = SECTOR_OFFSET(s->addr);
          if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
 -                      PAGE_SECTORS << BDRV_SECTOR_BITS) < 0) {
 +                      PAGE_SECTORS << BDRV_SECTOR_BITS, 0) < 0) {
              printf("%s: read error in sector %" PRIu64 "\n", __func__, sector);
              return;
          }
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_write_, NAND_PAGE_SIZE)(NANDFlashState *s)
          sector = off >> 9;
          soff = off & 0x1ff;
          if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
 -                      (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS) < 0) {
 +                      (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, 0) < 0) {
              printf("%s: read error in sector %" PRIu64 "\n", __func__, sector);
              return;
          }
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_erase_, NAND_PAGE_SIZE)(NANDFlashState *s)
          addr = PAGE_START(addr);
          page = addr >> 9;
          if (blk_pread(s->blk, page << BDRV_SECTOR_BITS, iobuf,
 -                      BDRV_SECTOR_SIZE) < 0) {
 +                      BDRV_SECTOR_SIZE, 0) < 0) {
              printf("%s: read error in sector %" PRIu64 "\n", __func__, page);
          }
          memset(iobuf + (addr & 0x1ff), 0xff, (~addr & 0x1ff) + 1);
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_erase_, NAND_PAGE_SIZE)(NANDFlashState *s)
          page = i >> 9;
          if (blk_pread(s->blk, page << BDRV_SECTOR_BITS, iobuf,
 -                      BDRV_SECTOR_SIZE) < 0) {
 +                      BDRV_SECTOR_SIZE, 0) < 0) {
              printf("%s: read error in sector %" PRIu64 "\n", __func__, page);
          }
          memset(iobuf, 0xff, ((addr - 1) & 0x1ff) + 1);
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_load_, NAND_PAGE_SIZE)(NANDFlashState *s,
      if (s->blk) {
          if (s->mem_oob) {
              if (blk_pread(s->blk, SECTOR(addr) << BDRV_SECTOR_BITS, s->io,
 -                          PAGE_SECTORS << BDRV_SECTOR_BITS) < 0) {
 +                          PAGE_SECTORS << BDRV_SECTOR_BITS, 0) < 0) {
                  printf("%s: read error in sector %" PRIu64 "\n",
                                  __func__, SECTOR(addr));
              }
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_load_, NAND_PAGE_SIZE)(NANDFlashState *s,
              s->ioaddr = s->io + SECTOR_OFFSET(s->addr) + offset;
          } else {
              if (blk_pread(s->blk, PAGE_START(addr), s->io,
 -                          (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS) < 0) {
 +                          (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, 0) < 0) {
                  printf("%s: read error in sector %" PRIu64 "\n",
                                  __func__, PAGE_START(addr) >> 9);
              }
 diff --git a/hw/block/onenand.c b/hw/block/onenand.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/onenand.c
 +++ b/hw/block/onenand.c
@@ -XXX,XX +XXX,XX @@ static void onenand_reset(OneNANDState *s, int cold)
          memset(s->blockwp, ONEN_LOCK_LOCKED, s->blocks);
          if (s->blk_cur && blk_pread(s->blk_cur, 0, s->boot[0],
 -                                    8 << BDRV_SECTOR_BITS) < 0) {
 +                                    8 << BDRV_SECTOR_BITS, 0) < 0) {
              hw_error("%s: Loading the BootRAM failed.\n", __func__);
          }
      }
@@ -XXX,XX +XXX,XX @@ static inline int onenand_load_main(OneNANDState *s, int sec, int secn,
      assert(UINT32_MAX >> BDRV_SECTOR_BITS > secn);
      if (s->blk_cur) {
          return blk_pread(s->blk_cur, sec << BDRV_SECTOR_BITS, dest,
 -                         secn << BDRV_SECTOR_BITS) < 0;
 +                         secn << BDRV_SECTOR_BITS, 0) < 0;
      } else if (sec + secn > s->secs_cur) {
          return 1;
      }
@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn,
          uint8_t *dp = 0;
          if (s->blk_cur) {
              dp = g_malloc(size);
 -            if (!dp || blk_pread(s->blk_cur, offset, dp, size) < 0) {
 +            if (!dp || blk_pread(s->blk_cur, offset, dp, size, 0) < 0) {
                  result = 1;
              }
          } else {
@@ -XXX,XX +XXX,XX @@ static inline int onenand_load_spare(OneNANDState *s, int sec, int secn,
      if (s->blk_cur) {
          uint32_t offset = (s->secs_cur + (sec >> 5)) << BDRV_SECTOR_BITS;
 -        if (blk_pread(s->blk_cur, offset, buf, BDRV_SECTOR_SIZE) < 0) {
 +        if (blk_pread(s->blk_cur, offset, buf, BDRV_SECTOR_SIZE, 0) < 0) {
              return 1;
          }
          memcpy(dest, buf + ((sec & 31) << 4), secn << 4);
@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn,
          if (s->blk_cur) {
              dp = g_malloc(512);
              if (!dp
 -                || blk_pread(s->blk_cur, offset, dp, BDRV_SECTOR_SIZE) < 0) {
 +                || blk_pread(s->blk_cur, offset, dp, BDRV_SECTOR_SIZE, 0) < 0) {
                  result = 1;
              } else {
                  dpp = dp + ((sec & 31) << 4);
@@ -XXX,XX +XXX,XX @@ static inline int onenand_erase(OneNANDState *s, int sec, int num)
                  goto fail;
              }
              if (blk_pread(s->blk_cur, erasesec << BDRV_SECTOR_BITS, tmpbuf,
 -                          BDRV_SECTOR_SIZE) < 0) {
 +                          BDRV_SECTOR_SIZE, 0) < 0) {
                  goto fail;
              }
              memcpy(tmpbuf + ((sec & 31) << 4), blankbuf, 1 << 4);
 diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/ide/atapi.c
 +++ b/hw/ide/atapi.c
@@ -XXX,XX +XXX,XX @@ cd_read_sector_sync(IDEState *s)
      switch (s->cd_sector_size) {
      case 2048:
          ret = blk_pread(s->blk, (int64_t)s->lba << ATAPI_SECTOR_BITS,
 -                        s->io_buffer, ATAPI_SECTOR_SIZE);
 +                        s->io_buffer, ATAPI_SECTOR_SIZE, 0);
          break;
      case 2352:
          ret = blk_pread(s->blk, (int64_t)s->lba << ATAPI_SECTOR_BITS,
 -                        s->io_buffer + 16, ATAPI_SECTOR_SIZE);
 +                        s->io_buffer + 16, ATAPI_SECTOR_SIZE, 0);
          if (ret >= 0) {
              cd_data_to_raw(s->io_buffer, s->lba);
          }
 diff --git a/hw/misc/mac_via.c b/hw/misc/mac_via.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/misc/mac_via.c
 +++ b/hw/misc/mac_via.c
@@ -XXX,XX +XXX,XX @@ static void mos6522_q800_via1_realize(DeviceState *dev, Error **errp)
              return;
          }
 -        ret = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM));
 +        ret = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM), 0);
          if (ret < 0) {
              error_setg(errp, "can't read PRAM contents");
              return;
 diff --git a/hw/misc/sifive_u_otp.c b/hw/misc/sifive_u_otp.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/misc/sifive_u_otp.c
 +++ b/hw/misc/sifive_u_otp.c
@@ -XXX,XX +XXX,XX @@ static uint64_t sifive_u_otp_read(void *opaque, hwaddr addr, unsigned int size)
                  int32_t buf;
                  if (blk_pread(s->blk, s->pa * SIFIVE_U_OTP_FUSE_WORD, &buf,
 -                              SIFIVE_U_OTP_FUSE_WORD) < 0) {
 +                              SIFIVE_U_OTP_FUSE_WORD, 0) < 0) {
                      error_report("read error index<%d>", s->pa);
                      return 0xff;
                  }
@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)
                  return;
              }
 -            if (blk_pread(s->blk, 0, s->fuse, filesize) < 0) {
 +            if (blk_pread(s->blk, 0, s->fuse, filesize, 0) < 0) {
                  error_setg(errp, "failed to read the initial flash content");
                  return;
              }
 diff --git a/hw/nvram/eeprom_at24c.c b/hw/nvram/eeprom_at24c.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/nvram/eeprom_at24c.c
 +++ b/hw/nvram/eeprom_at24c.c
@@ -XXX,XX +XXX,XX @@ void at24c_eeprom_reset(DeviceState *state)
      memset(ee->mem, 0, ee->rsize);
      if (ee->blk) {
 -        int ret = blk_pread(ee->blk, 0, ee->mem, ee->rsize);
 +        int ret = blk_pread(ee->blk, 0, ee->mem, ee->rsize, 0);
          if (ret < 0) {
              ERR(TYPE_AT24C_EE
 diff --git a/hw/nvram/spapr_nvram.c b/hw/nvram/spapr_nvram.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/nvram/spapr_nvram.c
 +++ b/hw/nvram/spapr_nvram.c
@@ -XXX,XX +XXX,XX @@ static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
      }
      if (nvram->blk) {
 -        ret = blk_pread(nvram->blk, 0, nvram->buf, nvram->size);
 +        ret = blk_pread(nvram->blk, 0, nvram->buf, nvram->size, 0);
          if (ret < 0) {
              error_setg(errp, "can't read spapr-nvram contents");
 diff --git a/hw/nvram/xlnx-bbram.c b/hw/nvram/xlnx-bbram.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/nvram/xlnx-bbram.c
 +++ b/hw/nvram/xlnx-bbram.c
@@ -XXX,XX +XXX,XX @@ static void bbram_bdrv_read(XlnxBBRam *s, Error **errp)
                      blk_name(s->blk));
      }
 -    if (blk_pread(s->blk, 0, ram, nr) < 0) {
 +    if (blk_pread(s->blk, 0, ram, nr, 0) < 0) {
          error_setg(errp,
                     "%s: Failed to read %u bytes from BBRAM backstore.",
                     blk_name(s->blk), nr);
 diff --git a/hw/nvram/xlnx-efuse.c b/hw/nvram/xlnx-efuse.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/nvram/xlnx-efuse.c
 +++ b/hw/nvram/xlnx-efuse.c
@@ -XXX,XX +XXX,XX @@ static int efuse_bdrv_read(XlnxEFuse *s, Error **errp)
                      blk_name(s->blk));
      }
 -    if (blk_pread(s->blk, 0, ram, nr) < 0) {
 +    if (blk_pread(s->blk, 0, ram, nr, 0) < 0) {
          error_setg(errp, "%s: Failed to read %u bytes from eFUSE backstore.",
                     blk_name(s->blk), nr);
          return -1;
 diff --git a/hw/ppc/pnv_pnor.c b/hw/ppc/pnv_pnor.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/ppc/pnv_pnor.c
 +++ b/hw/ppc/pnv_pnor.c
@@ -XXX,XX +XXX,XX @@ static void pnv_pnor_realize(DeviceState *dev, Error **errp)
          s->storage = blk_blockalign(s->blk, s->size);
 -        if (blk_pread(s->blk, 0, s->storage, s->size) < 0) {
 +        if (blk_pread(s->blk, 0, s->storage, s->size, 0) < 0) {
              error_setg(errp, "failed to read the initial flash content");
              return;
          }
 diff --git a/hw/sd/sd.c b/hw/sd/sd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/sd/sd.c
 +++ b/hw/sd/sd.c
@@ -XXX,XX +XXX,XX @@ void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert)
  static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len)
  {
      trace_sdcard_read_block(addr, len);
 -    if (!sd->blk || blk_pread(sd->blk, addr, sd->data, len) < 0) {
 +    if (!sd->blk || blk_pread(sd->blk, addr, sd->data, len, 0) < 0) {
          fprintf(stderr, "sd_blk_read: read error on host side\n");
      }
  }
 diff --git a/migration/block.c b/migration/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/migration/block.c
 +++ b/migration/block.c
@@ -XXX,XX +XXX,XX @@ static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds,
                  bmds_set_aio_inflight(bmds, sector, nr_sectors, 1);
                  blk_mig_unlock();
              } else {
 -                ret = blk_pread(bmds->blk, sector * BDRV_SECTOR_SIZE, blk->buf,
 -                                nr_sectors * BDRV_SECTOR_SIZE);
 +                ret = blk_pread(bmds->blk, sector * BDRV_SECTOR_SIZE,
 +                                blk->buf, nr_sectors * BDRV_SECTOR_SIZE, 0);
                  if (ret < 0) {
                      goto error;
                  }
 diff --git a/nbd/server.c b/nbd/server.c
 index XXXXXXX..XXXXXXX 100644
 --- a/nbd/server.c
 +++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn nbd_co_send_sparse_read(NBDClient *client,
              ret = nbd_co_send_iov(client, iov, 1, errp);
          } else {
              ret = blk_pread(exp->common.blk, offset + progress,
 -                            data + progress, pnum);
 +                            data + progress, pnum, 0);
              if (ret < 0) {
                  error_setg_errno(errp, -ret, "reading from file failed");
                  break;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_do_cmd_read(NBDClient *client, NBDRequest *request,
                                         data, request->len, errp);
      }
 -    ret = blk_pread(exp->common.blk, request->from, data, request->len);
 +    ret = blk_pread(exp->common.blk, request->from, data, request->len, 0);
      if (ret < 0) {
          return nbd_send_generic_reply(client, request->handle, ret,
                                        "reading from file failed", errp);
 diff --git a/qemu-img.c b/qemu-img.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-img.c
 +++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static int check_empty_sectors(BlockBackend *blk, int64_t offset,
      int ret = 0;
      int64_t idx;
 -    ret = blk_pread(blk, offset, buffer, bytes);
 +    ret = blk_pread(blk, offset, buffer, bytes, 0);
      if (ret < 0) {
          error_report("Error while reading offset %" PRId64 " of %s: %s",
                       offset, filename, strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int img_compare(int argc, char **argv)
                  int64_t pnum;
                  chunk = MIN(chunk, IO_BUF_SIZE);
 -                ret = blk_pread(blk1, offset, buf1, chunk);
 +                ret = blk_pread(blk1, offset, buf1, chunk, 0);
                  if (ret < 0) {
                      error_report("Error while reading offset %" PRId64
                                   " of %s: %s",
@@ -XXX,XX +XXX,XX @@ static int img_compare(int argc, char **argv)
                      ret = 4;
                      goto out;
                  }
 -                ret = blk_pread(blk2, offset, buf2, chunk);
 +                ret = blk_pread(blk2, offset, buf2, chunk, 0);
                  if (ret < 0) {
                      error_report("Error while reading offset %" PRId64
                                   " of %s: %s",
@@ -XXX,XX +XXX,XX @@ static int img_rebase(int argc, char **argv)
                      n = old_backing_size - offset;
                  }
 -                ret = blk_pread(blk_old_backing, offset, buf_old, n);
 +                ret = blk_pread(blk_old_backing, offset, buf_old, n, 0);
                  if (ret < 0) {
                      error_report("error while reading from old backing file");
                      goto out;
@@ -XXX,XX +XXX,XX @@ static int img_rebase(int argc, char **argv)
                      n = new_backing_size - offset;
                  }
 -                ret = blk_pread(blk_new_backing, offset, buf_new, n);
 +                ret = blk_pread(blk_new_backing, offset, buf_new, n, 0);
                  if (ret < 0) {
                      error_report("error while reading from new backing file");
                      goto out;
@@ -XXX,XX +XXX,XX @@ static int img_dd(int argc, char **argv)
      for (out_pos = 0; in_pos < size; block_count++) {
          int bytes = (in_pos + in.bsz > size) ? size - in_pos : in.bsz;
 -        ret = blk_pread(blk1, in_pos, in.buf, bytes);
 +        ret = blk_pread(blk1, in_pos, in.buf, bytes, 0);
          if (ret < 0) {
              error_report("error while reading from input image file: %s",
                           strerror(-ret));
 diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-io-cmds.c
 +++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static int do_pread(BlockBackend *blk, char *buf, int64_t offset,
          return -ERANGE;
      }
 -    ret = blk_pread(blk, offset, (uint8_t *)buf, bytes);
 +    ret = blk_pread(blk, offset, (uint8_t *)buf, bytes, 0);
      if (ret < 0) {
          return ret;
      }
 diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/unit/test-block-iothread.c
 +++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pread(BlockBackend *blk)
      int ret;
      /* Success */
 -    ret = blk_pread(blk, 0, buf, sizeof(buf));
 +    ret = blk_pread(blk, 0, buf, sizeof(buf), 0);
      g_assert_cmpint(ret, ==, 0);
      /* Early error: Negative offset */
 -    ret = blk_pread(blk, -2, buf, sizeof(buf));
 +    ret = blk_pread(blk, -2, buf, sizeof(buf), 0);
      g_assert_cmpint(ret, ==, -EIO);
  }
 --
 .35.3

-New patch
+[PULL 15/35] block: Change blk_{pread,pwrite}() param order
+From: Alberto Faria <afaria@redhat.com>
+Swap 'buf' and 'bytes' around for consistency with
+blk_co_{pread,pwrite}(), and in preparation to implement these functions
+using generated_co_wrapper.
+Callers were updated using this Coccinelle script:
+    @@ expression blk, offset, buf, bytes, flags; @@
+    - blk_pread(blk, offset, buf, bytes, flags)
+    + blk_pread(blk, offset, bytes, buf, flags)
+    @@ expression blk, offset, buf, bytes, flags; @@
+    - blk_pwrite(blk, offset, buf, bytes, flags)
+    + blk_pwrite(blk, offset, bytes, buf, flags)
+It had no effect on hw/block/nand.c, presumably due to the #if, so that
+file was updated manually.
+Overly-long lines were then fixed by hand.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-4-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/sysemu/block-backend-io.h |  4 +--
+ block.c                           |  2 +-
+ block/block-backend.c             |  4 +--
+ block/commit.c                    |  4 +--
+ block/crypto.c                    |  2 +-
+ block/export/fuse.c               |  4 +--
+ block/parallels.c                 |  2 +-
+ block/qcow.c                      |  8 +++---
+ block/qcow2.c                     |  4 +--
+ block/qed.c                       |  8 +++---
+ block/vdi.c                       |  4 +--
+ block/vhdx.c                      | 20 ++++++-------
+ block/vmdk.c                      | 10 +++----
+ block/vpc.c                       | 12 ++++----
+ hw/arm/allwinner-h3.c             |  2 +-
+ hw/arm/aspeed.c                   |  2 +-
+ hw/block/block.c                  |  2 +-
+ hw/block/fdc.c                    | 20 ++++++-------
+ hw/block/hd-geometry.c            |  2 +-
+ hw/block/m25p80.c                 |  2 +-
+ hw/block/nand.c                   | 47 ++++++++++++++++---------------
+ hw/block/onenand.c                | 32 ++++++++++-----------
+ hw/block/pflash_cfi01.c           |  4 +--
+ hw/block/pflash_cfi02.c           |  4 +--
+ hw/ide/atapi.c                    |  4 +--
+ hw/misc/mac_via.c                 |  4 +--
+ hw/misc/sifive_u_otp.c            | 14 ++++-----
+ hw/nvram/eeprom_at24c.c           |  4 +--
+ hw/nvram/spapr_nvram.c            |  6 ++--
+ hw/nvram/xlnx-bbram.c             |  4 +--
+ hw/nvram/xlnx-efuse.c             |  4 +--
+ hw/ppc/pnv_pnor.c                 |  6 ++--
+ hw/sd/sd.c                        |  4 +--
+ migration/block.c                 |  6 ++--
+ nbd/server.c                      |  8 +++---
+ qemu-img.c                        | 18 ++++++------
+ qemu-io-cmds.c                    |  4 +--
+ tests/unit/test-block-iothread.c  |  8 +++---
+files changed, 150 insertions(+), 149 deletions(-)
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
+  * the "I/O or GS" API.
+  */
+-int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes,
++int blk_pread(BlockBackend *blk, int64_t offset, int bytes, void *buf,
+               BdrvRequestFlags flags);
+-int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes,
++int blk_pwrite(BlockBackend *blk, int64_t offset, int bytes, const void *buf,
+                BdrvRequestFlags flags);
+ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
+                                int64_t bytes, QEMUIOVector *qiov,
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ static int find_image_format(BlockBackend *file, const char *filename,
+         return ret;
+     }
+-    ret = blk_pread(file, 0, buf, sizeof(buf), 0);
++    ret = blk_pread(file, 0, sizeof(buf), buf, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not read image for determining its "
+                          "format");
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                         flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
+ }
+-int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes,
++int blk_pread(BlockBackend *blk, int64_t offset, int bytes, void *buf,
+               BdrvRequestFlags flags)
+ {
+     int ret;
+@@ -XXX,XX +XXX,XX @@ int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes,
+     return ret;
+ }
+-int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes,
++int blk_pwrite(BlockBackend *blk, int64_t offset, int bytes, const void *buf,
+                BdrvRequestFlags flags)
+ {
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+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 @@ int bdrv_commit(BlockDriverState *bs)
+             goto ro_cleanup;
+         }
+         if (ret) {
+-            ret = blk_pread(src, offset, buf, n, 0);
++            ret = blk_pread(src, offset, n, buf, 0);
+             if (ret < 0) {
+                 goto ro_cleanup;
+             }
+-            ret = blk_pwrite(backing, offset, buf, n, 0);
++            ret = blk_pwrite(backing, offset, n, buf, 0);
+             if (ret < 0) {
+                 goto ro_cleanup;
+             }
+diff --git a/block/crypto.c b/block/crypto.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/crypto.c
++++ b/block/crypto.c
+@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_write_func(QCryptoBlock *block,
+     struct BlockCryptoCreateData *data = opaque;
+     ssize_t ret;
+-    ret = blk_pwrite(data->blk, offset, buf, buflen, 0);
++    ret = blk_pwrite(data->blk, offset, buflen, buf, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not write encryption header");
+         return ret;
+diff --git a/block/export/fuse.c b/block/export/fuse.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/export/fuse.c
++++ b/block/export/fuse.c
+@@ -XXX,XX +XXX,XX @@ static void fuse_read(fuse_req_t req, fuse_ino_t inode,
+         return;
+     }
+-    ret = blk_pread(exp->common.blk, offset, buf, size, 0);
++    ret = blk_pread(exp->common.blk, offset, size, buf, 0);
+     if (ret >= 0) {
+         fuse_reply_buf(req, buf, size);
+     } else {
+@@ -XXX,XX +XXX,XX @@ static void fuse_write(fuse_req_t req, fuse_ino_t inode, const char *buf,
+         }
+     }
+-    ret = blk_pwrite(exp->common.blk, offset, buf, size, 0);
++    ret = blk_pwrite(exp->common.blk, offset, size, buf, 0);
+     if (ret >= 0) {
+         fuse_reply_write(req, size);
+     } else {
+diff --git a/block/parallels.c b/block/parallels.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/parallels.c
++++ b/block/parallels.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,
+     memset(tmp, 0, sizeof(tmp));
+     memcpy(tmp, &header, sizeof(header));
+-    ret = blk_pwrite(blk, 0, tmp, BDRV_SECTOR_SIZE, 0);
++    ret = blk_pwrite(blk, 0, BDRV_SECTOR_SIZE, tmp, 0);
+     if (ret < 0) {
+         goto exit;
+     }
+diff --git a/block/qcow.c b/block/qcow.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow.c
++++ b/block/qcow.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
+     }
+     /* write all the data */
+-    ret = blk_pwrite(qcow_blk, 0, &header, sizeof(header), 0);
++    ret = blk_pwrite(qcow_blk, 0, sizeof(header), &header, 0);
+     if (ret < 0) {
+         goto exit;
+     }
+     if (qcow_opts->has_backing_file) {
+-        ret = blk_pwrite(qcow_blk, sizeof(header),
+-                         qcow_opts->backing_file, backing_filename_len, 0);
++        ret = blk_pwrite(qcow_blk, sizeof(header), backing_filename_len,
++                         qcow_opts->backing_file, 0);
+         if (ret < 0) {
+             goto exit;
+         }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
+     for (i = 0; i < DIV_ROUND_UP(sizeof(uint64_t) * l1_size, BDRV_SECTOR_SIZE);
+          i++) {
+         ret = blk_pwrite(qcow_blk, header_size + BDRV_SECTOR_SIZE * i,
+-                         tmp, BDRV_SECTOR_SIZE, 0);
++                         BDRV_SECTOR_SIZE, tmp, 0);
+         if (ret < 0) {
+             g_free(tmp);
+             goto exit;
+diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.c
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
+             cpu_to_be64(QCOW2_INCOMPAT_EXTL2);
+     }
+-    ret = blk_pwrite(blk, 0, header, cluster_size, 0);
++    ret = blk_pwrite(blk, 0, cluster_size, header, 0);
+     g_free(header);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not write qcow2 header");
+@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
+     /* Write a refcount table with one refcount block */
+     refcount_table = g_malloc0(2 * cluster_size);
+     refcount_table[0] = cpu_to_be64(2 * cluster_size);
+-    ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0);
++    ret = blk_pwrite(blk, cluster_size, 2 * cluster_size, refcount_table, 0);
+     g_free(refcount_table);
+     if (ret < 0) {
+diff --git a/block/qed.c b/block/qed.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qed.c
++++ b/block/qed.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
+     }
+     qed_header_cpu_to_le(&header, &le_header);
+-    ret = blk_pwrite(blk, 0, &le_header, sizeof(le_header), 0);
++    ret = blk_pwrite(blk, 0, sizeof(le_header), &le_header, 0);
+     if (ret < 0) {
+         goto out;
+     }
+-    ret = blk_pwrite(blk, sizeof(le_header), qed_opts->backing_file,
+-                     header.backing_filename_size, 0);
++    ret = blk_pwrite(blk, sizeof(le_header), header.backing_filename_size,
++                     qed_opts->backing_file, 0);
+     if (ret < 0) {
+         goto out;
+     }
+     l1_table = g_malloc0(l1_size);
+-    ret = blk_pwrite(blk, header.l1_table_offset, l1_table, l1_size, 0);
++    ret = blk_pwrite(blk, header.l1_table_offset, l1_size, l1_table, 0);
+     if (ret < 0) {
+         goto out;
+     }
+diff --git a/block/vdi.c b/block/vdi.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vdi.c
++++ b/block/vdi.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
+         vdi_header_print(&header);
+     }
+     vdi_header_to_le(&header);
+-    ret = blk_pwrite(blk, offset, &header, sizeof(header), 0);
++    ret = blk_pwrite(blk, offset, sizeof(header), &header, 0);
+     if (ret < 0) {
+         error_setg(errp, "Error writing header");
+         goto exit;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
+                 bmap[i] = VDI_UNALLOCATED;
+             }
+         }
+-        ret = blk_pwrite(blk, offset, bmap, bmap_size, 0);
++        ret = blk_pwrite(blk, offset, bmap_size, bmap, 0);
+         if (ret < 0) {
+             error_setg(errp, "Error writing bmap");
+             goto exit;
+diff --git a/block/vhdx.c b/block/vhdx.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vhdx.c
++++ b/block/vhdx.c
+@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_metadata(BlockBackend *blk,
+                                    VHDX_META_FLAGS_IS_VIRTUAL_DISK;
+     vhdx_metadata_entry_le_export(&md_table_entry[4]);
+-    ret = blk_pwrite(blk, metadata_offset, buffer, VHDX_HEADER_BLOCK_SIZE, 0);
++    ret = blk_pwrite(blk, metadata_offset, VHDX_HEADER_BLOCK_SIZE, buffer, 0);
+     if (ret < 0) {
+         goto exit;
+     }
+-    ret = blk_pwrite(blk, metadata_offset + (64 * KiB), entry_buffer,
+-                     VHDX_METADATA_ENTRY_BUFFER_SIZE, 0);
++    ret = blk_pwrite(blk, metadata_offset + (64 * KiB),
++                     VHDX_METADATA_ENTRY_BUFFER_SIZE, entry_buffer, 0);
+     if (ret < 0) {
+         goto exit;
+     }
+@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
+             s->bat[sinfo.bat_idx] = cpu_to_le64(s->bat[sinfo.bat_idx]);
+             sector_num += s->sectors_per_block;
+         }
+-        ret = blk_pwrite(blk, file_offset, s->bat, length, 0);
++        ret = blk_pwrite(blk, file_offset, length, s->bat, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to write the BAT");
+             goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_region_table(BlockBackend *blk,
+     }
+     /* Now write out the region headers to disk */
+-    ret = blk_pwrite(blk, VHDX_REGION_TABLE_OFFSET, buffer,
+-                     VHDX_HEADER_BLOCK_SIZE, 0);
++    ret = blk_pwrite(blk, VHDX_REGION_TABLE_OFFSET, VHDX_HEADER_BLOCK_SIZE,
++                     buffer, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to write first region table");
+         goto exit;
+     }
+-    ret = blk_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, buffer,
+-                     VHDX_HEADER_BLOCK_SIZE, 0);
++    ret = blk_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, VHDX_HEADER_BLOCK_SIZE,
++                     buffer, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to write second region table");
+         goto exit;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
+     creator = g_utf8_to_utf16("QEMU v" QEMU_VERSION, -1, NULL,
+                               &creator_items, NULL);
+     signature = cpu_to_le64(VHDX_FILE_SIGNATURE);
+-    ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET, &signature, sizeof(signature),
++    ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET, sizeof(signature), &signature,
+);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Failed to write file signature");
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
+     }
+     if (creator) {
+         ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET + sizeof(signature),
+-                         creator, creator_items * sizeof(gunichar2), 0);
++                         creator_items * sizeof(gunichar2), creator, 0);
+         if (ret < 0) {
+             error_setg_errno(errp, -ret, "Failed to write creator field");
+             goto delete_and_exit;
+diff --git a/block/vmdk.c b/block/vmdk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vmdk.c
++++ b/block/vmdk.c
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
+     header.check_bytes[3] = 0xa;
+     /* write all the data */
+-    ret = blk_pwrite(blk, 0, &magic, sizeof(magic), 0);
++    ret = blk_pwrite(blk, 0, sizeof(magic), &magic, 0);
+     if (ret < 0) {
+         error_setg(errp, QERR_IO_ERROR);
+         goto exit;
+     }
+-    ret = blk_pwrite(blk, sizeof(magic), &header, sizeof(header), 0);
++    ret = blk_pwrite(blk, sizeof(magic), sizeof(header), &header, 0);
+     if (ret < 0) {
+         error_setg(errp, QERR_IO_ERROR);
+         goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
+         gd_buf[i] = cpu_to_le32(tmp);
+     }
+     ret = blk_pwrite(blk, le64_to_cpu(header.rgd_offset) * BDRV_SECTOR_SIZE,
+-                     gd_buf, gd_buf_size, 0);
++                     gd_buf_size, gd_buf, 0);
+     if (ret < 0) {
+         error_setg(errp, QERR_IO_ERROR);
+         goto exit;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
+         gd_buf[i] = cpu_to_le32(tmp);
+     }
+     ret = blk_pwrite(blk, le64_to_cpu(header.gd_offset) * BDRV_SECTOR_SIZE,
+-                     gd_buf, gd_buf_size, 0);
++                     gd_buf_size, gd_buf, 0);
+     if (ret < 0) {
+         error_setg(errp, QERR_IO_ERROR);
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size,
+         desc_offset = 0x200;
+     }
+-    ret = blk_pwrite(blk, desc_offset, desc, desc_len, 0);
++    ret = blk_pwrite(blk, desc_offset, desc_len, desc, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Could not write description");
+         goto exit;
+diff --git a/block/vpc.c b/block/vpc.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vpc.c
++++ b/block/vpc.c
+@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
+     block_size = 0x200000;
+     num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512);
+-    ret = blk_pwrite(blk, offset, footer, sizeof(*footer), 0);
++    ret = blk_pwrite(blk, offset, sizeof(*footer), footer, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+     offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
+-    ret = blk_pwrite(blk, offset, footer, sizeof(*footer), 0);
++    ret = blk_pwrite(blk, offset, sizeof(*footer), footer, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
+     memset(bat_sector, 0xFF, 512);
+     for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
+-        ret = blk_pwrite(blk, offset, bat_sector, 512, 0);
++        ret = blk_pwrite(blk, offset, 512, bat_sector, 0);
+         if (ret < 0) {
+             goto fail;
+         }
+@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
+     /* Write the header */
+     offset = 512;
+-    ret = blk_pwrite(blk, offset, &dyndisk_header, sizeof(dyndisk_header), 0);
++    ret = blk_pwrite(blk, offset, sizeof(dyndisk_header), &dyndisk_header, 0);
+     if (ret < 0) {
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, VHDFooter *footer,
+         return ret;
+     }
+-    ret = blk_pwrite(blk, total_size - sizeof(*footer),
+-                     footer, sizeof(*footer), 0);
++    ret = blk_pwrite(blk, total_size - sizeof(*footer), sizeof(*footer),
++                     footer, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "Unable to write VHD header");
+         return ret;
+diff --git a/hw/arm/allwinner-h3.c b/hw/arm/allwinner-h3.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/arm/allwinner-h3.c
++++ b/hw/arm/allwinner-h3.c
+@@ -XXX,XX +XXX,XX @@ void allwinner_h3_bootrom_setup(AwH3State *s, BlockBackend *blk)
+     const int64_t rom_size = 32 * KiB;
+     g_autofree uint8_t *buffer = g_new0(uint8_t, rom_size);
+-    if (blk_pread(blk, 8 * KiB, buffer, rom_size, 0) < 0) {
++    if (blk_pread(blk, 8 * KiB, rom_size, buffer, 0) < 0) {
+         error_setg(&error_fatal, "%s: failed to read BlockBackend data",
+                    __func__);
+         return;
+diff --git a/hw/arm/aspeed.c b/hw/arm/aspeed.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/arm/aspeed.c
++++ b/hw/arm/aspeed.c
+@@ -XXX,XX +XXX,XX @@ static void write_boot_rom(DriveInfo *dinfo, hwaddr addr, size_t rom_size,
+     }
+     storage = g_malloc0(rom_size);
+-    if (blk_pread(blk, 0, storage, rom_size, 0) < 0) {
++    if (blk_pread(blk, 0, rom_size, storage, 0) < 0) {
+         error_setg(errp, "failed to read the initial flash content");
+         return;
+     }
+diff --git a/hw/block/block.c b/hw/block/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/block.c
++++ b/hw/block/block.c
+@@ -XXX,XX +XXX,XX @@ bool blk_check_size_and_read_all(BlockBackend *blk, void *buf, hwaddr size,
+      * block device and read only on demand.
+      */
+     assert(size <= BDRV_REQUEST_MAX_BYTES);
+-    ret = blk_pread(blk, 0, buf, size, 0);
++    ret = blk_pread(blk, 0, size, buf, 0);
+     if (ret < 0) {
+         error_setg_errno(errp, -ret, "can't read block backend");
+         return false;
+diff --git a/hw/block/fdc.c b/hw/block/fdc.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/fdc.c
++++ b/hw/block/fdc.c
+@@ -XXX,XX +XXX,XX @@ int fdctrl_transfer_handler(void *opaque, int nchan, int dma_pos, int dma_len)
+         if (fdctrl->data_dir != FD_DIR_WRITE ||
+             len < FD_SECTOR_LEN || rel_pos != 0) {
+             /* READ & SCAN commands and realign to a sector for WRITE */
+-            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
+-                          BDRV_SECTOR_SIZE, 0) < 0) {
++            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
++                          fdctrl->fifo, 0) < 0) {
+                 FLOPPY_DPRINTF("Floppy: error getting sector %d\n",
+                                fd_sector(cur_drv));
+                 /* Sure, image size is too small... */
+@@ -XXX,XX +XXX,XX @@ int fdctrl_transfer_handler(void *opaque, int nchan, int dma_pos, int dma_len)
+             k->read_memory(fdctrl->dma, nchan, fdctrl->fifo + rel_pos,
+                            fdctrl->data_pos, len);
+-            if (blk_pwrite(cur_drv->blk, fd_offset(cur_drv),
+-                           fdctrl->fifo, BDRV_SECTOR_SIZE, 0) < 0) {
++            if (blk_pwrite(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
++                           fdctrl->fifo, 0) < 0) {
+                 FLOPPY_DPRINTF("error writing sector %d\n",
+                                fd_sector(cur_drv));
+                 fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00);
+@@ -XXX,XX +XXX,XX @@ static uint32_t fdctrl_read_data(FDCtrl *fdctrl)
+                                    fd_sector(cur_drv));
+                     return 0;
+                 }
+-            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
+-                          BDRV_SECTOR_SIZE, 0)
++            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
++                          fdctrl->fifo, 0)
+                 < 0) {
+                 FLOPPY_DPRINTF("error getting sector %d\n",
+                                fd_sector(cur_drv));
+@@ -XXX,XX +XXX,XX @@ static void fdctrl_format_sector(FDCtrl *fdctrl)
+     }
+     memset(fdctrl->fifo, 0, FD_SECTOR_LEN);
+     if (cur_drv->blk == NULL ||
+-        blk_pwrite(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
+-                   BDRV_SECTOR_SIZE, 0) < 0) {
++        blk_pwrite(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
++                   fdctrl->fifo, 0) < 0) {
+         FLOPPY_DPRINTF("error formatting sector %d\n", fd_sector(cur_drv));
+         fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00);
+     } else {
+@@ -XXX,XX +XXX,XX @@ static void fdctrl_write_data(FDCtrl *fdctrl, uint32_t value)
+         if (pos == FD_SECTOR_LEN - 1 ||
+             fdctrl->data_pos == fdctrl->data_len) {
+             cur_drv = get_cur_drv(fdctrl);
+-            if (blk_pwrite(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
+-                           BDRV_SECTOR_SIZE, 0) < 0) {
++            if (blk_pwrite(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
++                           fdctrl->fifo, 0) < 0) {
+                 FLOPPY_DPRINTF("error writing sector %d\n",
+                                fd_sector(cur_drv));
+                 break;
+diff --git a/hw/block/hd-geometry.c b/hw/block/hd-geometry.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/hd-geometry.c
++++ b/hw/block/hd-geometry.c
+@@ -XXX,XX +XXX,XX @@ static int guess_disk_lchs(BlockBackend *blk,
+     blk_get_geometry(blk, &nb_sectors);
+-    if (blk_pread(blk, 0, buf, BDRV_SECTOR_SIZE, 0) < 0) {
++    if (blk_pread(blk, 0, BDRV_SECTOR_SIZE, buf, 0) < 0) {
+         return -1;
+     }
+     /* test msdos magic */
+diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/m25p80.c
++++ b/hw/block/m25p80.c
+@@ -XXX,XX +XXX,XX @@ static void m25p80_realize(SSIPeripheral *ss, Error **errp)
+         trace_m25p80_binding(s);
+         s->storage = blk_blockalign(s->blk, s->size);
+-        if (blk_pread(s->blk, 0, s->storage, s->size, 0) < 0) {
++        if (blk_pread(s->blk, 0, s->size, s->storage, 0) < 0) {
+             error_setg(errp, "failed to read the initial flash content");
+             return;
+         }
+diff --git a/hw/block/nand.c b/hw/block/nand.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/nand.c
++++ b/hw/block/nand.c
+@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_write_, NAND_PAGE_SIZE)(NANDFlashState *s)
+         sector = SECTOR(s->addr);
+         off = (s->addr & PAGE_MASK) + s->offset;
+         soff = SECTOR_OFFSET(s->addr);
+-        if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
+-                      PAGE_SECTORS << BDRV_SECTOR_BITS, 0) < 0) {
++        if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS,
++                      PAGE_SECTORS << BDRV_SECTOR_BITS, iobuf, 0) < 0) {
+             printf("%s: read error in sector %" PRIu64 "\n", __func__, sector);
+             return;
+         }
+@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_write_, NAND_PAGE_SIZE)(NANDFlashState *s)
+                             MIN(OOB_SIZE, off + s->iolen - NAND_PAGE_SIZE));
+         }
+-        if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
+-                       PAGE_SECTORS << BDRV_SECTOR_BITS, 0) < 0) {
++        if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS,
++                       PAGE_SECTORS << BDRV_SECTOR_BITS, iobuf, 0) < 0) {
+             printf("%s: write error in sector %" PRIu64 "\n", __func__, sector);
+         }
+     } else {
+         off = PAGE_START(s->addr) + (s->addr & PAGE_MASK) + s->offset;
+         sector = off >> 9;
+         soff = off & 0x1ff;
+-        if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
+-                      (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, 0) < 0) {
++        if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS,
++                      (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, iobuf, 0) < 0) {
+             printf("%s: read error in sector %" PRIu64 "\n", __func__, sector);
+             return;
+         }
+         mem_and(iobuf + soff, s->io, s->iolen);
+-        if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
+-                       (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, 0) < 0) {
++        if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS,
++                       (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, iobuf, 0) < 0) {
+             printf("%s: write error in sector %" PRIu64 "\n", __func__, sector);
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_erase_, NAND_PAGE_SIZE)(NANDFlashState *s)
+         i = SECTOR(addr);
+         page = SECTOR(addr + (1 << (ADDR_SHIFT + s->erase_shift)));
+         for (; i < page; i ++)
+-            if (blk_pwrite(s->blk, i << BDRV_SECTOR_BITS, iobuf,
+-                           BDRV_SECTOR_SIZE, 0) < 0) {
++            if (blk_pwrite(s->blk, i << BDRV_SECTOR_BITS,
++                           BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
+                 printf("%s: write error in sector %" PRIu64 "\n", __func__, i);
+             }
+     } else {
+         addr = PAGE_START(addr);
+         page = addr >> 9;
+-        if (blk_pread(s->blk, page << BDRV_SECTOR_BITS, iobuf,
+-                      BDRV_SECTOR_SIZE, 0) < 0) {
++        if (blk_pread(s->blk, page << BDRV_SECTOR_BITS,
++                      BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
+             printf("%s: read error in sector %" PRIu64 "\n", __func__, page);
+         }
+         memset(iobuf + (addr & 0x1ff), 0xff, (~addr & 0x1ff) + 1);
+-        if (blk_pwrite(s->blk, page << BDRV_SECTOR_BITS, iobuf,
+-                       BDRV_SECTOR_SIZE, 0) < 0) {
++        if (blk_pwrite(s->blk, page << BDRV_SECTOR_BITS,
++                       BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
+             printf("%s: write error in sector %" PRIu64 "\n", __func__, page);
+         }
+@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_erase_, NAND_PAGE_SIZE)(NANDFlashState *s)
+         i = (addr & ~0x1ff) + 0x200;
+         for (addr += ((NAND_PAGE_SIZE + OOB_SIZE) << s->erase_shift) - 0x200;
+                         i < addr; i += 0x200) {
+-            if (blk_pwrite(s->blk, i, iobuf, BDRV_SECTOR_SIZE, 0) < 0) {
++            if (blk_pwrite(s->blk, i, BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
+                 printf("%s: write error in sector %" PRIu64 "\n",
+                        __func__, i >> 9);
+             }
+         }
+         page = i >> 9;
+-        if (blk_pread(s->blk, page << BDRV_SECTOR_BITS, iobuf,
+-                      BDRV_SECTOR_SIZE, 0) < 0) {
++        if (blk_pread(s->blk, page << BDRV_SECTOR_BITS,
++                      BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
+             printf("%s: read error in sector %" PRIu64 "\n", __func__, page);
+         }
+         memset(iobuf, 0xff, ((addr - 1) & 0x1ff) + 1);
+-        if (blk_pwrite(s->blk, page << BDRV_SECTOR_BITS, iobuf,
+-                       BDRV_SECTOR_SIZE, 0) < 0) {
++        if (blk_pwrite(s->blk, page << BDRV_SECTOR_BITS,
++                       BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
+             printf("%s: write error in sector %" PRIu64 "\n", __func__, page);
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_load_, NAND_PAGE_SIZE)(NANDFlashState *s,
+     if (s->blk) {
+         if (s->mem_oob) {
+-            if (blk_pread(s->blk, SECTOR(addr) << BDRV_SECTOR_BITS, s->io,
+-                          PAGE_SECTORS << BDRV_SECTOR_BITS, 0) < 0) {
++            if (blk_pread(s->blk, SECTOR(addr) << BDRV_SECTOR_BITS,
++                          PAGE_SECTORS << BDRV_SECTOR_BITS, s->io, 0) < 0) {
+                 printf("%s: read error in sector %" PRIu64 "\n",
+                                 __func__, SECTOR(addr));
+             }
+@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_load_, NAND_PAGE_SIZE)(NANDFlashState *s,
+                             OOB_SIZE);
+             s->ioaddr = s->io + SECTOR_OFFSET(s->addr) + offset;
+         } else {
+-            if (blk_pread(s->blk, PAGE_START(addr), s->io,
+-                          (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, 0) < 0) {
++            if (blk_pread(s->blk, PAGE_START(addr),
++                          (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, s->io, 0)
++                < 0) {
+                 printf("%s: read error in sector %" PRIu64 "\n",
+                                 __func__, PAGE_START(addr) >> 9);
+             }
+diff --git a/hw/block/onenand.c b/hw/block/onenand.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/onenand.c
++++ b/hw/block/onenand.c
+@@ -XXX,XX +XXX,XX @@ static void onenand_reset(OneNANDState *s, int cold)
+         /* Lock the whole flash */
+         memset(s->blockwp, ONEN_LOCK_LOCKED, s->blocks);
+-        if (s->blk_cur && blk_pread(s->blk_cur, 0, s->boot[0],
+-                                    8 << BDRV_SECTOR_BITS, 0) < 0) {
++        if (s->blk_cur && blk_pread(s->blk_cur, 0, 8 << BDRV_SECTOR_BITS,
++                                    s->boot[0], 0) < 0) {
+             hw_error("%s: Loading the BootRAM failed.\n", __func__);
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ static inline int onenand_load_main(OneNANDState *s, int sec, int secn,
+     assert(UINT32_MAX >> BDRV_SECTOR_BITS > sec);
+     assert(UINT32_MAX >> BDRV_SECTOR_BITS > secn);
+     if (s->blk_cur) {
+-        return blk_pread(s->blk_cur, sec << BDRV_SECTOR_BITS, dest,
+-                         secn << BDRV_SECTOR_BITS, 0) < 0;
++        return blk_pread(s->blk_cur, sec << BDRV_SECTOR_BITS,
++                         secn << BDRV_SECTOR_BITS, dest, 0) < 0;
+     } else if (sec + secn > s->secs_cur) {
+         return 1;
+     }
+@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn,
+         uint8_t *dp = 0;
+         if (s->blk_cur) {
+             dp = g_malloc(size);
+-            if (!dp || blk_pread(s->blk_cur, offset, dp, size, 0) < 0) {
++            if (!dp || blk_pread(s->blk_cur, offset, size, dp, 0) < 0) {
+                 result = 1;
+             }
+         } else {
+@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn,
+                 dp[i] &= sp[i];
+             }
+             if (s->blk_cur) {
+-                result = blk_pwrite(s->blk_cur, offset, dp, size, 0) < 0;
++                result = blk_pwrite(s->blk_cur, offset, size, dp, 0) < 0;
+             }
+         }
+         if (dp && s->blk_cur) {
+@@ -XXX,XX +XXX,XX @@ static inline int onenand_load_spare(OneNANDState *s, int sec, int secn,
+     if (s->blk_cur) {
+         uint32_t offset = (s->secs_cur + (sec >> 5)) << BDRV_SECTOR_BITS;
+-        if (blk_pread(s->blk_cur, offset, buf, BDRV_SECTOR_SIZE, 0) < 0) {
++        if (blk_pread(s->blk_cur, offset, BDRV_SECTOR_SIZE, buf, 0) < 0) {
+             return 1;
+         }
+         memcpy(dest, buf + ((sec & 31) << 4), secn << 4);
+@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn,
+         if (s->blk_cur) {
+             dp = g_malloc(512);
+             if (!dp
+-                || blk_pread(s->blk_cur, offset, dp, BDRV_SECTOR_SIZE, 0) < 0) {
++                || blk_pread(s->blk_cur, offset, BDRV_SECTOR_SIZE, dp, 0) < 0) {
+                 result = 1;
+             } else {
+                 dpp = dp + ((sec & 31) << 4);
+@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn,
+                 dpp[i] &= sp[i];
+             }
+             if (s->blk_cur) {
+-                result = blk_pwrite(s->blk_cur, offset, dp,
+-                                    BDRV_SECTOR_SIZE, 0) < 0;
++                result = blk_pwrite(s->blk_cur, offset, BDRV_SECTOR_SIZE, dp,
++                                    0) < 0;
+             }
+         }
+         g_free(dp);
+@@ -XXX,XX +XXX,XX @@ static inline int onenand_erase(OneNANDState *s, int sec, int num)
+     for (; num > 0; num--, sec++) {
+         if (s->blk_cur) {
+             int erasesec = s->secs_cur + (sec >> 5);
+-            if (blk_pwrite(s->blk_cur, sec << BDRV_SECTOR_BITS, blankbuf,
+-                           BDRV_SECTOR_SIZE, 0) < 0) {
++            if (blk_pwrite(s->blk_cur, sec << BDRV_SECTOR_BITS,
++                           BDRV_SECTOR_SIZE, blankbuf, 0) < 0) {
+                 goto fail;
+             }
+-            if (blk_pread(s->blk_cur, erasesec << BDRV_SECTOR_BITS, tmpbuf,
+-                          BDRV_SECTOR_SIZE, 0) < 0) {
++            if (blk_pread(s->blk_cur, erasesec << BDRV_SECTOR_BITS,
++                          BDRV_SECTOR_SIZE, tmpbuf, 0) < 0) {
+                 goto fail;
+             }
+             memcpy(tmpbuf + ((sec & 31) << 4), blankbuf, 1 << 4);
+-            if (blk_pwrite(s->blk_cur, erasesec << BDRV_SECTOR_BITS, tmpbuf,
+-                           BDRV_SECTOR_SIZE, 0) < 0) {
++            if (blk_pwrite(s->blk_cur, erasesec << BDRV_SECTOR_BITS,
++                           BDRV_SECTOR_SIZE, tmpbuf, 0) < 0) {
+                 goto fail;
+             }
+         } else {
+diff --git a/hw/block/pflash_cfi01.c b/hw/block/pflash_cfi01.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/pflash_cfi01.c
++++ b/hw/block/pflash_cfi01.c
+@@ -XXX,XX +XXX,XX @@ static void pflash_update(PFlashCFI01 *pfl, int offset,
+         /* widen to sector boundaries */
+         offset = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);
+         offset_end = QEMU_ALIGN_UP(offset_end, BDRV_SECTOR_SIZE);
+-        ret = blk_pwrite(pfl->blk, offset, pfl->storage + offset,
+-                   offset_end - offset, 0);
++        ret = blk_pwrite(pfl->blk, offset, offset_end - offset,
++                         pfl->storage + offset, 0);
+         if (ret < 0) {
+             /* TODO set error bit in status */
+             error_report("Could not update PFLASH: %s", strerror(-ret));
+diff --git a/hw/block/pflash_cfi02.c b/hw/block/pflash_cfi02.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/pflash_cfi02.c
++++ b/hw/block/pflash_cfi02.c
+@@ -XXX,XX +XXX,XX @@ static void pflash_update(PFlashCFI02 *pfl, int offset, int size)
+         /* widen to sector boundaries */
+         offset = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);
+         offset_end = QEMU_ALIGN_UP(offset_end, BDRV_SECTOR_SIZE);
+-        ret = blk_pwrite(pfl->blk, offset, pfl->storage + offset,
+-                   offset_end - offset, 0);
++        ret = blk_pwrite(pfl->blk, offset, offset_end - offset,
++                         pfl->storage + offset, 0);
+         if (ret < 0) {
+             /* TODO set error bit in status */
+             error_report("Could not update PFLASH: %s", strerror(-ret));
+diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/ide/atapi.c
++++ b/hw/ide/atapi.c
+@@ -XXX,XX +XXX,XX @@ cd_read_sector_sync(IDEState *s)
+     switch (s->cd_sector_size) {
+     case 2048:
+         ret = blk_pread(s->blk, (int64_t)s->lba << ATAPI_SECTOR_BITS,
+-                        s->io_buffer, ATAPI_SECTOR_SIZE, 0);
++                        ATAPI_SECTOR_SIZE, s->io_buffer, 0);
+         break;
+     case 2352:
+         ret = blk_pread(s->blk, (int64_t)s->lba << ATAPI_SECTOR_BITS,
+-                        s->io_buffer + 16, ATAPI_SECTOR_SIZE, 0);
++                        ATAPI_SECTOR_SIZE, s->io_buffer + 16, 0);
+         if (ret >= 0) {
+             cd_data_to_raw(s->io_buffer, s->lba);
+         }
+diff --git a/hw/misc/mac_via.c b/hw/misc/mac_via.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/misc/mac_via.c
++++ b/hw/misc/mac_via.c
+@@ -XXX,XX +XXX,XX @@ static void via1_one_second(void *opaque)
+ static void pram_update(MOS6522Q800VIA1State *v1s)
+ {
+     if (v1s->blk) {
+-        if (blk_pwrite(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM), 0) < 0) {
++        if (blk_pwrite(v1s->blk, 0, sizeof(v1s->PRAM), v1s->PRAM, 0) < 0) {
+             qemu_log("pram_update: cannot write to file\n");
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ static void mos6522_q800_via1_realize(DeviceState *dev, Error **errp)
+             return;
+         }
+-        ret = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM), 0);
++        ret = blk_pread(v1s->blk, 0, sizeof(v1s->PRAM), v1s->PRAM, 0);
+         if (ret < 0) {
+             error_setg(errp, "can't read PRAM contents");
+             return;
+diff --git a/hw/misc/sifive_u_otp.c b/hw/misc/sifive_u_otp.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/misc/sifive_u_otp.c
++++ b/hw/misc/sifive_u_otp.c
+@@ -XXX,XX +XXX,XX @@ static uint64_t sifive_u_otp_read(void *opaque, hwaddr addr, unsigned int size)
+             if (s->blk) {
+                 int32_t buf;
+-                if (blk_pread(s->blk, s->pa * SIFIVE_U_OTP_FUSE_WORD, &buf,
+-                              SIFIVE_U_OTP_FUSE_WORD, 0) < 0) {
++                if (blk_pread(s->blk, s->pa * SIFIVE_U_OTP_FUSE_WORD,
++                              SIFIVE_U_OTP_FUSE_WORD, &buf, 0) < 0) {
+                     error_report("read error index<%d>", s->pa);
+                     return 0xff;
+                 }
+@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_write(void *opaque, hwaddr addr,
+             /* write to backend */
+             if (s->blk) {
+                 if (blk_pwrite(s->blk, s->pa * SIFIVE_U_OTP_FUSE_WORD,
+-                               &s->fuse[s->pa], SIFIVE_U_OTP_FUSE_WORD,
+-                               0) < 0) {
++                               SIFIVE_U_OTP_FUSE_WORD, &s->fuse[s->pa], 0)
++                    < 0) {
+                     error_report("write error index<%d>", s->pa);
+                 }
+             }
+@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)
+                 return;
+             }
+-            if (blk_pread(s->blk, 0, s->fuse, filesize, 0) < 0) {
++            if (blk_pread(s->blk, 0, filesize, s->fuse, 0) < 0) {
+                 error_setg(errp, "failed to read the initial flash content");
+                 return;
+             }
+@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)
+         serial_data = s->serial;
+         if (blk_pwrite(s->blk, index * SIFIVE_U_OTP_FUSE_WORD,
+-                       &serial_data, SIFIVE_U_OTP_FUSE_WORD, 0) < 0) {
++                       SIFIVE_U_OTP_FUSE_WORD, &serial_data, 0) < 0) {
+             error_setg(errp, "failed to write index<%d>", index);
+             return;
+         }
+         serial_data = ~(s->serial);
+         if (blk_pwrite(s->blk, (index + 1) * SIFIVE_U_OTP_FUSE_WORD,
+-                       &serial_data, SIFIVE_U_OTP_FUSE_WORD, 0) < 0) {
++                       SIFIVE_U_OTP_FUSE_WORD, &serial_data, 0) < 0) {
+             error_setg(errp, "failed to write index<%d>", index + 1);
+             return;
+         }
+diff --git a/hw/nvram/eeprom_at24c.c b/hw/nvram/eeprom_at24c.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/nvram/eeprom_at24c.c
++++ b/hw/nvram/eeprom_at24c.c
+@@ -XXX,XX +XXX,XX @@ int at24c_eeprom_event(I2CSlave *s, enum i2c_event event)
+     case I2C_START_RECV:
+         DPRINTK("clear\n");
+         if (ee->blk && ee->changed) {
+-            int ret = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
++            int ret = blk_pwrite(ee->blk, 0, ee->rsize, ee->mem, 0);
+             if (ret < 0) {
+                 ERR(TYPE_AT24C_EE
+                         " : failed to write backing file\n");
+@@ -XXX,XX +XXX,XX @@ void at24c_eeprom_reset(DeviceState *state)
+     memset(ee->mem, 0, ee->rsize);
+     if (ee->blk) {
+-        int ret = blk_pread(ee->blk, 0, ee->mem, ee->rsize, 0);
++        int ret = blk_pread(ee->blk, 0, ee->rsize, ee->mem, 0);
+         if (ret < 0) {
+             ERR(TYPE_AT24C_EE
+diff --git a/hw/nvram/spapr_nvram.c b/hw/nvram/spapr_nvram.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/nvram/spapr_nvram.c
++++ b/hw/nvram/spapr_nvram.c
+@@ -XXX,XX +XXX,XX @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
+     ret = 0;
+     if (nvram->blk) {
+-        ret = blk_pwrite(nvram->blk, offset, membuf, len, 0);
++        ret = blk_pwrite(nvram->blk, offset, len, membuf, 0);
+     }
+     assert(nvram->buf);
+@@ -XXX,XX +XXX,XX @@ static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
+     }
+     if (nvram->blk) {
+-        ret = blk_pread(nvram->blk, 0, nvram->buf, nvram->size, 0);
++        ret = blk_pread(nvram->blk, 0, nvram->size, nvram->buf, 0);
+         if (ret < 0) {
+             error_setg(errp, "can't read spapr-nvram contents");
+@@ -XXX,XX +XXX,XX @@ static void postload_update_cb(void *opaque, bool running, RunState state)
+     qemu_del_vm_change_state_handler(nvram->vmstate);
+     nvram->vmstate = NULL;
+-    blk_pwrite(nvram->blk, 0, nvram->buf, nvram->size, 0);
++    blk_pwrite(nvram->blk, 0, nvram->size, nvram->buf, 0);
+ }
+ static int spapr_nvram_post_load(void *opaque, int version_id)
+diff --git a/hw/nvram/xlnx-bbram.c b/hw/nvram/xlnx-bbram.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/nvram/xlnx-bbram.c
++++ b/hw/nvram/xlnx-bbram.c
+@@ -XXX,XX +XXX,XX @@ static void bbram_bdrv_read(XlnxBBRam *s, Error **errp)
+                     blk_name(s->blk));
+     }
+-    if (blk_pread(s->blk, 0, ram, nr, 0) < 0) {
++    if (blk_pread(s->blk, 0, nr, ram, 0) < 0) {
+         error_setg(errp,
+                    "%s: Failed to read %u bytes from BBRAM backstore.",
+                    blk_name(s->blk), nr);
+@@ -XXX,XX +XXX,XX @@ static void bbram_bdrv_sync(XlnxBBRam *s, uint64_t hwaddr)
+     }
+     offset = hwaddr - A_BBRAM_0;
+-    rc = blk_pwrite(s->blk, offset, &le32, 4, 0);
++    rc = blk_pwrite(s->blk, offset, 4, &le32, 0);
+     if (rc < 0) {
+         bbram_bdrv_error(s, rc, g_strdup_printf("write to offset %u", offset));
+     }
+diff --git a/hw/nvram/xlnx-efuse.c b/hw/nvram/xlnx-efuse.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/nvram/xlnx-efuse.c
++++ b/hw/nvram/xlnx-efuse.c
+@@ -XXX,XX +XXX,XX @@ static int efuse_bdrv_read(XlnxEFuse *s, Error **errp)
+                     blk_name(s->blk));
+     }
+-    if (blk_pread(s->blk, 0, ram, nr, 0) < 0) {
++    if (blk_pread(s->blk, 0, nr, ram, 0) < 0) {
+         error_setg(errp, "%s: Failed to read %u bytes from eFUSE backstore.",
+                    blk_name(s->blk), nr);
+         return -1;
+@@ -XXX,XX +XXX,XX @@ static void efuse_bdrv_sync(XlnxEFuse *s, unsigned int bit)
+     le32 = cpu_to_le32(xlnx_efuse_get_row(s, bit));
+     row_offset = (bit / 32) * 4;
+-    if (blk_pwrite(s->blk, row_offset, &le32, 4, 0) < 0) {
++    if (blk_pwrite(s->blk, row_offset, 4, &le32, 0) < 0) {
+         error_report("%s: Failed to write offset %u of eFUSE backstore.",
+                      blk_name(s->blk), row_offset);
+     }
+diff --git a/hw/ppc/pnv_pnor.c b/hw/ppc/pnv_pnor.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/ppc/pnv_pnor.c
++++ b/hw/ppc/pnv_pnor.c
+@@ -XXX,XX +XXX,XX @@ static void pnv_pnor_update(PnvPnor *s, int offset, int size)
+     offset = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);
+     offset_end = QEMU_ALIGN_UP(offset_end, BDRV_SECTOR_SIZE);
+-    ret = blk_pwrite(s->blk, offset, s->storage + offset,
+-                     offset_end - offset, 0);
++    ret = blk_pwrite(s->blk, offset, offset_end - offset, s->storage + offset,
++                     0);
+     if (ret < 0) {
+         error_report("Could not update PNOR offset=0x%" PRIx32" : %s", offset,
+                      strerror(-ret));
+@@ -XXX,XX +XXX,XX @@ static void pnv_pnor_realize(DeviceState *dev, Error **errp)
+         s->storage = blk_blockalign(s->blk, s->size);
+-        if (blk_pread(s->blk, 0, s->storage, s->size, 0) < 0) {
++        if (blk_pread(s->blk, 0, s->size, s->storage, 0) < 0) {
+             error_setg(errp, "failed to read the initial flash content");
+             return;
+         }
+diff --git a/hw/sd/sd.c b/hw/sd/sd.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/sd/sd.c
++++ b/hw/sd/sd.c
+@@ -XXX,XX +XXX,XX @@ void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert)
+ static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len)
+ {
+     trace_sdcard_read_block(addr, len);
+-    if (!sd->blk || blk_pread(sd->blk, addr, sd->data, len, 0) < 0) {
++    if (!sd->blk || blk_pread(sd->blk, addr, len, sd->data, 0) < 0) {
+         fprintf(stderr, "sd_blk_read: read error on host side\n");
+     }
+ }
+@@ -XXX,XX +XXX,XX @@ static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len)
+ static void sd_blk_write(SDState *sd, uint64_t addr, uint32_t len)
+ {
+     trace_sdcard_write_block(addr, len);
+-    if (!sd->blk || blk_pwrite(sd->blk, addr, sd->data, len, 0) < 0) {
++    if (!sd->blk || blk_pwrite(sd->blk, addr, len, sd->data, 0) < 0) {
+         fprintf(stderr, "sd_blk_write: write error on host side\n");
+     }
+ }
+diff --git a/migration/block.c b/migration/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/migration/block.c
++++ b/migration/block.c
+@@ -XXX,XX +XXX,XX @@ static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds,
+                 blk_mig_unlock();
+             } else {
+                 ret = blk_pread(bmds->blk, sector * BDRV_SECTOR_SIZE,
+-                                blk->buf, nr_sectors * BDRV_SECTOR_SIZE, 0);
++                                nr_sectors * BDRV_SECTOR_SIZE, blk->buf, 0);
+                 if (ret < 0) {
+                     goto error;
+                 }
+@@ -XXX,XX +XXX,XX @@ static int block_load(QEMUFile *f, void *opaque, int version_id)
+                                                 cluster_size,
+                                                 BDRV_REQ_MAY_UNMAP);
+                     } else {
+-                        ret = blk_pwrite(blk, cur_addr, cur_buf,
+-                                         cluster_size, 0);
++                        ret = blk_pwrite(blk, cur_addr, cluster_size, cur_buf,
++                                         0);
+                     }
+                     if (ret < 0) {
+                         break;
+diff --git a/nbd/server.c b/nbd/server.c
+index XXXXXXX..XXXXXXX 100644
+--- a/nbd/server.c
++++ b/nbd/server.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn nbd_co_send_sparse_read(NBDClient *client,
+             stl_be_p(&chunk.length, pnum);
+             ret = nbd_co_send_iov(client, iov, 1, errp);
+         } else {
+-            ret = blk_pread(exp->common.blk, offset + progress,
+-                            data + progress, pnum, 0);
++            ret = blk_pread(exp->common.blk, offset + progress, pnum,
++                            data + progress, 0);
+             if (ret < 0) {
+                 error_setg_errno(errp, -ret, "reading from file failed");
+                 break;
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_do_cmd_read(NBDClient *client, NBDRequest *request,
+                                        data, request->len, errp);
+     }
+-    ret = blk_pread(exp->common.blk, request->from, data, request->len, 0);
++    ret = blk_pread(exp->common.blk, request->from, request->len, data, 0);
+     if (ret < 0) {
+         return nbd_send_generic_reply(client, request->handle, ret,
+                                       "reading from file failed", errp);
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_handle_request(NBDClient *client,
+         if (request->flags & NBD_CMD_FLAG_FUA) {
+             flags |= BDRV_REQ_FUA;
+         }
+-        ret = blk_pwrite(exp->common.blk, request->from, data, request->len,
++        ret = blk_pwrite(exp->common.blk, request->from, request->len, data,
+                          flags);
+         return nbd_send_generic_reply(client, request->handle, ret,
+                                       "writing to file failed", errp);
+diff --git a/qemu-img.c b/qemu-img.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-img.c
++++ b/qemu-img.c
+@@ -XXX,XX +XXX,XX @@ static int check_empty_sectors(BlockBackend *blk, int64_t offset,
+     int ret = 0;
+     int64_t idx;
+-    ret = blk_pread(blk, offset, buffer, bytes, 0);
++    ret = blk_pread(blk, offset, bytes, buffer, 0);
+     if (ret < 0) {
+         error_report("Error while reading offset %" PRId64 " of %s: %s",
+                      offset, filename, strerror(-ret));
+@@ -XXX,XX +XXX,XX @@ static int img_compare(int argc, char **argv)
+                 int64_t pnum;
+                 chunk = MIN(chunk, IO_BUF_SIZE);
+-                ret = blk_pread(blk1, offset, buf1, chunk, 0);
++                ret = blk_pread(blk1, offset, chunk, buf1, 0);
+                 if (ret < 0) {
+                     error_report("Error while reading offset %" PRId64
+                                  " of %s: %s",
+@@ -XXX,XX +XXX,XX @@ static int img_compare(int argc, char **argv)
+                     ret = 4;
+                     goto out;
+                 }
+-                ret = blk_pread(blk2, offset, buf2, chunk, 0);
++                ret = blk_pread(blk2, offset, chunk, buf2, 0);
+                 if (ret < 0) {
+                     error_report("Error while reading offset %" PRId64
+                                  " of %s: %s",
+@@ -XXX,XX +XXX,XX @@ static int img_rebase(int argc, char **argv)
+                     n = old_backing_size - offset;
+                 }
+-                ret = blk_pread(blk_old_backing, offset, buf_old, n, 0);
++                ret = blk_pread(blk_old_backing, offset, n, buf_old, 0);
+                 if (ret < 0) {
+                     error_report("error while reading from old backing file");
+                     goto out;
+@@ -XXX,XX +XXX,XX @@ static int img_rebase(int argc, char **argv)
+                     n = new_backing_size - offset;
+                 }
+-                ret = blk_pread(blk_new_backing, offset, buf_new, n, 0);
++                ret = blk_pread(blk_new_backing, offset, n, buf_new, 0);
+                 if (ret < 0) {
+                     error_report("error while reading from new backing file");
+                     goto out;
+@@ -XXX,XX +XXX,XX @@ static int img_rebase(int argc, char **argv)
+                     if (buf_old_is_zero) {
+                         ret = blk_pwrite_zeroes(blk, offset + written, pnum, 0);
+                     } else {
+-                        ret = blk_pwrite(blk, offset + written,
+-                                         buf_old + written, pnum, 0);
++                        ret = blk_pwrite(blk, offset + written, pnum,
++                                         buf_old + written, 0);
+                     }
+                     if (ret < 0) {
+                         error_report("Error while writing to COW image: %s",
+@@ -XXX,XX +XXX,XX @@ static int img_dd(int argc, char **argv)
+     for (out_pos = 0; in_pos < size; block_count++) {
+         int bytes = (in_pos + in.bsz > size) ? size - in_pos : in.bsz;
+-        ret = blk_pread(blk1, in_pos, in.buf, bytes, 0);
++        ret = blk_pread(blk1, in_pos, bytes, in.buf, 0);
+         if (ret < 0) {
+             error_report("error while reading from input image file: %s",
+                          strerror(-ret));
+@@ -XXX,XX +XXX,XX @@ static int img_dd(int argc, char **argv)
+         }
+         in_pos += bytes;
+-        ret = blk_pwrite(blk2, out_pos, in.buf, bytes, 0);
++        ret = blk_pwrite(blk2, out_pos, bytes, in.buf, 0);
+         if (ret < 0) {
+             error_report("error while writing to output image file: %s",
+                          strerror(-ret));
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-io-cmds.c
++++ b/qemu-io-cmds.c
+@@ -XXX,XX +XXX,XX @@ static int do_pread(BlockBackend *blk, char *buf, int64_t offset,
+         return -ERANGE;
+     }
+-    ret = blk_pread(blk, offset, (uint8_t *)buf, bytes, 0);
++    ret = blk_pread(blk, offset, bytes, (uint8_t *)buf, 0);
+     if (ret < 0) {
+         return ret;
+     }
+@@ -XXX,XX +XXX,XX @@ static int do_pwrite(BlockBackend *blk, char *buf, int64_t offset,
+         return -ERANGE;
+     }
+-    ret = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags);
++    ret = blk_pwrite(blk, offset, bytes, (uint8_t *)buf, flags);
+     if (ret < 0) {
+         return ret;
+     }
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pread(BlockBackend *blk)
+     int ret;
+     /* Success */
+-    ret = blk_pread(blk, 0, buf, sizeof(buf), 0);
++    ret = blk_pread(blk, 0, sizeof(buf), buf, 0);
+     g_assert_cmpint(ret, ==, 0);
+     /* Early error: Negative offset */
+-    ret = blk_pread(blk, -2, buf, sizeof(buf), 0);
++    ret = blk_pread(blk, -2, sizeof(buf), buf, 0);
+     g_assert_cmpint(ret, ==, -EIO);
+ }
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwrite(BlockBackend *blk)
+     int ret;
+     /* Success */
+-    ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
++    ret = blk_pwrite(blk, 0, sizeof(buf), buf, 0);
+     g_assert_cmpint(ret, ==, 0);
+     /* Early error: Negative offset */
+-    ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);
++    ret = blk_pwrite(blk, -2, sizeof(buf), buf, 0);
+     g_assert_cmpint(ret, ==, -EIO);
+ }
+--
+.35.3

-New patch
+[PULL 16/35] block: Make 'bytes' param of blk_{pread, pwrite}() an int64_t
+From: Alberto Faria <afaria@redhat.com>
+For consistency with other I/O functions, and in preparation to
+implement them using generated_co_wrapper.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-5-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/sysemu/block-backend-io.h | 6 +++---
+ block/block-backend.c             | 6 +++---
+files changed, 6 insertions(+), 6 deletions(-)
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
+  * the "I/O or GS" API.
+  */
+-int blk_pread(BlockBackend *blk, int64_t offset, int bytes, void *buf,
++int blk_pread(BlockBackend *blk, int64_t offset, int64_t bytes, void *buf,
+               BdrvRequestFlags flags);
+-int blk_pwrite(BlockBackend *blk, int64_t offset, int bytes, const void *buf,
+-               BdrvRequestFlags flags);
++int blk_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
++               const void *buf, BdrvRequestFlags flags);
+ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
+                                int64_t bytes, QEMUIOVector *qiov,
+                                BdrvRequestFlags flags);
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                         flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
+ }
+-int blk_pread(BlockBackend *blk, int64_t offset, int bytes, void *buf,
++int blk_pread(BlockBackend *blk, int64_t offset, int64_t bytes, void *buf,
+               BdrvRequestFlags flags)
+ {
+     int ret;
+@@ -XXX,XX +XXX,XX @@ int blk_pread(BlockBackend *blk, int64_t offset, int bytes, void *buf,
+     return ret;
+ }
+-int blk_pwrite(BlockBackend *blk, int64_t offset, int bytes, const void *buf,
+-               BdrvRequestFlags flags)
++int blk_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
++               const void *buf, BdrvRequestFlags flags)
+ {
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+     IO_OR_GS_CODE();
+--
+.35.3

-New patch
+[PULL 17/35] block: Make blk_co_pwrite() take a const buffer
+From: Alberto Faria <afaria@redhat.com>
+It does not mutate the buffer.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-6-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/sysemu/block-backend-io.h | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ static inline int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset,
+ }
+ static inline int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset,
+-                                             int64_t bytes, void *buf,
++                                             int64_t bytes, const void *buf,
+                                              BdrvRequestFlags flags)
+ {
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+--
+.35.3

-New patch
+[PULL 18/35] block: Implement blk_{pread, pwrite}() using generated_co_wrapper
+From: Alberto Faria <afaria@redhat.com>
+We need to add include/sysemu/block-backend-io.h to the inputs of the
+block-gen.c target defined in block/meson.build.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-7-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/coroutines.h                |  4 ----
+ include/sysemu/block-backend-io.h | 10 ++++++----
+ block/block-backend.c             | 23 -----------------------
+ block/meson.build                 |  1 +
+files changed, 7 insertions(+), 31 deletions(-)
+diff --git a/block/coroutines.h b/block/coroutines.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/coroutines.h
++++ b/block/coroutines.h
+@@ -XXX,XX +XXX,XX @@ bdrv_common_block_status_above(BlockDriverState *bs,
+ int generated_co_wrapper
+ nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
+-int generated_co_wrapper
+-blk_do_preadv(BlockBackend *blk, int64_t offset, int64_t bytes,
+-              QEMUIOVector *qiov, BdrvRequestFlags flags);
+-
+ int generated_co_wrapper
+ blk_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
+                     QEMUIOVector *qiov, size_t qiov_offset,
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
+  * the "I/O or GS" API.
+  */
+-int blk_pread(BlockBackend *blk, int64_t offset, int64_t bytes, void *buf,
+-              BdrvRequestFlags flags);
+-int blk_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
+-               const void *buf, BdrvRequestFlags flags);
++int generated_co_wrapper blk_pread(BlockBackend *blk, int64_t offset,
++                                   int64_t bytes, void *buf,
++                                   BdrvRequestFlags flags);
++int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
++                                    int64_t bytes, const void *buf,
++                                    BdrvRequestFlags flags);
+ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
+                                int64_t bytes, QEMUIOVector *qiov,
+                                BdrvRequestFlags flags);
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                         flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
+ }
+-int blk_pread(BlockBackend *blk, int64_t offset, int64_t bytes, void *buf,
+-              BdrvRequestFlags flags)
+-{
+-    int ret;
+-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+-    IO_OR_GS_CODE();
+-
+-    blk_inc_in_flight(blk);
+-    ret = blk_do_preadv(blk, offset, bytes, &qiov, flags);
+-    blk_dec_in_flight(blk);
+-
+-    return ret;
+-}
+-
+-int blk_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
+-               const void *buf, BdrvRequestFlags flags)
+-{
+-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+-    IO_OR_GS_CODE();
+-
+-    return blk_pwritev_part(blk, offset, bytes, &qiov, 0, flags);
+-}
+-
+ int64_t blk_getlength(BlockBackend *blk)
+ {
+     IO_CODE();
+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_gen_c = custom_target('block-gen.c',
+                             input: files(
+                                       '../include/block/block-io.h',
+                                       '../include/block/block-global-state.h',
++                                      '../include/sysemu/block-backend-io.h',
+                                       'coroutines.h'
+                                       ),
+                             command: [wrapper_py, '@OUTPUT@', '@INPUT@'])
+--
+.35.3

-New patch
+[PULL 19/35] block: Add blk_{preadv,pwritev}()
+From: Alberto Faria <afaria@redhat.com>
+Implement them using generated_co_wrapper.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-8-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/sysemu/block-backend-io.h |  6 +++++
+ tests/unit/test-block-iothread.c  | 42 ++++++++++++++++++++++++++++++-
+files changed, 47 insertions(+), 1 deletion(-)
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_pread(BlockBackend *blk, int64_t offset,
+ int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
+                                     int64_t bytes, const void *buf,
+                                     BdrvRequestFlags flags);
++int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
++                                    int64_t bytes, QEMUIOVector *qiov,
++                                    BdrvRequestFlags flags);
+ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
+                                int64_t bytes, QEMUIOVector *qiov,
+                                BdrvRequestFlags flags);
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
+                                      int64_t bytes,
+                                      QEMUIOVector *qiov, size_t qiov_offset,
+                                      BdrvRequestFlags flags);
++int generated_co_wrapper blk_pwritev(BlockBackend *blk, int64_t offset,
++                                     int64_t bytes, QEMUIOVector *qiov,
++                                     BdrvRequestFlags flags);
+ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
+                                 int64_t bytes, QEMUIOVector *qiov,
+                                 BdrvRequestFlags flags);
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwrite(BlockBackend *blk)
+     g_assert_cmpint(ret, ==, -EIO);
+ }
++static void test_sync_op_blk_preadv(BlockBackend *blk)
++{
++    uint8_t buf[512];
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, sizeof(buf));
++    int ret;
++
++    /* Success */
++    ret = blk_preadv(blk, 0, sizeof(buf), &qiov, 0);
++    g_assert_cmpint(ret, ==, 0);
++
++    /* Early error: Negative offset */
++    ret = blk_preadv(blk, -2, sizeof(buf), &qiov, 0);
++    g_assert_cmpint(ret, ==, -EIO);
++}
++
++static void test_sync_op_blk_pwritev(BlockBackend *blk)
++{
++    uint8_t buf[512] = { 0 };
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, sizeof(buf));
++    int ret;
++
++    /* Success */
++    ret = blk_pwritev(blk, 0, sizeof(buf), &qiov, 0);
++    g_assert_cmpint(ret, ==, 0);
++
++    /* Early error: Negative offset */
++    ret = blk_pwritev(blk, -2, sizeof(buf), &qiov, 0);
++    g_assert_cmpint(ret, ==, -EIO);
++}
++
+ static void test_sync_op_load_vmstate(BdrvChild *c)
+ {
+     uint8_t buf[512];
+@@ -XXX,XX +XXX,XX @@ const SyncOpTest sync_op_tests[] = {
+         .name   = "/sync-op/pwrite",
+         .fn     = test_sync_op_pwrite,
+         .blkfn  = test_sync_op_blk_pwrite,
++    }, {
++        .name   = "/sync-op/preadv",
++        .fn     = NULL,
++        .blkfn  = test_sync_op_blk_preadv,
++    }, {
++        .name   = "/sync-op/pwritev",
++        .fn     = NULL,
++        .blkfn  = test_sync_op_blk_pwritev,
+     }, {
+         .name   = "/sync-op/load_vmstate",
+         .fn     = test_sync_op_load_vmstate,
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op(const void *opaque)
+     blk_set_aio_context(blk, ctx, &error_abort);
+     aio_context_acquire(ctx);
+-    t->fn(c);
++    if (t->fn) {
++        t->fn(c);
++    }
+     if (t->blkfn) {
+         t->blkfn(blk);
+     }
+--
+.35.3

-New patch
+[PULL 20/35] block: Add blk_[co_]preadv_part()
+From: Alberto Faria <afaria@redhat.com>
+Implement blk_preadv_part() using generated_co_wrapper.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-9-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/coroutines.h                |  5 -----
+ include/sysemu/block-backend-io.h |  7 +++++++
+ block/block-backend.c             | 30 +++++++++++++++++++++++-------
+ tests/unit/test-block-iothread.c  | 19 +++++++++++++++++++
+files changed, 49 insertions(+), 12 deletions(-)
+diff --git a/block/coroutines.h b/block/coroutines.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/coroutines.h
++++ b/block/coroutines.h
+@@ -XXX,XX +XXX,XX @@ nbd_co_do_establish_connection(BlockDriverState *bs, bool blocking,
+                                Error **errp);
+-int coroutine_fn
+-blk_co_do_preadv(BlockBackend *blk, int64_t offset, int64_t bytes,
+-                 QEMUIOVector *qiov, BdrvRequestFlags flags);
+-
+-
+ int coroutine_fn
+ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
+                        QEMUIOVector *qiov, size_t qiov_offset,
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_pread(BlockBackend *blk, int64_t offset,
+ int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
+                                     int64_t bytes, const void *buf,
+                                     BdrvRequestFlags flags);
++int generated_co_wrapper blk_preadv_part(BlockBackend *blk, int64_t offset,
++                                         int64_t bytes, QEMUIOVector *qiov,
++                                         size_t qiov_offset,
++                                         BdrvRequestFlags flags);
++int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
++                                    int64_t bytes, QEMUIOVector *qiov,
++                                    size_t qiov_offset, BdrvRequestFlags flags);
+ int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
+                                     int64_t bytes, QEMUIOVector *qiov,
+                                     BdrvRequestFlags flags);
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
+ }
+ /* To be called between exactly one pair of blk_inc/dec_in_flight() */
+-int coroutine_fn
+-blk_co_do_preadv(BlockBackend *blk, int64_t offset, int64_t bytes,
+-                 QEMUIOVector *qiov, BdrvRequestFlags flags)
++static int coroutine_fn
++blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
++                      QEMUIOVector *qiov, size_t qiov_offset,
++                      BdrvRequestFlags flags)
+ {
+     int ret;
+     BlockDriverState *bs;
+@@ -XXX,XX +XXX,XX @@ blk_co_do_preadv(BlockBackend *blk, int64_t offset, int64_t bytes,
+                 bytes, false);
+     }
+-    ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags);
++    ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
++                              flags);
+     bdrv_dec_in_flight(bs);
+     return ret;
+ }
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
+     IO_OR_GS_CODE();
+     blk_inc_in_flight(blk);
+-    ret = blk_co_do_preadv(blk, offset, bytes, qiov, flags);
++    ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, 0, flags);
++    blk_dec_in_flight(blk);
++
++    return ret;
++}
++
++int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
++                                    int64_t bytes, QEMUIOVector *qiov,
++                                    size_t qiov_offset, BdrvRequestFlags flags)
++{
++    int ret;
++    IO_OR_GS_CODE();
++
++    blk_inc_in_flight(blk);
++    ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, qiov_offset, flags);
+     blk_dec_in_flight(blk);
+     return ret;
+@@ -XXX,XX +XXX,XX @@ static void blk_aio_read_entry(void *opaque)
+     QEMUIOVector *qiov = rwco->iobuf;
+     assert(qiov->size == acb->bytes);
+-    rwco->ret = blk_co_do_preadv(rwco->blk, rwco->offset, acb->bytes,
+-                                 qiov, rwco->flags);
++    rwco->ret = blk_co_do_preadv_part(rwco->blk, rwco->offset, acb->bytes, qiov,
++                                      0, rwco->flags);
+     blk_aio_complete(acb);
+ }
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwritev(BlockBackend *blk)
+     g_assert_cmpint(ret, ==, -EIO);
+ }
++static void test_sync_op_blk_preadv_part(BlockBackend *blk)
++{
++    uint8_t buf[512];
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, sizeof(buf));
++    int ret;
++
++    /* Success */
++    ret = blk_preadv_part(blk, 0, sizeof(buf), &qiov, 0, 0);
++    g_assert_cmpint(ret, ==, 0);
++
++    /* Early error: Negative offset */
++    ret = blk_preadv_part(blk, -2, sizeof(buf), &qiov, 0, 0);
++    g_assert_cmpint(ret, ==, -EIO);
++}
++
+ static void test_sync_op_load_vmstate(BdrvChild *c)
+ {
+     uint8_t buf[512];
+@@ -XXX,XX +XXX,XX @@ const SyncOpTest sync_op_tests[] = {
+         .name   = "/sync-op/pwritev",
+         .fn     = NULL,
+         .blkfn  = test_sync_op_blk_pwritev,
++    }, {
++        .name   = "/sync-op/preadv_part",
++        .fn     = NULL,
++        .blkfn  = test_sync_op_blk_preadv_part,
+     }, {
+         .name   = "/sync-op/load_vmstate",
+         .fn     = test_sync_op_load_vmstate,
+--
+.35.3

-New patch
+[PULL 21/35] block: Export blk_pwritev_part() in block-backend-io.h
+From: Alberto Faria <afaria@redhat.com>
+Also convert it into a generated_co_wrapper.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-10-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/coroutines.h                |  5 -----
+ include/sysemu/block-backend-io.h |  4 ++++
+ block/block-backend.c             | 14 --------------
+ tests/unit/test-block-iothread.c  | 19 +++++++++++++++++++
+files changed, 23 insertions(+), 19 deletions(-)
+diff --git a/block/coroutines.h b/block/coroutines.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/coroutines.h
++++ b/block/coroutines.h
+@@ -XXX,XX +XXX,XX @@ bdrv_common_block_status_above(BlockDriverState *bs,
+ int generated_co_wrapper
+ nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
+-int generated_co_wrapper
+-blk_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
+-                    QEMUIOVector *qiov, size_t qiov_offset,
+-                    BdrvRequestFlags flags);
+-
+ int generated_co_wrapper
+ blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
+ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
+                                int64_t bytes, QEMUIOVector *qiov,
+                                BdrvRequestFlags flags);
++int generated_co_wrapper blk_pwritev_part(BlockBackend *blk, int64_t offset,
++                                          int64_t bytes, QEMUIOVector *qiov,
++                                          size_t qiov_offset,
++                                          BdrvRequestFlags flags);
+ int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
+                                      int64_t bytes,
+                                      QEMUIOVector *qiov, size_t qiov_offset,
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
+     return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags);
+ }
+-static int coroutine_fn blk_pwritev_part(BlockBackend *blk, int64_t offset,
+-                                         int64_t bytes,
+-                                         QEMUIOVector *qiov, size_t qiov_offset,
+-                                         BdrvRequestFlags flags)
+-{
+-    int ret;
+-
+-    blk_inc_in_flight(blk);
+-    ret = blk_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags);
+-    blk_dec_in_flight(blk);
+-
+-    return ret;
+-}
+-
+ typedef struct BlkRwCo {
+     BlockBackend *blk;
+     int64_t offset;
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_preadv_part(BlockBackend *blk)
+     g_assert_cmpint(ret, ==, -EIO);
+ }
++static void test_sync_op_blk_pwritev_part(BlockBackend *blk)
++{
++    uint8_t buf[512] = { 0 };
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, sizeof(buf));
++    int ret;
++
++    /* Success */
++    ret = blk_pwritev_part(blk, 0, sizeof(buf), &qiov, 0, 0);
++    g_assert_cmpint(ret, ==, 0);
++
++    /* Early error: Negative offset */
++    ret = blk_pwritev_part(blk, -2, sizeof(buf), &qiov, 0, 0);
++    g_assert_cmpint(ret, ==, -EIO);
++}
++
+ static void test_sync_op_load_vmstate(BdrvChild *c)
+ {
+     uint8_t buf[512];
+@@ -XXX,XX +XXX,XX @@ const SyncOpTest sync_op_tests[] = {
+         .name   = "/sync-op/preadv_part",
+         .fn     = NULL,
+         .blkfn  = test_sync_op_blk_preadv_part,
++    }, {
++        .name   = "/sync-op/pwritev_part",
++        .fn     = NULL,
++        .blkfn  = test_sync_op_blk_pwritev_part,
+     }, {
+         .name   = "/sync-op/load_vmstate",
+         .fn     = test_sync_op_load_vmstate,
+--
+.35.3

-New patch
+[PULL 22/35] block: Change blk_pwrite_compressed() param order
+From: Alberto Faria <afaria@redhat.com>
+Swap 'buf' and 'bytes' around for consistency with other I/O functions.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-11-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/sysemu/block-backend-io.h | 4 ++--
+ block/block-backend.c             | 4 ++--
+ qemu-img.c                        | 2 +-
+ qemu-io-cmds.c                    | 2 +-
+files changed, 6 insertions(+), 6 deletions(-)
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int blk_flush(BlockBackend *blk);
+ int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+-int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
+-                          int64_t bytes);
++int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, int64_t bytes,
++                          const void *buf);
+ int blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
+ int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                       int64_t bytes, BdrvRequestFlags flags);
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                           flags | BDRV_REQ_ZERO_WRITE);
+ }
+-int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
+-                          int64_t bytes)
++int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, int64_t bytes,
++                          const void *buf)
+ {
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+     IO_OR_GS_CODE();
+diff --git a/qemu-img.c b/qemu-img.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-img.c
++++ b/qemu-img.c
+@@ -XXX,XX +XXX,XX @@ static int convert_do_copy(ImgConvertState *s)
+     if (s->compressed && !s->ret) {
+         /* signal EOF to align */
+-        ret = blk_pwrite_compressed(s->target, 0, NULL, 0);
++        ret = blk_pwrite_compressed(s->target, 0, 0, NULL);
+         if (ret < 0) {
+             return ret;
+         }
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-io-cmds.c
++++ b/qemu-io-cmds.c
+@@ -XXX,XX +XXX,XX @@ static int do_write_compressed(BlockBackend *blk, char *buf, int64_t offset,
+         return -ERANGE;
+     }
+-    ret = blk_pwrite_compressed(blk, offset, buf, bytes);
++    ret = blk_pwrite_compressed(blk, offset, bytes, buf);
+     if (ret < 0) {
+         return ret;
+     }
+--
+.35.3

-New patch
+[PULL 23/35] block: Add blk_co_pwrite_compressed()
+From: Alberto Faria <afaria@redhat.com>
+Also convert blk_pwrite_compressed() into a generated_co_wrapper.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-12-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/sysemu/block-backend-io.h |  7 +++++--
+ block/block-backend.c             |  8 ++++----
+ tests/unit/test-block-iothread.c  | 18 ++++++++++++++++++
+files changed, 27 insertions(+), 6 deletions(-)
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int blk_flush(BlockBackend *blk);
+ int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+-int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, int64_t bytes,
+-                          const void *buf);
++int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
++                                               int64_t offset, int64_t bytes,
++                                               const void *buf);
++int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
++                                          int64_t bytes, const void *buf);
+ int blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
+ int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                       int64_t bytes, BdrvRequestFlags flags);
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                           flags | BDRV_REQ_ZERO_WRITE);
+ }
+-int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, int64_t bytes,
+-                          const void *buf)
++int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
++                                          int64_t bytes, const void *buf)
+ {
+     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+     IO_OR_GS_CODE();
+-    return blk_pwritev_part(blk, offset, bytes, &qiov, 0,
+-                            BDRV_REQ_WRITE_COMPRESSED);
++    return blk_co_pwritev_part(blk, offset, bytes, &qiov, 0,
++                               BDRV_REQ_WRITE_COMPRESSED);
+ }
+ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwritev_part(BlockBackend *blk)
+     g_assert_cmpint(ret, ==, -EIO);
+ }
++static void test_sync_op_blk_pwrite_compressed(BlockBackend *blk)
++{
++    uint8_t buf[512] = { 0 };
++    int ret;
++
++    /* Late error: Not supported */
++    ret = blk_pwrite_compressed(blk, 0, sizeof(buf), buf);
++    g_assert_cmpint(ret, ==, -ENOTSUP);
++
++    /* Early error: Negative offset */
++    ret = blk_pwrite_compressed(blk, -2, sizeof(buf), buf);
++    g_assert_cmpint(ret, ==, -EIO);
++}
++
+ static void test_sync_op_load_vmstate(BdrvChild *c)
+ {
+     uint8_t buf[512];
+@@ -XXX,XX +XXX,XX @@ const SyncOpTest sync_op_tests[] = {
+         .name   = "/sync-op/pwritev_part",
+         .fn     = NULL,
+         .blkfn  = test_sync_op_blk_pwritev_part,
++    }, {
++        .name   = "/sync-op/pwrite_compressed",
++        .fn     = NULL,
++        .blkfn  = test_sync_op_blk_pwrite_compressed,
+     }, {
+         .name   = "/sync-op/load_vmstate",
+         .fn     = test_sync_op_load_vmstate,
+--
+.35.3

-New patch
+[PULL 24/35] block: Implement blk_pwrite_zeroes() using generated_co_wrapper
+From: Alberto Faria <afaria@redhat.com>
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-13-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/sysemu/block-backend-io.h |  5 +++--
+ block/block-backend.c             |  8 --------
+ tests/unit/test-block-iothread.c  | 17 +++++++++++++++++
+files changed, 20 insertions(+), 10 deletions(-)
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
+ int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
+                                           int64_t bytes, const void *buf);
+ int blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
+-int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+-                      int64_t bytes, BdrvRequestFlags flags);
++int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
++                                           int64_t bytes,
++                                           BdrvRequestFlags flags);
+ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                                       int64_t bytes, BdrvRequestFlags flags);
+ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ typedef struct BlkRwCo {
+     BdrvRequestFlags flags;
+ } BlkRwCo;
+-int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+-                      int64_t bytes, BdrvRequestFlags flags)
+-{
+-    IO_OR_GS_CODE();
+-    return blk_pwritev_part(blk, offset, bytes, NULL, 0,
+-                            flags | BDRV_REQ_ZERO_WRITE);
+-}
+-
+ int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
+ {
+     GLOBAL_STATE_CODE();
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwrite_compressed(BlockBackend *blk)
+     g_assert_cmpint(ret, ==, -EIO);
+ }
++static void test_sync_op_blk_pwrite_zeroes(BlockBackend *blk)
++{
++    int ret;
++
++    /* Success */
++    ret = blk_pwrite_zeroes(blk, 0, 512, 0);
++    g_assert_cmpint(ret, ==, 0);
++
++    /* Early error: Negative offset */
++    ret = blk_pwrite_zeroes(blk, -2, 512, 0);
++    g_assert_cmpint(ret, ==, -EIO);
++}
++
+ static void test_sync_op_load_vmstate(BdrvChild *c)
+ {
+     uint8_t buf[512];
+@@ -XXX,XX +XXX,XX @@ const SyncOpTest sync_op_tests[] = {
+         .name   = "/sync-op/pwrite_compressed",
+         .fn     = NULL,
+         .blkfn  = test_sync_op_blk_pwrite_compressed,
++    }, {
++        .name   = "/sync-op/pwrite_zeroes",
++        .fn     = NULL,
++        .blkfn  = test_sync_op_blk_pwrite_zeroes,
+     }, {
+         .name   = "/sync-op/load_vmstate",
+         .fn     = test_sync_op_load_vmstate,
+--
+.35.3

-New patch
+[PULL 25/35] block: Implement blk_pdiscard() using generated_co_wrapper
+From: Alberto Faria <afaria@redhat.com>
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-14-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/coroutines.h                |  3 ---
+ include/sysemu/block-backend-io.h |  3 ++-
+ block/block-backend.c             | 12 ------------
+files changed, 2 insertions(+), 16 deletions(-)
+diff --git a/block/coroutines.h b/block/coroutines.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/coroutines.h
++++ b/block/coroutines.h
+@@ -XXX,XX +XXX,XX @@ nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
+ int generated_co_wrapper
+ blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+-int generated_co_wrapper
+-blk_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
+-
+ int generated_co_wrapper blk_do_flush(BlockBackend *blk);
+ #endif /* BLOCK_COROUTINES_H */
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ static inline int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset,
+     return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
+ }
++int generated_co_wrapper blk_pdiscard(BlockBackend *blk, int64_t offset,
++                                      int64_t bytes);
+ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
+                                  int64_t bytes);
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
+                                                const void *buf);
+ int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
+                                           int64_t bytes, const void *buf);
+-int blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
+ int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                                            int64_t bytes,
+                                            BdrvRequestFlags flags);
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
+     return ret;
+ }
+-int blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
+-{
+-    int ret;
+-    IO_OR_GS_CODE();
+-
+-    blk_inc_in_flight(blk);
+-    ret = blk_do_pdiscard(blk, offset, bytes);
+-    blk_dec_in_flight(blk);
+-
+-    return ret;
+-}
+-
+ /* To be called between exactly one pair of blk_inc/dec_in_flight() */
+ int coroutine_fn blk_co_do_flush(BlockBackend *blk)
+ {
+--
+.35.3

-New patch
+[PULL 26/35] block: Implement blk_flush() using generated_co_wrapper
+From: Alberto Faria <afaria@redhat.com>
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-15-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/coroutines.h                |  2 --
+ include/sysemu/block-backend-io.h |  2 +-
+ block/block-backend.c             | 11 -----------
+files changed, 1 insertion(+), 14 deletions(-)
+diff --git a/block/coroutines.h b/block/coroutines.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/coroutines.h
++++ b/block/coroutines.h
+@@ -XXX,XX +XXX,XX @@ nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
+ int generated_co_wrapper
+ blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+-int generated_co_wrapper blk_do_flush(BlockBackend *blk);
+-
+ #endif /* BLOCK_COROUTINES_H */
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_pdiscard(BlockBackend *blk, int64_t offset,
+ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
+                                  int64_t bytes);
++int generated_co_wrapper blk_flush(BlockBackend *blk);
+ int coroutine_fn blk_co_flush(BlockBackend *blk);
+-int blk_flush(BlockBackend *blk);
+ int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_flush(BlockBackend *blk)
+     return ret;
+ }
+-int blk_flush(BlockBackend *blk)
+-{
+-    int ret;
+-
+-    blk_inc_in_flight(blk);
+-    ret = blk_do_flush(blk);
+-    blk_dec_in_flight(blk);
+-
+-    return ret;
+-}
+-
+ void blk_drain(BlockBackend *blk)
+ {
+     BlockDriverState *bs = blk_bs(blk);
+--
+.35.3

-New patch
+[PULL 27/35] block: Add blk_co_ioctl()
+From: Alberto Faria <afaria@redhat.com>
+Also convert blk_ioctl() into a generated_co_wrapper.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-16-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/coroutines.h                | 6 ------
+ include/sysemu/block-backend-io.h | 5 ++++-
+ block/block-backend.c             | 7 ++++---
+files changed, 8 insertions(+), 10 deletions(-)
+diff --git a/block/coroutines.h b/block/coroutines.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/coroutines.h
++++ b/block/coroutines.h
+@@ -XXX,XX +XXX,XX @@ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
+                        QEMUIOVector *qiov, size_t qiov_offset,
+                        BdrvRequestFlags flags);
+-int coroutine_fn
+-blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+-
+ int coroutine_fn
+ blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
+@@ -XXX,XX +XXX,XX @@ bdrv_common_block_status_above(BlockDriverState *bs,
+ int generated_co_wrapper
+ nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
+-int generated_co_wrapper
+-blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+-
+ #endif /* BLOCK_COROUTINES_H */
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
+ int generated_co_wrapper blk_flush(BlockBackend *blk);
+ int coroutine_fn blk_co_flush(BlockBackend *blk);
+-int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
++int generated_co_wrapper blk_ioctl(BlockBackend *blk, unsigned long int req,
++                                   void *buf);
++int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
++                              void *buf);
+ int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
+                                                int64_t offset, int64_t bytes,
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ void blk_aio_cancel_async(BlockAIOCB *acb)
+ }
+ /* To be called between exactly one pair of blk_inc/dec_in_flight() */
+-int coroutine_fn
++static int coroutine_fn
+ blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
+ {
+     IO_CODE();
+@@ -XXX,XX +XXX,XX @@ blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
+     return bdrv_co_ioctl(blk_bs(blk), req, buf);
+ }
+-int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
++int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
++                              void *buf)
+ {
+     int ret;
+     IO_OR_GS_CODE();
+     blk_inc_in_flight(blk);
+-    ret = blk_do_ioctl(blk, req, buf);
++    ret = blk_co_do_ioctl(blk, req, buf);
+     blk_dec_in_flight(blk);
+     return ret;
+--
+.35.3

-New patch
+[PULL 28/35] block: Add blk_co_truncate()
+From: Alberto Faria <afaria@redhat.com>
+Also convert blk_truncate() into a generated_co_wrapper.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-17-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ include/sysemu/block-backend-io.h |  8 ++++++--
+ block/block-backend.c             |  7 ++++---
+ tests/unit/test-block-iothread.c  | 14 ++++++++++++++
+files changed, 24 insertions(+), 5 deletions(-)
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/block-backend-io.h
++++ b/include/sysemu/block-backend-io.h
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                                            BdrvRequestFlags flags);
+ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+                                       int64_t bytes, BdrvRequestFlags flags);
+-int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
+-                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
++int generated_co_wrapper blk_truncate(BlockBackend *blk, int64_t offset,
++                                      bool exact, PreallocMode prealloc,
++                                      BdrvRequestFlags flags, Error **errp);
++int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
++                                 PreallocMode prealloc, BdrvRequestFlags flags,
++                                 Error **errp);
+ #endif /* BLOCK_BACKEND_IO_H */
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
+                                BDRV_REQ_WRITE_COMPRESSED);
+ }
+-int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
+-                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
++int coroutine_fn blk_co_truncate(BlockBackend *blk, int64_t offset, bool exact,
++                                 PreallocMode prealloc, BdrvRequestFlags flags,
++                                 Error **errp)
+ {
+     IO_OR_GS_CODE();
+     if (!blk_is_available(blk)) {
+@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
+         return -ENOMEDIUM;
+     }
+-    return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
++    return bdrv_co_truncate(blk->root, offset, exact, prealloc, flags, errp);
+ }
+ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c)
+     c->bs->open_flags |= BDRV_O_RDWR;
+ }
++static void test_sync_op_blk_truncate(BlockBackend *blk)
++{
++    int ret;
++
++    /* Normal success path */
++    ret = blk_truncate(blk, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
++    g_assert_cmpint(ret, ==, 0);
++
++    /* Early error: Negative offset */
++    ret = blk_truncate(blk, -2, false, PREALLOC_MODE_OFF, 0, NULL);
++    g_assert_cmpint(ret, ==, -EINVAL);
++}
++
+ static void test_sync_op_block_status(BdrvChild *c)
+ {
+     int ret;
+@@ -XXX,XX +XXX,XX @@ const SyncOpTest sync_op_tests[] = {
+     }, {
+         .name   = "/sync-op/truncate",
+         .fn     = test_sync_op_truncate,
++        .blkfn  = test_sync_op_blk_truncate,
+     }, {
+         .name   = "/sync-op/block_status",
+         .fn     = test_sync_op_block_status,
+--
+.35.3

-[PULL 2/3] util/main-loop: Introduce the main loop into QOM
+[PULL 29/35] block: Reorganize some declarations in block-backend-io.h
-From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
+From: Alberto Faria <afaria@redhat.com>
-'event-loop-base' provides basic property handling for all 'AioContext'
+Keep generated_co_wrapper and coroutine_fn pairs together. This should
-based event loops. So let's define a new 'MainLoopClass' that inherits
+make it clear that each I/O function has these two versions.
 from it. This will permit tweaking the main loop's properties through
 qapi as well as through the command line using the '-object' keyword[1].
 Only one instance of 'MainLoopClass' might be created at any time.
-'EventLoopBaseClass' learns a new callback, 'can_be_deleted()' so as to
+Also move blk_co_{pread,pwrite}()'s implementations out of the header
-mark 'MainLoop' as non-deletable.
+file for consistency.
-[1] For example:
+Signed-off-by: Alberto Faria <afaria@redhat.com>
-      -object main-loop,id=main-loop,aio-max-batch=<value>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
 Message-Id: <20220705161527.1054072-18-afaria@redhat.com>
 Reviewed-by: Hanna Reitz <hreitz@redhat.com>
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 ---
  include/sysemu/block-backend-io.h | 77 +++++++++++++------------------
  block/block-backend.c             | 22 +++++++++
 files changed, 54 insertions(+), 45 deletions(-)
-Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Message-id: 20220425075723.20019-3-nsaenzju@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  qapi/qom.json                    | 13 ++++++++
  meson.build                      |  3 +-
  include/qemu/main-loop.h         | 10 ++++++
  include/sysemu/event-loop-base.h |  1 +
  event-loop-base.c                | 13 ++++++++
  util/main-loop.c                 | 56 ++++++++++++++++++++++++++++++++
 files changed, 95 insertions(+), 1 deletion(-)
 diff --git a/qapi/qom.json b/qapi/qom.json
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/qom.json
+--- a/include/sysemu/block-backend-io.h
-+++ b/qapi/qom.json
++++ b/include/sysemu/block-backend-io.h
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
-             '*poll-grow': 'int',
+ int generated_co_wrapper blk_pread(BlockBackend *blk, int64_t offset,
-             '*poll-shrink': 'int' } }
+                                    int64_t bytes, void *buf,
+                                    BdrvRequestFlags flags);
-+##
+-int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
-+# @MainLoopProperties:
+-                                    int64_t bytes, const void *buf,
-+#
++int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
-+# Properties for the main-loop object.
++                              void *buf, BdrvRequestFlags flags);
 +#
 +# Since: 7.1
 +##
 +{ 'struct': 'MainLoopProperties',
 +  'base': 'EventLoopBaseProperties',
 +  'data': {} }
 +
- ##
++int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
- # @MemoryBackendProperties:
++                                    int64_t bytes, QEMUIOVector *qiov,
- #
+                                     BdrvRequestFlags flags);
-@@ -XXX,XX +XXX,XX @@
++int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
-     { 'name': 'input-linux',
++                               int64_t bytes, QEMUIOVector *qiov,
-       'if': 'CONFIG_LINUX' },
++                               BdrvRequestFlags flags);
-     'iothread',
++
-+    'main-loop',
+ int generated_co_wrapper blk_preadv_part(BlockBackend *blk, int64_t offset,
-     { 'name': 'memory-backend-epc',
+                                          int64_t bytes, QEMUIOVector *qiov,
-       'if': 'CONFIG_LINUX' },
+                                          size_t qiov_offset,
-     'memory-backend-file',
+@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_preadv_part(BlockBackend *blk, int64_t offset,
-@@ -XXX,XX +XXX,XX @@
+ int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
-       'input-linux':                { 'type': 'InputLinuxProperties',
+                                     int64_t bytes, QEMUIOVector *qiov,
-                                       'if': 'CONFIG_LINUX' },
+                                     size_t qiov_offset, BdrvRequestFlags flags);
-       'iothread':                   'IothreadProperties',
+-int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
-+      'main-loop':                  'MainLoopProperties',
+-                                    int64_t bytes, QEMUIOVector *qiov,
-       'memory-backend-epc':         { 'type': 'MemoryBackendEpcProperties',
++
-                                       'if': 'CONFIG_LINUX' },
++int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
-       'memory-backend-file':        'MemoryBackendFileProperties',
++                                    int64_t bytes, const void *buf,
-diff --git a/meson.build b/meson.build
+                                     BdrvRequestFlags flags);
 -int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
 -                               int64_t bytes, QEMUIOVector *qiov,
 -                               BdrvRequestFlags flags);
 +int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
 +                               const void *buf, BdrvRequestFlags flags);
 +
 +int generated_co_wrapper blk_pwritev(BlockBackend *blk, int64_t offset,
 +                                     int64_t bytes, QEMUIOVector *qiov,
 +                                     BdrvRequestFlags flags);
 +int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
 +                                int64_t bytes, QEMUIOVector *qiov,
 +                                BdrvRequestFlags flags);
 +
  int generated_co_wrapper blk_pwritev_part(BlockBackend *blk, int64_t offset,
                                            int64_t bytes, QEMUIOVector *qiov,
                                            size_t qiov_offset,
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
                                       int64_t bytes,
                                       QEMUIOVector *qiov, size_t qiov_offset,
                                       BdrvRequestFlags flags);
 -int generated_co_wrapper blk_pwritev(BlockBackend *blk, int64_t offset,
 -                                     int64_t bytes, QEMUIOVector *qiov,
 -                                     BdrvRequestFlags flags);
 -int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
 -                                int64_t bytes, QEMUIOVector *qiov,
 -                                BdrvRequestFlags flags);
 -
 -static inline int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset,
 -                                            int64_t bytes, void *buf,
 -                                            BdrvRequestFlags flags)
 -{
 -    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
 -    IO_OR_GS_CODE();
 -
 -    assert(bytes <= SIZE_MAX);
 -
 -    return blk_co_preadv(blk, offset, bytes, &qiov, flags);
 -}
 -
 -static inline int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset,
 -                                             int64_t bytes, const void *buf,
 -                                             BdrvRequestFlags flags)
 -{
 -    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
 -    IO_OR_GS_CODE();
 -    assert(bytes <= SIZE_MAX);
 +int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
 +                                               int64_t offset, int64_t bytes,
 +                                               const void *buf);
 +int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
 +                                          int64_t bytes, const void *buf);
 -    return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
 -}
 +int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 +                                           int64_t bytes,
 +                                           BdrvRequestFlags flags);
 +int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 +                                      int64_t bytes, BdrvRequestFlags flags);
  int generated_co_wrapper blk_pdiscard(BlockBackend *blk, int64_t offset,
                                        int64_t bytes);
@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_ioctl(BlockBackend *blk, unsigned long int req,
  int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
                                void *buf);
 -int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
 -                                               int64_t offset, int64_t bytes,
 -                                               const void *buf);
 -int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
 -                                          int64_t bytes, const void *buf);
 -int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 -                                           int64_t bytes,
 -                                           BdrvRequestFlags flags);
 -int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 -                                      int64_t bytes, BdrvRequestFlags flags);
  int generated_co_wrapper blk_truncate(BlockBackend *blk, int64_t offset,
                                        bool exact, PreallocMode prealloc,
                                        BdrvRequestFlags flags, Error **errp);
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
---- a/meson.build
+--- a/block/block-backend.c
-+++ b/meson.build
++++ b/block/block-backend.c
-@@ -XXX,XX +XXX,XX @@ libqemuutil = static_library('qemuutil',
+@@ -XXX,XX +XXX,XX @@ blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
-                              sources: util_ss.sources() + stub_ss.sources() + genh,
+     return ret;
-                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
+ }
- qemuutil = declare_dependency(link_with: libqemuutil,
--                              sources: genh + version_res)
++int coroutine_fn blk_co_pread(BlockBackend *blk, int64_t offset, int64_t bytes,
-+                              sources: genh + version_res,
++                              void *buf, BdrvRequestFlags flags)
-+                              dependencies: [event_loop_base])
++{
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
- if have_system or have_user
++    IO_OR_GS_CODE();
    decodetree = generator(find_program('scripts/decodetree.py'),
 diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/qemu/main-loop.h
 +++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@
  #define QEMU_MAIN_LOOP_H
  #include "block/aio.h"
 +#include "qom/object.h"
 +#include "sysemu/event-loop-base.h"
  #define SIG_IPI SIGUSR1
 +#define TYPE_MAIN_LOOP  "main-loop"
 +OBJECT_DECLARE_TYPE(MainLoop, MainLoopClass, MAIN_LOOP)
 +
-+struct MainLoop {
++    assert(bytes <= SIZE_MAX);
 +    EventLoopBase parent_obj;
 +};
 +typedef struct MainLoop MainLoop;
 +
- /**
++    return blk_co_preadv(blk, offset, bytes, &qiov, flags);
   * qemu_init_main_loop: Set up the process so that it can run the main loop.
   *
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/event-loop-base.h
 +++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBaseClass {
      void (*init)(EventLoopBase *base, Error **errp);
      void (*update_params)(EventLoopBase *base, Error **errp);
 +    bool (*can_be_deleted)(EventLoopBase *base);
  };
  struct EventLoopBase {
 diff --git a/event-loop-base.c b/event-loop-base.c
 index XXXXXXX..XXXXXXX 100644
 --- a/event-loop-base.c
 +++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_complete(UserCreatable *uc, Error **errp)
      }
  }
 +static bool event_loop_base_can_be_deleted(UserCreatable *uc)
 +{
 +    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
 +    EventLoopBase *backend = EVENT_LOOP_BASE(uc);
 +
 +    if (bc->can_be_deleted) {
 +        return bc->can_be_deleted(backend);
 +    }
 +
 +    return true;
 +}
 +
- static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
+ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
- {
+                                int64_t bytes, QEMUIOVector *qiov,
-     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
+                                BdrvRequestFlags flags)
-     ucc->complete = event_loop_base_complete;
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
-+    ucc->can_be_deleted = event_loop_base_can_be_deleted;
+     return ret;
      object_class_property_add(klass, "aio-max-batch", "int",
                                event_loop_base_get_param,
 diff --git a/util/main-loop.c b/util/main-loop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/main-loop.c
 +++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/error-report.h"
  #include "qemu/queue.h"
  #include "qemu/compiler.h"
 +#include "qom/object.h"
  #ifndef _WIN32
  #include <sys/wait.h>
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
      return 0;
  }
-+static void main_loop_update_params(EventLoopBase *base, Error **errp)
++int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
 +                               const void *buf, BdrvRequestFlags flags)
 +{
-+    if (!qemu_aio_context) {
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
-+        error_setg(errp, "qemu aio context not ready");
++    IO_OR_GS_CODE();
 +        return;
 +    }
 +
-+    aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
++    assert(bytes <= SIZE_MAX);
 +
 +    return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
 +}
 +
-+MainLoop *mloop;
+ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
-+
+                                 int64_t bytes, QEMUIOVector *qiov,
-+static void main_loop_init(EventLoopBase *base, Error **errp)
+                                 BdrvRequestFlags flags)
 +{
 +    MainLoop *m = MAIN_LOOP(base);
 +
 +    if (mloop) {
 +        error_setg(errp, "only one main-loop instance allowed");
 +        return;
 +    }
 +
 +    main_loop_update_params(base, errp);
 +
 +    mloop = m;
 +    return;
 +}
 +
 +static bool main_loop_can_be_deleted(EventLoopBase *base)
 +{
 +    return false;
 +}
 +
 +static void main_loop_class_init(ObjectClass *oc, void *class_data)
 +{
 +    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(oc);
 +
 +    bc->init = main_loop_init;
 +    bc->update_params = main_loop_update_params;
 +    bc->can_be_deleted = main_loop_can_be_deleted;
 +}
 +
 +static const TypeInfo main_loop_info = {
 +    .name = TYPE_MAIN_LOOP,
 +    .parent = TYPE_EVENT_LOOP_BASE,
 +    .class_init = main_loop_class_init,
 +    .instance_size = sizeof(MainLoop),
 +};
 +
 +static void main_loop_register_types(void)
 +{
 +    type_register_static(&main_loop_info);
 +}
 +
 +type_init(main_loop_register_types)
 +
  static int max_priority;
  #ifndef _WIN32
 --
-.35.1
+.35.3

-New patch
+[PULL 30/35] block: Remove remaining unused symbols in coroutines.h
+From: Alberto Faria <afaria@redhat.com>
+Some can be made static, others are unused generated_co_wrappers.
+Signed-off-by: Alberto Faria <afaria@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220705161527.1054072-19-afaria@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+---
+ block/coroutines.h    | 19 -------------------
+ block/block-backend.c |  6 +++---
+files changed, 3 insertions(+), 22 deletions(-)
+diff --git a/block/coroutines.h b/block/coroutines.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/coroutines.h
++++ b/block/coroutines.h
+@@ -XXX,XX +XXX,XX @@ nbd_co_do_establish_connection(BlockDriverState *bs, bool blocking,
+                                Error **errp);
+-int coroutine_fn
+-blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
+-                       QEMUIOVector *qiov, size_t qiov_offset,
+-                       BdrvRequestFlags flags);
+-
+-int coroutine_fn
+-blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
+-
+-int coroutine_fn blk_co_do_flush(BlockBackend *blk);
+-
+-
+ /*
+  * "I/O or GS" API functions. These functions can run without
+  * the BQL, but only in one specific iothread/main loop.
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_do_flush(BlockBackend *blk);
+  * the "I/O or GS" API.
+  */
+-int generated_co_wrapper
+-bdrv_preadv(BdrvChild *child, int64_t offset, int64_t bytes,
+-            QEMUIOVector *qiov, BdrvRequestFlags flags);
+-
+-int generated_co_wrapper
+-bdrv_pwritev(BdrvChild *child, int64_t offset, int64_t bytes,
+-             QEMUIOVector *qiov, BdrvRequestFlags flags);
+-
+ int generated_co_wrapper
+ bdrv_common_block_status_above(BlockDriverState *bs,
+                                BlockDriverState *base,
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
+ }
+ /* To be called between exactly one pair of blk_inc/dec_in_flight() */
+-int coroutine_fn
++static int coroutine_fn
+ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
+                        QEMUIOVector *qiov, size_t qiov_offset,
+                        BdrvRequestFlags flags)
+@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
+ }
+ /* To be called between exactly one pair of blk_inc/dec_in_flight() */
+-int coroutine_fn
++static int coroutine_fn
+ blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
+ {
+     int ret;
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
+ }
+ /* To be called between exactly one pair of blk_inc/dec_in_flight() */
+-int coroutine_fn blk_co_do_flush(BlockBackend *blk)
++static int coroutine_fn blk_co_do_flush(BlockBackend *blk)
+ {
+     blk_wait_while_drained(blk);
+     IO_CODE();
+--
+.35.3

-New patch
+[PULL 31/35] qsd: Do not use error_report() before monitor_init
+error_report() only works once monitor_init_globals_core() has been
+called, which is not the case when parsing the --daemonize option.  Use
+fprintf(stderr, ...) instead.
+Fixes: 2525edd85fec53e23fda98974a15e3b3c8957596 ("qsd: Add --daemonize")
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220609122852.21140-1-hreitz@redhat.com>
+Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+---
+ storage-daemon/qemu-storage-daemon.c | 6 +++++-
+file changed, 5 insertions(+), 1 deletion(-)
+diff --git a/storage-daemon/qemu-storage-daemon.c b/storage-daemon/qemu-storage-daemon.c
+index XXXXXXX..XXXXXXX 100644
+--- a/storage-daemon/qemu-storage-daemon.c
++++ b/storage-daemon/qemu-storage-daemon.c
+@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[], bool pre_init_pass)
+             }
+         case OPTION_DAEMONIZE:
+             if (os_set_daemonize(true) < 0) {
+-                error_report("--daemonize not supported in this build");
++                /*
++                 * --daemonize is parsed before monitor_init_globals_core(), so
++                 * error_report() does not work yet
++                 */
++                fprintf(stderr, "--daemonize not supported in this build\n");
+                 exit(EXIT_FAILURE);
+             }
+             break;
+--
+.35.3

-New patch
+[PULL 32/35] iotests/297: Have mypy ignore unused ignores
+e7874a50ff3f5b20fb46f36958ad ("python: update for mypy 0.950") has added
+`warn_unused_ignores = False` to python/setup.cfg, to be able to keep
+compatibility with both pre- and post-0.950 mypy versions.
+The iotests' mypy.ini needs the same, or 297 will fail (on both pre- and
+post-0.950 mypy, as far as I can tell; just for different `ignore`
+lines).
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220621092536.19837-1-hreitz@redhat.com>
+Acked-by: John Snow <jsnow@redhat.com>
+---
+ tests/qemu-iotests/mypy.ini | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+diff --git a/tests/qemu-iotests/mypy.ini b/tests/qemu-iotests/mypy.ini
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/mypy.ini
++++ b/tests/qemu-iotests/mypy.ini
+@@ -XXX,XX +XXX,XX @@ no_implicit_optional = True
+ scripts_are_modules = True
+ warn_redundant_casts = True
+ warn_unused_configs = True
+-warn_unused_ignores = True
++warn_unused_ignores = False
+--
+.35.3

-[PULL 3/3] util/event-loop-base: Introduce options to set the thread pool size
+[PULL 33/35] qsd: Unlink absolute PID file path
-From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
+After writing the PID file, we register an atexit() handler to unlink it
 when the process terminates.  However, if the process has changed its
 working directory in the meantime (e.g. in os_setup_post() when
 daemonizing), this will not work when the PID file path was relative.
 Therefore, pass the absolute path (created with realpath()) to the
 unlink() call in the atexit() handler.
-The thread pool regulates itself: when idle, it kills threads until
+(realpath() needs a path pointing to an existing file, so we cannot use
-empty, when in demand, it creates new threads until full. This behaviour
+it before qemu_write_pidfile().)
 doesn't play well with latency sensitive workloads where the price of
 creating a new thread is too high. For example, when paired with qemu's
 '-mlock', or using safety features like SafeStack, creating a new thread
 has been measured take multiple milliseconds.
-In order to mitigate this let's introduce a new 'EventLoopBase'
+Reproducer:
-property to set the thread pool size. The threads will be created during
+$ cd /tmp
-the pool's initialization or upon updating the property's value, remain
+$ qemu-storage-daemon --daemonize --pidfile qsd.pid
-available during its lifetime regardless of demand, and destroyed upon
+$ file qsd.pid
-freeing it. A properly characterized workload will then be able to
+qsd.pid: ASCII text
-configure the pool to avoid any latency spikes.
+$ kill $(cat qsd.pid)
 $ file qsd.pid
 qsd.pid: ASCII text
-Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
+(qsd.pid should be gone after the process has terminated.)
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Acked-by: Markus Armbruster <armbru@redhat.com>
+Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2092322
-Message-id: 20220425075723.20019-4-nsaenzju@redhat.com
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20220609122701.17172-2-hreitz@redhat.com>
 Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 ---
- qapi/qom.json                    | 10 +++++-
+ storage-daemon/qemu-storage-daemon.c | 11 ++++++++++-
- include/block/aio.h              | 10 ++++++
+file changed, 10 insertions(+), 1 deletion(-)
  include/block/thread-pool.h      |  3 ++
  include/sysemu/event-loop-base.h |  4 +++
  event-loop-base.c                | 23 +++++++++++++
  iothread.c                       |  3 ++
  util/aio-posix.c                 |  1 +
  util/async.c                     | 20 ++++++++++++
  util/main-loop.c                 |  9 ++++++
  util/thread-pool.c               | 55 +++++++++++++++++++++++++++++---
 files changed, 133 insertions(+), 5 deletions(-)
-diff --git a/qapi/qom.json b/qapi/qom.json
+diff --git a/storage-daemon/qemu-storage-daemon.c b/storage-daemon/qemu-storage-daemon.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/qom.json
+--- a/storage-daemon/qemu-storage-daemon.c
-+++ b/qapi/qom.json
++++ b/storage-daemon/qemu-storage-daemon.c
 @@ -XXX,XX +XXX,XX @@
- #                 0 means that the engine will use its default.
+ #include "trace/control.h"
- #                 (default: 0)
- #
+ static const char *pid_file;
-+# @thread-pool-min: minimum number of threads reserved in the thread pool
++static char *pid_file_realpath;
-+#                   (default:0)
+ static volatile bool exit_requested = false;
-+#
-+# @thread-pool-max: maximum number of threads the thread pool can contain
+ void qemu_system_killed(int signal, pid_t pid)
-+#                   (default:64)
+@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[], bool pre_init_pass)
-+#
- # Since: 7.1
+ static void pid_file_cleanup(void)
- ##
+ {
- { 'struct': 'EventLoopBaseProperties',
+-    unlink(pid_file);
--  'data': { '*aio-max-batch': 'int' } }
++    unlink(pid_file_realpath);
 +  'data': { '*aio-max-batch': 'int',
 +            '*thread-pool-min': 'int',
 +            '*thread-pool-max': 'int' } }
  ##
  # @IothreadProperties:
 diff --git a/include/block/aio.h b/include/block/aio.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/aio.h
 +++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ struct AioContext {
      QSLIST_HEAD(, Coroutine) scheduled_coroutines;
      QEMUBH *co_schedule_bh;
 +    int thread_pool_min;
 +    int thread_pool_max;
      /* Thread pool for performing work and receiving completion callbacks.
       * Has its own locking.
       */
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
  void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
                                  Error **errp);
 +/**
 + * aio_context_set_thread_pool_params:
 + * @ctx: the aio context
 + * @min: min number of threads to have readily available in the thread pool
 + * @min: max number of threads the thread pool can contain
 + */
 +void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
 +                                        int64_t max, Error **errp);
  #endif
 diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/thread-pool.h
 +++ b/include/block/thread-pool.h
@@ -XXX,XX +XXX,XX @@
  #include "block/block.h"
 +#define THREAD_POOL_MAX_THREADS_DEFAULT         64
 +
  typedef int ThreadPoolFunc(void *opaque);
  typedef struct ThreadPool ThreadPool;
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
  int coroutine_fn thread_pool_submit_co(ThreadPool *pool,
          ThreadPoolFunc *func, void *arg);
  void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg);
 +void thread_pool_update_params(ThreadPool *pool, struct AioContext *ctx);
  #endif
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/event-loop-base.h
 +++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBase {
      /* AioContext AIO engine parameters */
      int64_t aio_max_batch;
 +
 +    /* AioContext thread pool parameters */
 +    int64_t thread_pool_min;
 +    int64_t thread_pool_max;
  };
  #endif
 diff --git a/event-loop-base.c b/event-loop-base.c
 index XXXXXXX..XXXXXXX 100644
 --- a/event-loop-base.c
 +++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "qom/object_interfaces.h"
  #include "qapi/error.h"
 +#include "block/thread-pool.h"
  #include "sysemu/event-loop-base.h"
  typedef struct {
@@ -XXX,XX +XXX,XX @@ typedef struct {
      ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
  } EventLoopBaseParamInfo;
 +static void event_loop_base_instance_init(Object *obj)
 +{
 +    EventLoopBase *base = EVENT_LOOP_BASE(obj);
 +
 +    base->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
 +}
 +
  static EventLoopBaseParamInfo aio_max_batch_info = {
      "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
  };
 +static EventLoopBaseParamInfo thread_pool_min_info = {
 +    "thread-pool-min", offsetof(EventLoopBase, thread_pool_min),
 +};
 +static EventLoopBaseParamInfo thread_pool_max_info = {
 +    "thread-pool-max", offsetof(EventLoopBase, thread_pool_max),
 +};
  static void event_loop_base_get_param(Object *obj, Visitor *v,
          const char *name, void *opaque, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
                                event_loop_base_get_param,
                                event_loop_base_set_param,
                                NULL, &aio_max_batch_info);
 +    object_class_property_add(klass, "thread-pool-min", "int",
 +                              event_loop_base_get_param,
 +                              event_loop_base_set_param,
 +                              NULL, &thread_pool_min_info);
 +    object_class_property_add(klass, "thread-pool-max", "int",
 +                              event_loop_base_get_param,
 +                              event_loop_base_set_param,
 +                              NULL, &thread_pool_max_info);
  }
- static const TypeInfo event_loop_base_info = {
+ static void pid_file_init(void)
-     .name = TYPE_EVENT_LOOP_BASE,
+@@ -XXX,XX +XXX,XX @@ static void pid_file_init(void)
-     .parent = TYPE_OBJECT,
+         exit(EXIT_FAILURE);
-     .instance_size = sizeof(EventLoopBase),
+     }
-+    .instance_init = event_loop_base_instance_init,
-     .class_size = sizeof(EventLoopBaseClass),
++    pid_file_realpath = g_malloc(PATH_MAX);
-     .class_init = event_loop_base_class_init,
++    if (!realpath(pid_file, pid_file_realpath)) {
-     .abstract = true,
++        error_report("cannot resolve PID file path: %s: %s",
-diff --git a/iothread.c b/iothread.c
++                     pid_file, strerror(errno));
-index XXXXXXX..XXXXXXX 100644
++        unlink(pid_file);
---- a/iothread.c
++        exit(EXIT_FAILURE);
 +++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
      aio_context_set_aio_params(iothread->ctx,
                                 iothread->parent_obj.aio_max_batch,
                                 errp);
 +
 +    aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_min,
 +                                       base->thread_pool_max, errp);
  }
 diff --git a/util/aio-posix.c b/util/aio-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-posix.c
 +++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "block/block.h"
 +#include "block/thread-pool.h"
  #include "qemu/main-loop.h"
  #include "qemu/rcu.h"
  #include "qemu/rcu_queue.h"
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
      ctx->aio_max_batch = 0;
 +    ctx->thread_pool_min = 0;
 +    ctx->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
 +
      return ctx;
  fail:
      g_source_destroy(&ctx->source);
@@ -XXX,XX +XXX,XX @@ void qemu_set_current_aio_context(AioContext *ctx)
      assert(!get_my_aiocontext());
      set_my_aiocontext(ctx);
  }
 +
 +void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
 +                                        int64_t max, Error **errp)
 +{
 +
 +    if (min > max || !max || min > INT_MAX || max > INT_MAX) {
 +        error_setg(errp, "bad thread-pool-min/thread-pool-max values");
 +        return;
 +    }
 +
-+    ctx->thread_pool_min = min;
+     atexit(pid_file_cleanup);
 +    ctx->thread_pool_max = max;
 +
 +    if (ctx->thread_pool) {
 +        thread_pool_update_params(ctx->thread_pool, ctx);
 +    }
 +}
 diff --git a/util/main-loop.c b/util/main-loop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/main-loop.c
 +++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
  #include "sysemu/replay.h"
  #include "qemu/main-loop.h"
  #include "block/aio.h"
 +#include "block/thread-pool.h"
  #include "qemu/error-report.h"
  #include "qemu/queue.h"
  #include "qemu/compiler.h"
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
  static void main_loop_update_params(EventLoopBase *base, Error **errp)
  {
 +    ERRP_GUARD();
 +
      if (!qemu_aio_context) {
          error_setg(errp, "qemu aio context not ready");
          return;
      }
      aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
 +    if (*errp) {
 +        return;
 +    }
 +
 +    aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool_min,
 +                                       base->thread_pool_max, errp);
  }
- MainLoop *mloop;
-diff --git a/util/thread-pool.c b/util/thread-pool.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/thread-pool.c
-+++ b/util/thread-pool.c
-@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
-     QemuMutex lock;
-     QemuCond worker_stopped;
-     QemuSemaphore sem;
--    int max_threads;
-     QEMUBH *new_thread_bh;
-     /* The following variables are only accessed from one AioContext. */
-@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
-     int new_threads;     /* backlog of threads we need to create */
-     int pending_threads; /* threads created but not running yet */
-     bool stopping;
-+    int min_threads;
-+    int max_threads;
- };
-+static inline bool back_to_sleep(ThreadPool *pool, int ret)
-+{
-+    /*
-+     * The semaphore timed out, we should exit the loop except when:
-+     *  - There is work to do, we raced with the signal.
-+     *  - The max threads threshold just changed, we raced with the signal.
-+     *  - The thread pool forces a minimum number of readily available threads.
-+     */
-+    if (ret == -1 && (!QTAILQ_EMPTY(&pool->request_list) ||
-+            pool->cur_threads > pool->max_threads ||
-+            pool->cur_threads <= pool->min_threads)) {
-+            return true;
-+    }
-+
-+    return false;
-+}
-+
- static void *worker_thread(void *opaque)
- {
-     ThreadPool *pool = opaque;
-@@ -XXX,XX +XXX,XX @@ static void *worker_thread(void *opaque)
-             ret = qemu_sem_timedwait(&pool->sem, 10000);
-             qemu_mutex_lock(&pool->lock);
-             pool->idle_threads--;
--        } while (ret == -1 && !QTAILQ_EMPTY(&pool->request_list));
--        if (ret == -1 || pool->stopping) {
-+        } while (back_to_sleep(pool, ret));
-+        if (ret == -1 || pool->stopping ||
-+            pool->cur_threads > pool->max_threads) {
-             break;
-         }
-@@ -XXX,XX +XXX,XX @@ void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)
-     thread_pool_submit_aio(pool, func, arg, NULL, NULL);
- }
-+void thread_pool_update_params(ThreadPool *pool, AioContext *ctx)
-+{
-+    qemu_mutex_lock(&pool->lock);
-+
-+    pool->min_threads = ctx->thread_pool_min;
-+    pool->max_threads = ctx->thread_pool_max;
-+
-+    /*
-+     * We either have to:
-+     *  - Increase the number available of threads until over the min_threads
-+     *    threshold.
-+     *  - Decrease the number of available threads until under the max_threads
-+     *    threshold.
-+     *  - Do nothing. The current number of threads fall in between the min and
-+     *    max thresholds. We'll let the pool manage itself.
-+     */
-+    for (int i = pool->cur_threads; i < pool->min_threads; i++) {
-+        spawn_thread(pool);
-+    }
-+
-+    for (int i = pool->cur_threads; i > pool->max_threads; i--) {
-+        qemu_sem_post(&pool->sem);
-+    }
-+
-+    qemu_mutex_unlock(&pool->lock);
-+}
-+
- static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
- {
-     if (!ctx) {
-@@ -XXX,XX +XXX,XX @@ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
-     qemu_mutex_init(&pool->lock);
-     qemu_cond_init(&pool->worker_stopped);
-     qemu_sem_init(&pool->sem, 0);
--    pool->max_threads = 64;
-     pool->new_thread_bh = aio_bh_new(ctx, spawn_thread_bh_fn, pool);
-     QLIST_INIT(&pool->head);
-     QTAILQ_INIT(&pool->request_list);
-+
-+    thread_pool_update_params(pool, ctx);
- }
- ThreadPool *thread_pool_new(AioContext *ctx)
 --
-.35.1
+.35.3

-New patch
+[PULL 34/35] vl: Conditionally register PID file unlink notifier
+Currently, the exit notifier for unlinking the PID file is registered
+unconditionally.  Limit it to only when we actually do create a PID
+file.
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220609122701.17172-3-hreitz@redhat.com>
+Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+---
+ softmmu/vl.c | 18 +++++++++---------
+file changed, 9 insertions(+), 9 deletions(-)
+diff --git a/softmmu/vl.c b/softmmu/vl.c
+index XXXXXXX..XXXXXXX 100644
+--- a/softmmu/vl.c
++++ b/softmmu/vl.c
+@@ -XXX,XX +XXX,XX @@ static Notifier qemu_unlink_pidfile_notifier;
+ static void qemu_unlink_pidfile(Notifier *n, void *data)
+ {
+-    if (pid_file) {
+-        unlink(pid_file);
+-    }
++    unlink(pid_file);
+ }
+ static const QEMUOption *lookup_opt(int argc, char **argv,
+@@ -XXX,XX +XXX,XX @@ static void qemu_maybe_daemonize(const char *pid_file)
+     os_daemonize();
+     rcu_disable_atfork();
+-    if (pid_file && !qemu_write_pidfile(pid_file, &err)) {
+-        error_reportf_err(err, "cannot create PID file: ");
+-        exit(1);
+-    }
++    if (pid_file) {
++        if (!qemu_write_pidfile(pid_file, &err)) {
++            error_reportf_err(err, "cannot create PID file: ");
++            exit(1);
++        }
+-    qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
+-    qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);
++        qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
++        qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);
++    }
+ }
+ static void qemu_init_displays(void)
+--
+.35.3

-New patch
+[PULL 35/35] vl: Unlink absolute PID file path
+After writing the PID file, we register an exit notifier to unlink it
+when the process terminates.  However, if the process has changed its
+working directory in the meantime (e.g. in os_setup_post() when
+daemonizing), this will not work when the PID file path was relative.
+Therefore, pass the absolute path (created with realpath()) to the
+unlink() call in the exit notifier.
+(realpath() needs a path pointing to an existing file, so we cannot use
+it before qemu_write_pidfile().)
+Reproducer:
+$ cd /tmp
+$ qemu-system-x86_64 --daemonize --pidfile qemu.pid
+$ file qemu.pid
+qemu.pid: ASCII text
+$ kill $(cat qemu.pid)
+$ file qemu.pid
+qemu.pid: ASCII text
+(qemu.pid should be gone after the process has terminated.)
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+Message-Id: <20220609122701.17172-4-hreitz@redhat.com>
+Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+---
+ softmmu/vl.c | 30 ++++++++++++++++++++++++++----
+file changed, 26 insertions(+), 4 deletions(-)
+diff --git a/softmmu/vl.c b/softmmu/vl.c
+index XXXXXXX..XXXXXXX 100644
+--- a/softmmu/vl.c
++++ b/softmmu/vl.c
+@@ -XXX,XX +XXX,XX @@ machine_parse_property_opt(QemuOptsList *opts_list, const char *propname,
+ }
+ static const char *pid_file;
+-static Notifier qemu_unlink_pidfile_notifier;
++struct UnlinkPidfileNotifier {
++    Notifier notifier;
++    char *pid_file_realpath;
++};
++static struct UnlinkPidfileNotifier qemu_unlink_pidfile_notifier;
+ static void qemu_unlink_pidfile(Notifier *n, void *data)
+ {
+-    unlink(pid_file);
++    struct UnlinkPidfileNotifier *upn;
++
++    upn = DO_UPCAST(struct UnlinkPidfileNotifier, notifier, n);
++    unlink(upn->pid_file_realpath);
+ }
+ static const QEMUOption *lookup_opt(int argc, char **argv,
+@@ -XXX,XX +XXX,XX @@ static void qemu_maybe_daemonize(const char *pid_file)
+     rcu_disable_atfork();
+     if (pid_file) {
++        char *pid_file_realpath = NULL;
++
+         if (!qemu_write_pidfile(pid_file, &err)) {
+             error_reportf_err(err, "cannot create PID file: ");
+             exit(1);
+         }
+-        qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
+-        qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);
++        pid_file_realpath = g_malloc0(PATH_MAX);
++        if (!realpath(pid_file, pid_file_realpath)) {
++            error_report("cannot resolve PID file path: %s: %s",
++                         pid_file, strerror(errno));
++            unlink(pid_file);
++            exit(1);
++        }
++
++        qemu_unlink_pidfile_notifier = (struct UnlinkPidfileNotifier) {
++            .notifier = {
++                .notify = qemu_unlink_pidfile,
++            },
++            .pid_file_realpath = pid_file_realpath,
++        };
++        qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier.notifier);
+     }
+ }
+--
+.35.3

The following changes since commit 9cf289af47bcfae5c75de37d8e5d6fd23705322c:

Merge tag 'qga-pull-request' of gitlab.com:marcandre.lureau/qemu into staging (2022-05-04 03:42:49 -0700)

are available in the Git repository at:

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

for you to fetch changes up to bef2e050d6a7feb865854c65570c496ac5a8cf53:

util/event-loop-base: Introduce options to set the thread pool size (2022-05-04 17:02:19 +0100)

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

Add new thread-pool-min/thread-pool-max parameters to control the thread pool
used for async I/O.

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

Nicolas Saenz Julienne (3):
  Introduce event-loop-base abstract class
  util/main-loop: Introduce the main loop into QOM
  util/event-loop-base: Introduce options to set the thread pool size

-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

Introduce the 'event-loop-base' abstract class, it'll hold the
properties common to all event loops and provide the necessary hooks for
their creation and maintenance. Then have iothread inherit from it.

EventLoopBaseClass is defined as user creatable and provides a hook for
its children to attach themselves to the user creatable class 'complete'
function. It also provides an update_params() callback to propagate
property changes onto its children.

The new 'event-loop-base' class will live in the root directory. It is
built on its own using the 'link_whole' option (there are no direct
function dependencies between the class and its children, it all happens
trough 'constructor' magic). And also imposes new compilation
dependencies:

qom <- event-loop-base <- blockdev (iothread.c)

And in subsequent patches:

qom <- event-loop-base <- qemuutil (util/main-loop.c)

All this forced some amount of reordering in meson.build:

- Moved qom build definition before qemuutil. Doing it the other way
   around (i.e. moving qemuutil after qom) isn't possible as a lot of
   core libraries that live in between the two depend on it.

- Process the 'hw' subdir earlier, as it introduces files into the
   'qom' source set.

No functional changes intended.

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-2-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    |  22 +++++--
 meson.build                      |  23 ++++---
 include/sysemu/event-loop-base.h |  36 +++++++++++
 include/sysemu/iothread.h        |   6 +-
 event-loop-base.c                | 104 +++++++++++++++++++++++++++++++
 iothread.c                       |  65 ++++++-------------
 6 files changed, 192 insertions(+), 64 deletions(-)
 create mode 100644 include/sysemu/event-loop-base.h
 create mode 100644 event-loop-base.c

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
             '*repeat': 'bool',
             '*grab-toggle': 'GrabToggleKeys' } }
 
+##
+# @EventLoopBaseProperties:
+#
+# Common properties for event loops
+#
+# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
+#                 0 means that the engine will use its default.
+#                 (default: 0)
+#
+# Since: 7.1
+##
+{ 'struct': 'EventLoopBaseProperties',
+  'data': { '*aio-max-batch': 'int' } }
+
 ##
 # @IothreadProperties:
 #
@@ -XXX,XX +XXX,XX @@
 #               algorithm detects it is spending too long polling without
 #               encountering events. 0 selects a default behaviour (default: 0)
 #
-# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
-#                 0 means that the engine will use its default
-#                 (default:0, since 6.1)
+# The @aio-max-batch option is available since 6.1.
 #
 # Since: 2.0
 ##
 { 'struct': 'IothreadProperties',
+  'base': 'EventLoopBaseProperties',
   'data': { '*poll-max-ns': 'int',
             '*poll-grow': 'int',
-            '*poll-shrink': 'int',
-            '*aio-max-batch': 'int' } }
+            '*poll-shrink': 'int' } }
 
 ##
 # @MemoryBackendProperties:
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ subdir('qom')
 subdir('authz')
 subdir('crypto')
 subdir('ui')
+subdir('hw')
 
 
 if enable_modules
@@ -XXX,XX +XXX,XX @@ if enable_modules
   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
 endif
 
+qom_ss = qom_ss.apply(config_host, strict: false)
+libqom = static_library('qom', qom_ss.sources() + genh,
+                        dependencies: [qom_ss.dependencies()],
+                        name_suffix: 'fa')
+qom = declare_dependency(link_whole: libqom)
+
+event_loop_base = files('event-loop-base.c')
+event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
+                                 build_by_default: true)
+event_loop_base = declare_dependency(link_whole: event_loop_base,
+                                     dependencies: [qom])
+
 stub_ss = stub_ss.apply(config_all, strict: false)
 
 util_ss.add_all(trace_ss)
@@ -XXX,XX +XXX,XX @@ subdir('monitor')
 subdir('net')
 subdir('replay')
 subdir('semihosting')
-subdir('hw')
 subdir('tcg')
 subdir('fpu')
 subdir('accel')
@@ -XXX,XX +XXX,XX @@ qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
                              capture: true,
                              command: [undefsym, nm, '@INPUT@'])
 
-qom_ss = qom_ss.apply(config_host, strict: false)
-libqom = static_library('qom', qom_ss.sources() + genh,
-                        dependencies: [qom_ss.dependencies()],
-                        name_suffix: 'fa')
-
-qom = declare_dependency(link_whole: libqom)
-
 authz_ss = authz_ss.apply(config_host, strict: false)
 libauthz = static_library('authz', authz_ss.sources() + genh,
                           dependencies: [authz_ss.dependencies()],
@@ -XXX,XX +XXX,XX @@ libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
                              build_by_default: false)
 
 blockdev = declare_dependency(link_whole: [libblockdev],
-                              dependencies: [block])
+                              dependencies: [block, event_loop_base])
 
 qmp_ss = qmp_ss.apply(config_host, strict: false)
 libqmp = static_library('qmp', qmp_ss.sources() + genh,
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU event-loop backend
+ *
+ * Copyright (C) 2022 Red Hat Inc
+ *
+ * Authors:
+ *  Nicolas Saenz Julienne <nsaenzju@redhat.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 QEMU_EVENT_LOOP_BASE_H
+#define QEMU_EVENT_LOOP_BASE_H
+
+#include "qom/object.h"
+#include "block/aio.h"
+#include "qemu/typedefs.h"
+
+#define TYPE_EVENT_LOOP_BASE         "event-loop-base"
+OBJECT_DECLARE_TYPE(EventLoopBase, EventLoopBaseClass,
+                    EVENT_LOOP_BASE)
+
+struct EventLoopBaseClass {
+    ObjectClass parent_class;
+
+    void (*init)(EventLoopBase *base, Error **errp);
+    void (*update_params)(EventLoopBase *base, Error **errp);
+};
+
+struct EventLoopBase {
+    Object parent;
+
+    /* AioContext AIO engine parameters */
+    int64_t aio_max_batch;
+};
+#endif
diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/iothread.h
+++ b/include/sysemu/iothread.h
@@ -XXX,XX +XXX,XX @@
 #include "block/aio.h"
 #include "qemu/thread.h"
 #include "qom/object.h"
+#include "sysemu/event-loop-base.h"
 
 #define TYPE_IOTHREAD "iothread"
 
 struct IOThread {
-    Object parent_obj;
+    EventLoopBase parent_obj;
 
     QemuThread thread;
     AioContext *ctx;
@@ -XXX,XX +XXX,XX @@ struct IOThread {
     int64_t poll_max_ns;
     int64_t poll_grow;
     int64_t poll_shrink;
-
-    /* AioContext AIO engine parameters */
-    int64_t aio_max_batch;
 };
 typedef struct IOThread IOThread;
 
diff --git a/event-loop-base.c b/event-loop-base.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU event-loop base
+ *
+ * Copyright (C) 2022 Red Hat Inc
+ *
+ * Authors:
+ *  Stefan Hajnoczi <stefanha@redhat.com>
+ *  Nicolas Saenz Julienne <nsaenzju@redhat.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 "qom/object_interfaces.h"
+#include "qapi/error.h"
+#include "sysemu/event-loop-base.h"
+
+typedef struct {
+    const char *name;
+    ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
+} EventLoopBaseParamInfo;
+
+static EventLoopBaseParamInfo aio_max_batch_info = {
+    "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
+};
+
+static void event_loop_base_get_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+    EventLoopBase *event_loop_base = EVENT_LOOP_BASE(obj);
+    EventLoopBaseParamInfo *info = opaque;
+    int64_t *field = (void *)event_loop_base + info->offset;
+
+    visit_type_int64(v, name, field, errp);
+}
+
+static void event_loop_base_set_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(obj);
+    EventLoopBase *base = EVENT_LOOP_BASE(obj);
+    EventLoopBaseParamInfo *info = opaque;
+    int64_t *field = (void *)base + info->offset;
+    int64_t value;
+
+    if (!visit_type_int64(v, name, &value, errp)) {
+        return;
+    }
+
+    if (value < 0) {
+        error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
+                   info->name, INT64_MAX);
+        return;
+    }
+
+    *field = value;
+
+    if (bc->update_params) {
+        bc->update_params(base, errp);
+    }
+
+    return;
+}
+
+static void event_loop_base_complete(UserCreatable *uc, Error **errp)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
+    EventLoopBase *base = EVENT_LOOP_BASE(uc);
+
+    if (bc->init) {
+        bc->init(base, errp);
+    }
+}
+
+static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
+{
+    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
+    ucc->complete = event_loop_base_complete;
+
+    object_class_property_add(klass, "aio-max-batch", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &aio_max_batch_info);
+}
+
+static const TypeInfo event_loop_base_info = {
+    .name = TYPE_EVENT_LOOP_BASE,
+    .parent = TYPE_OBJECT,
+    .instance_size = sizeof(EventLoopBase),
+    .class_size = sizeof(EventLoopBaseClass),
+    .class_init = event_loop_base_class_init,
+    .abstract = true,
+    .interfaces = (InterfaceInfo[]) {
+        { TYPE_USER_CREATABLE },
+        { }
+    }
+};
+
+static void register_types(void)
+{
+    type_register_static(&event_loop_base_info);
+}
+type_init(register_types);
diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/module.h"
 #include "block/aio.h"
 #include "block/block.h"
+#include "sysemu/event-loop-base.h"
 #include "sysemu/iothread.h"
 #include "qapi/error.h"
 #include "qapi/qapi-commands-misc.h"
@@ -XXX,XX +XXX,XX @@ static void iothread_init_gcontext(IOThread *iothread)
     iothread->main_loop = g_main_loop_new(iothread->worker_context, TRUE);
 }
 
-static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
+static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
 {
+    IOThread *iothread = IOTHREAD(base);
     ERRP_GUARD();
 
+    if (!iothread->ctx) {
+        return;
+    }
+
     aio_context_set_poll_params(iothread->ctx,
                                 iothread->poll_max_ns,
                                 iothread->poll_grow,
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
     }
 
     aio_context_set_aio_params(iothread->ctx,
-                               iothread->aio_max_batch,
+                               iothread->parent_obj.aio_max_batch,
                                errp);
 }
 
-static void iothread_complete(UserCreatable *obj, Error **errp)
+
+static void iothread_init(EventLoopBase *base, Error **errp)
 {
     Error *local_error = NULL;
-    IOThread *iothread = IOTHREAD(obj);
+    IOThread *iothread = IOTHREAD(base);
     char *thread_name;
 
     iothread->stopping = false;
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
      */
     iothread_init_gcontext(iothread);
 
-    iothread_set_aio_context_params(iothread, &local_error);
+    iothread_set_aio_context_params(base, &local_error);
     if (local_error) {
         error_propagate(errp, local_error);
         aio_context_unref(iothread->ctx);
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
      * to inherit.
      */
     thread_name = g_strdup_printf("IO %s",
-                        object_get_canonical_path_component(OBJECT(obj)));
+                        object_get_canonical_path_component(OBJECT(base)));
     qemu_thread_create(&iothread->thread, thread_name, iothread_run,
                        iothread, QEMU_THREAD_JOINABLE);
     g_free(thread_name);
@@ -XXX,XX +XXX,XX @@ static IOThreadParamInfo poll_grow_info = {
 static IOThreadParamInfo poll_shrink_info = {
     "poll-shrink", offsetof(IOThread, poll_shrink),
 };
-static IOThreadParamInfo aio_max_batch_info = {
-    "aio-max-batch", offsetof(IOThread, aio_max_batch),
-};
 
 static void iothread_get_param(Object *obj, Visitor *v,
         const char *name, IOThreadParamInfo *info, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
     }
 }
 
-static void iothread_get_aio_param(Object *obj, Visitor *v,
-        const char *name, void *opaque, Error **errp)
-{
-    IOThreadParamInfo *info = opaque;
-
-    iothread_get_param(obj, v, name, info, errp);
-}
-
-static void iothread_set_aio_param(Object *obj, Visitor *v,
-        const char *name, void *opaque, Error **errp)
-{
-    IOThread *iothread = IOTHREAD(obj);
-    IOThreadParamInfo *info = opaque;
-
-    if (!iothread_set_param(obj, v, name, info, errp)) {
-        return;
-    }
-
-    if (iothread->ctx) {
-        aio_context_set_aio_params(iothread->ctx,
-                                   iothread->aio_max_batch,
-                                   errp);
-    }
-}
-
 static void iothread_class_init(ObjectClass *klass, void *class_data)
 {
-    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-    ucc->complete = iothread_complete;
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(klass);
+
+    bc->init = iothread_init;
+    bc->update_params = iothread_set_aio_context_params;
 
     object_class_property_add(klass, "poll-max-ns", "int",
                               iothread_get_poll_param,
@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *class_data)
                               iothread_get_poll_param,
                               iothread_set_poll_param,
                               NULL, &poll_shrink_info);
-    object_class_property_add(klass, "aio-max-batch", "int",
-                              iothread_get_aio_param,
-                              iothread_set_aio_param,
-                              NULL, &aio_max_batch_info);
 }
 
 static const TypeInfo iothread_info = {
     .name = TYPE_IOTHREAD,
-    .parent = TYPE_OBJECT,
+    .parent = TYPE_EVENT_LOOP_BASE,
     .class_init = iothread_class_init,
     .instance_size = sizeof(IOThread),
     .instance_init = iothread_instance_init,
     .instance_finalize = iothread_instance_finalize,
-    .interfaces = (InterfaceInfo[]) {
-        {TYPE_USER_CREATABLE},
-        {}
-    },
 };
 
 static void iothread_register_types(void)
@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)
     info->poll_max_ns = iothread->poll_max_ns;
     info->poll_grow = iothread->poll_grow;
     info->poll_shrink = iothread->poll_shrink;
-    info->aio_max_batch = iothread->aio_max_batch;
+    info->aio_max_batch = iothread->parent_obj.aio_max_batch;
 
     QAPI_LIST_APPEND(*tail, info);
     return 0;
-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

'event-loop-base' provides basic property handling for all 'AioContext'
based event loops. So let's define a new 'MainLoopClass' that inherits
from it. This will permit tweaking the main loop's properties through
qapi as well as through the command line using the '-object' keyword[1].
Only one instance of 'MainLoopClass' might be created at any time.

'EventLoopBaseClass' learns a new callback, 'can_be_deleted()' so as to
mark 'MainLoop' as non-deletable.

[1] For example:
      -object main-loop,id=main-loop,aio-max-batch=<value>

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-3-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    | 13 ++++++++
 meson.build                      |  3 +-
 include/qemu/main-loop.h         | 10 ++++++
 include/sysemu/event-loop-base.h |  1 +
 event-loop-base.c                | 13 ++++++++
 util/main-loop.c                 | 56 ++++++++++++++++++++++++++++++++
 6 files changed, 95 insertions(+), 1 deletion(-)

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
             '*poll-grow': 'int',
             '*poll-shrink': 'int' } }
 
+##
+# @MainLoopProperties:
+#
+# Properties for the main-loop object.
+#
+# Since: 7.1
+##
+{ 'struct': 'MainLoopProperties',
+  'base': 'EventLoopBaseProperties',
+  'data': {} }
+
 ##
 # @MemoryBackendProperties:
 #
@@ -XXX,XX +XXX,XX @@
     { 'name': 'input-linux',
       'if': 'CONFIG_LINUX' },
     'iothread',
+    'main-loop',
     { 'name': 'memory-backend-epc',
       'if': 'CONFIG_LINUX' },
     'memory-backend-file',
@@ -XXX,XX +XXX,XX @@
       'input-linux':                { 'type': 'InputLinuxProperties',
                                       'if': 'CONFIG_LINUX' },
       'iothread':                   'IothreadProperties',
+      'main-loop':                  'MainLoopProperties',
       'memory-backend-epc':         { 'type': 'MemoryBackendEpcProperties',
                                       'if': 'CONFIG_LINUX' },
       'memory-backend-file':        'MemoryBackendFileProperties',
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ libqemuutil = static_library('qemuutil',
                              sources: util_ss.sources() + stub_ss.sources() + genh,
                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
 qemuutil = declare_dependency(link_with: libqemuutil,
-                              sources: genh + version_res)
+                              sources: genh + version_res,
+                              dependencies: [event_loop_base])
 
 if have_system or have_user
   decodetree = generator(find_program('scripts/decodetree.py'),
diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/main-loop.h
+++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@
 #define QEMU_MAIN_LOOP_H
 
 #include "block/aio.h"
+#include "qom/object.h"
+#include "sysemu/event-loop-base.h"
 
 #define SIG_IPI SIGUSR1
 
+#define TYPE_MAIN_LOOP  "main-loop"
+OBJECT_DECLARE_TYPE(MainLoop, MainLoopClass, MAIN_LOOP)
+
+struct MainLoop {
+    EventLoopBase parent_obj;
+};
+typedef struct MainLoop MainLoop;
+
 /**
  * qemu_init_main_loop: Set up the process so that it can run the main loop.
  *
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/event-loop-base.h
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBaseClass {
 
     void (*init)(EventLoopBase *base, Error **errp);
     void (*update_params)(EventLoopBase *base, Error **errp);
+    bool (*can_be_deleted)(EventLoopBase *base);
 };
 
 struct EventLoopBase {
diff --git a/event-loop-base.c b/event-loop-base.c
index XXXXXXX..XXXXXXX 100644
--- a/event-loop-base.c
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_complete(UserCreatable *uc, Error **errp)
     }
 }
 
+static bool event_loop_base_can_be_deleted(UserCreatable *uc)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
+    EventLoopBase *backend = EVENT_LOOP_BASE(uc);
+
+    if (bc->can_be_deleted) {
+        return bc->can_be_deleted(backend);
+    }
+
+    return true;
+}
+
 static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
 {
     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
     ucc->complete = event_loop_base_complete;
+    ucc->can_be_deleted = event_loop_base_can_be_deleted;
 
     object_class_property_add(klass, "aio-max-batch", "int",
                               event_loop_base_get_param,
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/error-report.h"
 #include "qemu/queue.h"
 #include "qemu/compiler.h"
+#include "qom/object.h"
 
 #ifndef _WIN32
 #include <sys/wait.h>
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
     return 0;
 }
 
+static void main_loop_update_params(EventLoopBase *base, Error **errp)
+{
+    if (!qemu_aio_context) {
+        error_setg(errp, "qemu aio context not ready");
+        return;
+    }
+
+    aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
+}
+
+MainLoop *mloop;
+
+static void main_loop_init(EventLoopBase *base, Error **errp)
+{
+    MainLoop *m = MAIN_LOOP(base);
+
+    if (mloop) {
+        error_setg(errp, "only one main-loop instance allowed");
+        return;
+    }
+
+    main_loop_update_params(base, errp);
+
+    mloop = m;
+    return;
+}
+
+static bool main_loop_can_be_deleted(EventLoopBase *base)
+{
+    return false;
+}
+
+static void main_loop_class_init(ObjectClass *oc, void *class_data)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(oc);
+
+    bc->init = main_loop_init;
+    bc->update_params = main_loop_update_params;
+    bc->can_be_deleted = main_loop_can_be_deleted;
+}
+
+static const TypeInfo main_loop_info = {
+    .name = TYPE_MAIN_LOOP,
+    .parent = TYPE_EVENT_LOOP_BASE,
+    .class_init = main_loop_class_init,
+    .instance_size = sizeof(MainLoop),
+};
+
+static void main_loop_register_types(void)
+{
+    type_register_static(&main_loop_info);
+}
+
+type_init(main_loop_register_types)
+
 static int max_priority;
 
 #ifndef _WIN32
-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

The thread pool regulates itself: when idle, it kills threads until
empty, when in demand, it creates new threads until full. This behaviour
doesn't play well with latency sensitive workloads where the price of
creating a new thread is too high. For example, when paired with qemu's
'-mlock', or using safety features like SafeStack, creating a new thread
has been measured take multiple milliseconds.

In order to mitigate this let's introduce a new 'EventLoopBase'
property to set the thread pool size. The threads will be created during
the pool's initialization or upon updating the property's value, remain
available during its lifetime regardless of demand, and destroyed upon
freeing it. A properly characterized workload will then be able to
configure the pool to avoid any latency spikes.

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-4-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    | 10 +++++-
 include/block/aio.h              | 10 ++++++
 include/block/thread-pool.h      |  3 ++
 include/sysemu/event-loop-base.h |  4 +++
 event-loop-base.c                | 23 +++++++++++++
 iothread.c                       |  3 ++
 util/aio-posix.c                 |  1 +
 util/async.c                     | 20 ++++++++++++
 util/main-loop.c                 |  9 ++++++
 util/thread-pool.c               | 55 +++++++++++++++++++++++++++++---
 10 files changed, 133 insertions(+), 5 deletions(-)

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
 #                 0 means that the engine will use its default.
 #                 (default: 0)
 #
+# @thread-pool-min: minimum number of threads reserved in the thread pool
+#                   (default:0)
+#
+# @thread-pool-max: maximum number of threads the thread pool can contain
+#                   (default:64)
+#
 # Since: 7.1
 ##
 { 'struct': 'EventLoopBaseProperties',
-  'data': { '*aio-max-batch': 'int' } }
+  'data': { '*aio-max-batch': 'int',
+            '*thread-pool-min': 'int',
+            '*thread-pool-max': 'int' } }
 
 ##
 # @IothreadProperties:
diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ struct AioContext {
     QSLIST_HEAD(, Coroutine) scheduled_coroutines;
     QEMUBH *co_schedule_bh;
 
+    int thread_pool_min;
+    int thread_pool_max;
     /* Thread pool for performing work and receiving completion callbacks.
      * Has its own locking.
      */
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
 void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
                                 Error **errp);
 
+/**
+ * aio_context_set_thread_pool_params:
+ * @ctx: the aio context
+ * @min: min number of threads to have readily available in the thread pool
+ * @min: max number of threads the thread pool can contain
+ */
+void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
+                                        int64_t max, Error **errp);
 #endif
diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/thread-pool.h
+++ b/include/block/thread-pool.h
@@ -XXX,XX +XXX,XX @@
 
 #include "block/block.h"
 
+#define THREAD_POOL_MAX_THREADS_DEFAULT         64
+
 typedef int ThreadPoolFunc(void *opaque);
 
 typedef struct ThreadPool ThreadPool;
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
 int coroutine_fn thread_pool_submit_co(ThreadPool *pool,
         ThreadPoolFunc *func, void *arg);
 void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg);
+void thread_pool_update_params(ThreadPool *pool, struct AioContext *ctx);
 
 #endif
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/event-loop-base.h
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBase {
 
     /* AioContext AIO engine parameters */
     int64_t aio_max_batch;
+
+    /* AioContext thread pool parameters */
+    int64_t thread_pool_min;
+    int64_t thread_pool_max;
 };
 #endif
diff --git a/event-loop-base.c b/event-loop-base.c
index XXXXXXX..XXXXXXX 100644
--- a/event-loop-base.c
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "qom/object_interfaces.h"
 #include "qapi/error.h"
+#include "block/thread-pool.h"
 #include "sysemu/event-loop-base.h"
 
 typedef struct {
@@ -XXX,XX +XXX,XX @@ typedef struct {
     ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
 } EventLoopBaseParamInfo;
 
+static void event_loop_base_instance_init(Object *obj)
+{
+    EventLoopBase *base = EVENT_LOOP_BASE(obj);
+
+    base->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
+}
+
 static EventLoopBaseParamInfo aio_max_batch_info = {
     "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
 };
+static EventLoopBaseParamInfo thread_pool_min_info = {
+    "thread-pool-min", offsetof(EventLoopBase, thread_pool_min),
+};
+static EventLoopBaseParamInfo thread_pool_max_info = {
+    "thread-pool-max", offsetof(EventLoopBase, thread_pool_max),
+};
 
 static void event_loop_base_get_param(Object *obj, Visitor *v,
         const char *name, void *opaque, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
                               event_loop_base_get_param,
                               event_loop_base_set_param,
                               NULL, &aio_max_batch_info);
+    object_class_property_add(klass, "thread-pool-min", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &thread_pool_min_info);
+    object_class_property_add(klass, "thread-pool-max", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &thread_pool_max_info);
 }
 
 static const TypeInfo event_loop_base_info = {
     .name = TYPE_EVENT_LOOP_BASE,
     .parent = TYPE_OBJECT,
     .instance_size = sizeof(EventLoopBase),
+    .instance_init = event_loop_base_instance_init,
     .class_size = sizeof(EventLoopBaseClass),
     .class_init = event_loop_base_class_init,
     .abstract = true,
diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
     aio_context_set_aio_params(iothread->ctx,
                                iothread->parent_obj.aio_max_batch,
                                errp);
+
+    aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_min,
+                                       base->thread_pool_max, errp);
 }
 
 
diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "block/block.h"
+#include "block/thread-pool.h"
 #include "qemu/main-loop.h"
 #include "qemu/rcu.h"
 #include "qemu/rcu_queue.h"
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
 
     ctx->aio_max_batch = 0;
 
+    ctx->thread_pool_min = 0;
+    ctx->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
+
     return ctx;
 fail:
     g_source_destroy(&ctx->source);
@@ -XXX,XX +XXX,XX @@ void qemu_set_current_aio_context(AioContext *ctx)
     assert(!get_my_aiocontext());
     set_my_aiocontext(ctx);
 }
+
+void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
+                                        int64_t max, Error **errp)
+{
+
+    if (min > max || !max || min > INT_MAX || max > INT_MAX) {
+        error_setg(errp, "bad thread-pool-min/thread-pool-max values");
+        return;
+    }
+
+    ctx->thread_pool_min = min;
+    ctx->thread_pool_max = max;
+
+    if (ctx->thread_pool) {
+        thread_pool_update_params(ctx->thread_pool, ctx);
+    }
+}
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/replay.h"
 #include "qemu/main-loop.h"
 #include "block/aio.h"
+#include "block/thread-pool.h"
 #include "qemu/error-report.h"
 #include "qemu/queue.h"
 #include "qemu/compiler.h"
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
 
 static void main_loop_update_params(EventLoopBase *base, Error **errp)
 {
+    ERRP_GUARD();
+
     if (!qemu_aio_context) {
         error_setg(errp, "qemu aio context not ready");
         return;
     }
 
     aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
+    if (*errp) {
+        return;
+    }
+
+    aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool_min,
+                                       base->thread_pool_max, errp);
 }
 
 MainLoop *mloop;
diff --git a/util/thread-pool.c b/util/thread-pool.c
index XXXXXXX..XXXXXXX 100644
--- a/util/thread-pool.c
+++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
     QemuMutex lock;
     QemuCond worker_stopped;
     QemuSemaphore sem;
-    int max_threads;
     QEMUBH *new_thread_bh;
 
     /* The following variables are only accessed from one AioContext. */
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
     int new_threads;     /* backlog of threads we need to create */
     int pending_threads; /* threads created but not running yet */
     bool stopping;
+    int min_threads;
+    int max_threads;
 };
 
+static inline bool back_to_sleep(ThreadPool *pool, int ret)
+{
+    /*
+     * The semaphore timed out, we should exit the loop except when:
+     *  - There is work to do, we raced with the signal.
+     *  - The max threads threshold just changed, we raced with the signal.
+     *  - The thread pool forces a minimum number of readily available threads.
+     */
+    if (ret == -1 && (!QTAILQ_EMPTY(&pool->request_list) ||
+            pool->cur_threads > pool->max_threads ||
+            pool->cur_threads <= pool->min_threads)) {
+            return true;
+    }
+
+    return false;
+}
+
 static void *worker_thread(void *opaque)
 {
     ThreadPool *pool = opaque;
@@ -XXX,XX +XXX,XX @@ static void *worker_thread(void *opaque)
             ret = qemu_sem_timedwait(&pool->sem, 10000);
             qemu_mutex_lock(&pool->lock);
             pool->idle_threads--;
-        } while (ret == -1 && !QTAILQ_EMPTY(&pool->request_list));
-        if (ret == -1 || pool->stopping) {
+        } while (back_to_sleep(pool, ret));
+        if (ret == -1 || pool->stopping ||
+            pool->cur_threads > pool->max_threads) {
             break;
         }
 
@@ -XXX,XX +XXX,XX @@ void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)
     thread_pool_submit_aio(pool, func, arg, NULL, NULL);
 }
 
+void thread_pool_update_params(ThreadPool *pool, AioContext *ctx)
+{
+    qemu_mutex_lock(&pool->lock);
+
+    pool->min_threads = ctx->thread_pool_min;
+    pool->max_threads = ctx->thread_pool_max;
+
+    /*
+     * We either have to:
+     *  - Increase the number available of threads until over the min_threads
+     *    threshold.
+     *  - Decrease the number of available threads until under the max_threads
+     *    threshold.
+     *  - Do nothing. The current number of threads fall in between the min and
+     *    max thresholds. We'll let the pool manage itself.
+     */
+    for (int i = pool->cur_threads; i < pool->min_threads; i++) {
+        spawn_thread(pool);
+    }
+
+    for (int i = pool->cur_threads; i > pool->max_threads; i--) {
+        qemu_sem_post(&pool->sem);
+    }
+
+    qemu_mutex_unlock(&pool->lock);
+}
+
 static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
 {
     if (!ctx) {
@@ -XXX,XX +XXX,XX @@ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
     qemu_mutex_init(&pool->lock);
     qemu_cond_init(&pool->worker_stopped);
     qemu_sem_init(&pool->sem, 0);
-    pool->max_threads = 64;
     pool->new_thread_bh = aio_bh_new(ctx, spawn_thread_bh_fn, pool);
 
     QLIST_INIT(&pool->head);
     QTAILQ_INIT(&pool->request_list);
+
+    thread_pool_update_params(pool, ctx);
 }
 
 ThreadPool *thread_pool_new(AioContext *ctx)
-- 
2.35.1

The following changes since commit 9548cbeffffd4253e38570d29b8cff0bf77c998f:

iotests/copy-before-write: specify required_fmts (2022-07-12 13:21:02 +0530)

are available in the Git repository at:

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

for you to fetch changes up to 85c4bf8aa6c93c24876e8870ae7cf8ab2e5a96cf:

vl: Unlink absolute PID file path (2022-07-12 14:31:15 +0200)

----------------------------------------------------------------
Block patches:
- Refactoring for non-coroutine variants of bdrv/blk_co_* functions:
  Auto-generate more of them with the block coroutine wrapper generator
  script
- iotest fixes
- Both for the storage daemon and the system emulator: Fix PID file
  handling when daemonizing (store the absolute path and delete that on
  exit, which is necessary because daemonizing will change the working
  directory to /)

----------------------------------------------------------------
Alberto Faria (28):
  block: Add a 'flags' param to bdrv_{pread,pwrite,pwrite_sync}()
  block: Change bdrv_{pread,pwrite,pwrite_sync}() param order
  block: Make bdrv_{pread,pwrite}() return 0 on success
  crypto: Make block callbacks return 0 on success
  block: Make bdrv_co_pwrite() take a const buffer
  block: Make 'bytes' param of bdrv_co_{pread,pwrite,preadv,pwritev}()
    an int64_t
  block: Implement bdrv_{pread,pwrite,pwrite_zeroes}() using
    generated_co_wrapper
  block: Add bdrv_co_pwrite_sync()
  block: Use bdrv_co_pwrite_sync() when caller is coroutine_fn
  block/qcow2: Use bdrv_pwrite_sync() in qcow2_mark_dirty()
  block: Make blk_{pread,pwrite}() return 0 on success
  block: Add a 'flags' param to blk_pread()
  block: Change blk_{pread,pwrite}() param order
  block: Make 'bytes' param of blk_{pread,pwrite}() an int64_t
  block: Make blk_co_pwrite() take a const buffer
  block: Implement blk_{pread,pwrite}() using generated_co_wrapper
  block: Add blk_{preadv,pwritev}()
  block: Add blk_[co_]preadv_part()
  block: Export blk_pwritev_part() in block-backend-io.h
  block: Change blk_pwrite_compressed() param order
  block: Add blk_co_pwrite_compressed()
  block: Implement blk_pwrite_zeroes() using generated_co_wrapper
  block: Implement blk_pdiscard() using generated_co_wrapper
  block: Implement blk_flush() using generated_co_wrapper
  block: Add blk_co_ioctl()
  block: Add blk_co_truncate()
  block: Reorganize some declarations in block-backend-io.h
  block: Remove remaining unused symbols in coroutines.h

Hanna Reitz (5):
  qsd: Do not use error_report() before monitor_init
  iotests/297: Have mypy ignore unused ignores
  qsd: Unlink absolute PID file path
  vl: Conditionally register PID file unlink notifier
  vl: Unlink absolute PID file path

John Snow (2):
  tests/qemu-iotests: hotfix for 307, 223 output
  tests/qemu-iotests: skip 108 when FUSE is not loaded

-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

For consistency with other I/O functions, and in preparation to
implement them using generated_co_wrapper.

Callers were updated using this Coccinelle script:

@@ expression child, offset, buf, bytes; @@
    - bdrv_pread(child, offset, buf, bytes)
    + bdrv_pread(child, offset, buf, bytes, 0)

@@ expression child, offset, buf, bytes; @@
    - bdrv_pwrite(child, offset, buf, bytes)
    + bdrv_pwrite(child, offset, buf, bytes, 0)

@@ expression child, offset, buf, bytes; @@
    - bdrv_pwrite_sync(child, offset, buf, bytes)
    + bdrv_pwrite_sync(child, offset, buf, bytes, 0)

Resulting overly-long lines were then fixed by hand.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Message-Id: <20220609152744.3891847-2-afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/block-io.h         |  7 ++--
 block/blklogwrites.c             |  4 +--
 block/bochs.c                    |  6 ++--
 block/cloop.c                    | 10 +++---
 block/crypto.c                   |  4 +--
 block/dmg.c                      | 24 +++++++-------
 block/io.c                       | 13 ++++----
 block/parallels-ext.c            |  4 +--
 block/parallels.c                | 12 +++----
 block/qcow.c                     | 27 ++++++++-------
 block/qcow2-bitmap.c             | 14 ++++----
 block/qcow2-cache.c              |  7 ++--
 block/qcow2-cluster.c            | 21 ++++++------
 block/qcow2-refcount.c           | 42 +++++++++++------------
 block/qcow2-snapshot.c           | 39 +++++++++++-----------
 block/qcow2.c                    | 44 ++++++++++++------------
 block/qed.c                      |  8 ++---
 block/vdi.c                      | 10 +++---
 block/vhdx-log.c                 | 19 +++++------
 block/vhdx.c                     | 32 ++++++++++--------
 block/vmdk.c                     | 57 ++++++++++++++------------------
 block/vpc.c                      | 19 ++++++-----
 block/vvfat.c                    |  7 ++--
 tests/unit/test-block-iothread.c |  8 ++---
 24 files changed, 219 insertions(+), 219 deletions(-)

diff --git a/include/block/block-io.h b/include/block/block-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -XXX,XX +XXX,XX @@
 int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
                        int64_t bytes, BdrvRequestFlags flags);
 int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
-int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes);
+int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
+               BdrvRequestFlags flags);
 int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
-                int64_t bytes);
+                int64_t bytes, BdrvRequestFlags flags);
 int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
-                     const void *buf, int64_t bytes);
+                     const void *buf, int64_t bytes, BdrvRequestFlags flags);
 /*
  * Efficiently zero a region of the disk image.  Note that this is a regular
  * I/O request like read or write and should have a reasonable size.  This
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index XXXXXXX..XXXXXXX 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -XXX,XX +XXX,XX @@ static uint64_t blk_log_writes_find_cur_log_sector(BdrvChild *log,
 
     while (cur_idx < nr_entries) {
         int read_ret = bdrv_pread(log, cur_sector << sector_bits, &cur_entry,
-                                  sizeof(cur_entry));
+                                  sizeof(cur_entry), 0);
         if (read_ret < 0) {
             error_setg_errno(errp, -read_ret,
                              "Failed to read log entry %"PRIu64, cur_idx);
@@ -XXX,XX +XXX,XX @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
             log_sb.nr_entries = cpu_to_le64(0);
             log_sb.sectorsize = cpu_to_le32(BDRV_SECTOR_SIZE);
         } else {
-            ret = bdrv_pread(s->log_file, 0, &log_sb, sizeof(log_sb));
+            ret = bdrv_pread(s->log_file, 0, &log_sb, sizeof(log_sb), 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "Could not read log superblock");
                 goto fail_log;
diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
+    ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs), 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_bitmap,
-                     s->catalog_size * 4);
+                     s->catalog_size * 4, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
 
     /* read in bitmap for current extent */
     ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8),
-                     &bitmap_entry, 1);
+                     &bitmap_entry, 1, 0);
     if (ret < 0) {
         return ret;
     }
diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     /* read header */
-    ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
+    ret = bdrv_pread(bs->file, 128, &s->block_size, 4, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4);
+    ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
         return -ENOMEM;
     }
 
-    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size);
+    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
         int ret;
         uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];
 
-        ret = bdrv_pread(bs->file, s->offsets[block_num],
-                         s->compressed_block, bytes);
+        ret = bdrv_pread(bs->file, s->offsets[block_num], s->compressed_block,
+                         bytes, 0);
         if (ret != bytes) {
             return -1;
         }
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
     BlockDriverState *bs = opaque;
     ssize_t ret;
 
-    ret = bdrv_pread(bs->file, offset, buf, buflen);
+    ret = bdrv_pread(bs->file, offset, buf, buflen, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return ret;
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_write_func(QCryptoBlock *block,
     BlockDriverState *bs = opaque;
     ssize_t ret;
 
-    ret = bdrv_pwrite(bs->file, offset, buf, buflen);
+    ret = bdrv_pwrite(bs->file, offset, buf, buflen, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not write encryption header");
         return ret;
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int read_uint64(BlockDriverState *bs, int64_t offset, uint64_t *result)
     uint64_t buffer;
     int ret;
 
-    ret = bdrv_pread(bs->file, offset, &buffer, 8);
+    ret = bdrv_pread(bs->file, offset, &buffer, 8, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int read_uint32(BlockDriverState *bs, int64_t offset, uint32_t *result)
     uint32_t buffer;
     int ret;
 
-    ret = bdrv_pread(bs->file, offset, &buffer, 4);
+    ret = bdrv_pread(bs->file, offset, &buffer, 4, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int64_t dmg_find_koly_offset(BdrvChild *file, Error **errp)
         offset = length - 511 - 512;
     }
     length = length < 515 ? length : 515;
-    ret = bdrv_pread(file, offset, buffer, length);
+    ret = bdrv_pread(file, offset, buffer, length, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed while reading UDIF trailer");
         return ret;
@@ -XXX,XX +XXX,XX @@ static int dmg_read_resource_fork(BlockDriverState *bs, DmgHeaderState *ds,
         offset += 4;
 
         buffer = g_realloc(buffer, count);
-        ret = bdrv_pread(bs->file, offset, buffer, count);
+        ret = bdrv_pread(bs->file, offset, buffer, count, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int dmg_read_plist_xml(BlockDriverState *bs, DmgHeaderState *ds,
 
     buffer = g_malloc(info_length + 1);
     buffer[info_length] = '\0';
-    ret = bdrv_pread(bs->file, info_begin, buffer, info_length);
+    ret = bdrv_pread(bs->file, info_begin, buffer, info_length, 0);
     if (ret != info_length) {
         ret = -EINVAL;
         goto fail;
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
         case UDZO: { /* zlib compressed */
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk],
-                             s->compressed_chunk, s->lengths[chunk]);
+            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
+                             s->lengths[chunk], 0);
             if (ret != s->lengths[chunk]) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             }
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk],
-                             s->compressed_chunk, s->lengths[chunk]);
+            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
+                             s->lengths[chunk], 0);
             if (ret != s->lengths[chunk]) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             }
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk],
-                             s->compressed_chunk, s->lengths[chunk]);
+            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
+                             s->lengths[chunk], 0);
             if (ret != s->lengths[chunk]) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             break;
         case UDRW: /* copy */
             ret = bdrv_pread(bs->file, s->offsets[chunk],
-                             s->uncompressed_chunk, s->lengths[chunk]);
+                             s->uncompressed_chunk, s->lengths[chunk], 0);
             if (ret != s->lengths[chunk]) {
                 return -1;
             }
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
 }
 
 /* See bdrv_pwrite() for the return codes */
-int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes)
+int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
+               BdrvRequestFlags flags)
 {
     int ret;
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes)
         return -EINVAL;
     }
 
-    ret = bdrv_preadv(child, offset, bytes, &qiov,  0);
+    ret = bdrv_preadv(child, offset, bytes, &qiov, flags);
 
     return ret < 0 ? ret : bytes;
 }
@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes)
   -EACCES      Trying to write a read-only device
 */
 int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
-                int64_t bytes)
+                int64_t bytes, BdrvRequestFlags flags)
 {
     int ret;
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
@@ -XXX,XX +XXX,XX @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
         return -EINVAL;
     }
 
-    ret = bdrv_pwritev(child, offset, bytes, &qiov, 0);
+    ret = bdrv_pwritev(child, offset, bytes, &qiov, flags);
 
     return ret < 0 ? ret : bytes;
 }
@@ -XXX,XX +XXX,XX @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
  * Returns 0 on success, -errno in error cases.
  */
 int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
-                     const void *buf, int64_t count)
+                     const void *buf, int64_t count, BdrvRequestFlags flags)
 {
     int ret;
     IO_CODE();
 
-    ret = bdrv_pwrite(child, offset, buf, count);
+    ret = bdrv_pwrite(child, offset, buf, count, flags);
     if (ret < 0) {
         return ret;
     }
diff --git a/block/parallels-ext.c b/block/parallels-ext.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels-ext.c
+++ b/block/parallels-ext.c
@@ -XXX,XX +XXX,XX @@ static int parallels_load_bitmap_data(BlockDriverState *bs,
             bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
         } else {
             ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS, buf,
-                             s->cluster_size);
+                             s->cluster_size, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret,
                                  "Failed to read bitmap data cluster");
@@ -XXX,XX +XXX,XX @@ int parallels_read_format_extension(BlockDriverState *bs,
 
     assert(ext_off > 0);
 
-    ret = bdrv_pread(bs->file, ext_off, ext_cluster, s->cluster_size);
+    ret = bdrv_pread(bs->file, ext_off, ext_cluster, s->cluster_size, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to read Format Extension cluster");
         goto out;
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs)
         if (off + to_write > s->header_size) {
             to_write = s->header_size - off;
         }
-        ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off,
-                          to_write);
+        ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off, to_write,
+                          0);
         if (ret < 0) {
             qemu_co_mutex_unlock(&s->lock);
             return ret;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
 
     ret = 0;
     if (flush_bat) {
-        ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size);
+        ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size, 0);
         if (ret < 0) {
             res->check_errors++;
             goto out;
@@ -XXX,XX +XXX,XX @@ static int parallels_update_header(BlockDriverState *bs)
     if (size > s->header_size) {
         size = s->header_size;
     }
-    return bdrv_pwrite_sync(bs->file, 0, s->header, size);
+    return bdrv_pwrite_sync(bs->file, 0, s->header, size, 0);
 }
 
 static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph));
+    ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph), 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
         s->header_size = size;
     }
 
-    ret = bdrv_pread(bs->file, 0, s->header, s->header_size);
+    ret = bdrv_pread(bs->file, 0, s->header, s->header_size, 0);
     if (ret < 0) {
         goto fail;
     }
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
+    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
-               s->l1_size * sizeof(uint64_t));
+                     s->l1_size * sizeof(uint64_t), 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
             goto fail;
         }
         ret = bdrv_pread(bs->file, header.backing_file_offset,
-                   bs->auto_backing_file, len);
+                         bs->auto_backing_file, len, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
         BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
         ret = bdrv_pwrite_sync(bs->file,
                                s->l1_table_offset + l1_index * sizeof(tmp),
-                               &tmp, sizeof(tmp));
+                               &tmp, sizeof(tmp), 0);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
     if (new_l2_table) {
         memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
         ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
-                               s->l2_size * sizeof(uint64_t));
+                               s->l2_size * sizeof(uint64_t), 0);
         if (ret < 0) {
             return ret;
         }
     } else {
         ret = bdrv_pread(bs->file, l2_offset, l2_table,
-                         s->l2_size * sizeof(uint64_t));
+                         s->l2_size * sizeof(uint64_t), 0);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
             /* write the cluster content */
             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
             ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache,
-                              s->cluster_size);
+                              s->cluster_size, 0);
             if (ret < 0) {
                 return ret;
             }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
                                 return -EIO;
                             }
                             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
-                            ret = bdrv_pwrite(bs->file,
-                                              cluster_offset + i,
+                            ret = bdrv_pwrite(bs->file, cluster_offset + i,
                                               s->cluster_data,
-                                              BDRV_SECTOR_SIZE);
+                                              BDRV_SECTOR_SIZE, 0);
                             if (ret < 0) {
                                 return ret;
                             }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
             BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
         }
         ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
-                               &tmp, sizeof(tmp));
+                               &tmp, sizeof(tmp), 0);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
         csize = cluster_offset >> (63 - s->cluster_bits);
         csize &= (s->cluster_size - 1);
         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
-        ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize);
+        ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize, 0);
         if (ret != csize)
             return -1;
         if (decompress_buffer(s->cluster_cache, s->cluster_size,
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
     int ret;
 
     memset(s->l1_table, 0, l1_length);
-    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table,
-            l1_length) < 0)
+    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table, l1_length,
+                         0) < 0)
         return -1;
     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
                         PREALLOC_MODE_OFF, 0, NULL);
diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-bitmap.c
+++ b/block/qcow2-bitmap.c
@@ -XXX,XX +XXX,XX @@ static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
     }
 
     assert(tb->size <= BME_MAX_TABLE_SIZE);
-    ret = bdrv_pread(bs->file, tb->offset,
-                     table, tb->size * BME_TABLE_ENTRY_SIZE);
+    ret = bdrv_pread(bs->file, tb->offset, table,
+                     tb->size * BME_TABLE_ENTRY_SIZE, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int load_bitmap_data(BlockDriverState *bs,
                  * already cleared */
             }
         } else {
-            ret = bdrv_pread(bs->file, data_offset, buf, s->cluster_size);
+            ret = bdrv_pread(bs->file, data_offset, buf, s->cluster_size, 0);
             if (ret < 0) {
                 goto finish;
             }
@@ -XXX,XX +XXX,XX @@ static Qcow2BitmapList *bitmap_list_load(BlockDriverState *bs, uint64_t offset,
     }
     dir_end = dir + size;
 
-    ret = bdrv_pread(bs->file, offset, dir, size);
+    ret = bdrv_pread(bs->file, offset, dir, size, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to read bitmap directory");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list,
         goto fail;
     }
 
-    ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size);
+    ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static uint64_t *store_bitmap_data(BlockDriverState *bs,
             goto fail;
         }
 
-        ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size);
+        ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
                              bm_name);
@@ -XXX,XX +XXX,XX @@ static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp)
     }
 
     bitmap_table_to_be(tb, tb_size);
-    ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]));
+    ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]), 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
                          bm_name);
diff --git a/block/qcow2-cache.c b/block/qcow2-cache.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cache.c
+++ b/block/qcow2-cache.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
     }
 
     ret = bdrv_pwrite(bs->file, c->entries[i].offset,
-                      qcow2_cache_get_table_addr(c, i), c->table_size);
+                      qcow2_cache_get_table_addr(c, i), c->table_size, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
             BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
         }
 
-        ret = bdrv_pread(bs->file, offset,
-                         qcow2_cache_get_table_addr(c, i),
-                         c->table_size);
+        ret = bdrv_pread(bs->file, offset, qcow2_cache_get_table_addr(c, i),
+                         c->table_size, 0);
         if (ret < 0) {
             return ret;
         }
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE);
     for(i = 0; i < s->l1_size; i++)
         new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
-    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset,
-                           new_l1_table, new_l1_size2);
+    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, new_l1_table,
+                           new_l1_size2, 0);
     if (ret < 0)
         goto fail;
     for(i = 0; i < s->l1_size; i++)
@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);
     stl_be_p(data, new_l1_size);
     stq_be_p(data + 4, new_l1_table_offset);
-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size),
-                           data, sizeof(data));
+    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size), data,
+                           sizeof(data), 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)
     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
     ret = bdrv_pwrite_sync(bs->file,
                            s->l1_table_offset + L1E_SIZE * l1_start_index,
-                           buf, bufsize);
+                           buf, bufsize, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
                                       (void **)&l2_slice);
             } else {
                 /* load inactive L2 tables from disk */
-                ret = bdrv_pread(bs->file, slice_offset, l2_slice, slice_size2);
+                ret = bdrv_pread(bs->file, slice_offset, l2_slice,
+                                 slice_size2, 0);
             }
             if (ret < 0) {
                 goto fail;
@@ -XXX,XX +XXX,XX @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
                         goto fail;
                     }
 
-                    ret = bdrv_pwrite(bs->file, slice_offset,
-                                      l2_slice, slice_size2);
+                    ret = bdrv_pwrite(bs->file, slice_offset, l2_slice,
+                                      slice_size2, 0);
                     if (ret < 0) {
                         goto fail;
                     }
@@ -XXX,XX +XXX,XX @@ int qcow2_expand_zero_clusters(BlockDriverState *bs,
 
         l1_table = new_l1_table;
 
-        ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset,
-                         l1_table, l1_size2);
+        ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset, l1_table,
+                         l1_size2, 0);
         if (ret < 0) {
             goto fail;
         }
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ int qcow2_refcount_init(BlockDriverState *bs)
         }
         BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
         ret = bdrv_pread(bs->file, s->refcount_table_offset,
-                         s->refcount_table, refcount_table_size2);
+                         s->refcount_table, refcount_table_size2, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,
         BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);
         ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset +
                                refcount_table_index * REFTABLE_ENTRY_SIZE,
-            &data64, sizeof(data64));
+            &data64, sizeof(data64), 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
 
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);
     ret = bdrv_pwrite_sync(bs->file, table_offset, new_table,
-        table_size * REFTABLE_ENTRY_SIZE);
+                           table_size * REFTABLE_ENTRY_SIZE, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
     data.d32 = cpu_to_be32(table_clusters);
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);
     ret = bdrv_pwrite_sync(bs->file,
-                           offsetof(QCowHeader, refcount_table_offset),
-                           &data, sizeof(data));
+                           offsetof(QCowHeader, refcount_table_offset), &data,
+                           sizeof(data), 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
         }
         l1_allocated = true;
 
-        ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2);
+        ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ fail:
             cpu_to_be64s(&l1_table[i]);
         }
 
-        ret = bdrv_pwrite_sync(bs->file, l1_table_offset,
-                               l1_table, l1_size2);
+        ret = bdrv_pwrite_sync(bs->file, l1_table_offset, l1_table, l1_size2,
+                               0);
 
         for (i = 0; i < l1_size; i++) {
             be64_to_cpus(&l1_table[i]);
@@ -XXX,XX +XXX,XX @@ static int fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
     }
 
     ret = bdrv_pwrite_sync(bs->file, l2e_offset, &l2_table[idx],
-                           l2_entry_size(s));
+                           l2_entry_size(s), 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: Failed to overwrite L2 "
                 "table entry: %s\n", strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
     bool metadata_overlap;
 
     /* Read L2 table from disk */
-    ret = bdrv_pread(bs->file, l2_offset, l2_table, l2_size_bytes);
+    ret = bdrv_pread(bs->file, l2_offset, l2_table, l2_size_bytes, 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
         res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
     }
 
     /* Read L1 table entries from disk */
-    ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size_bytes);
+    ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size_bytes, 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
         res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
         }
 
         ret = bdrv_pread(bs->file, l2_offset, l2_table,
-                         s->l2_size * l2_entry_size(s));
+                         s->l2_size * l2_entry_size(s), 0);
         if (ret < 0) {
             fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
                     strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
                 goto fail;
             }
 
-            ret = bdrv_pwrite(bs->file, l2_offset, l2_table,
-                              s->cluster_size);
+            ret = bdrv_pwrite(bs->file, l2_offset, l2_table, s->cluster_size,
+                              0);
             if (ret < 0) {
                 fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
                         strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcounts_write_refblocks(
                                     refblock_index * s->cluster_size);
 
         ret = bdrv_pwrite(bs->file, refblock_offset, on_disk_refblock,
-                          s->cluster_size);
+                          s->cluster_size, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "ERROR writing refblock");
             return ret;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
 
     assert(reftable_length < INT_MAX);
     ret = bdrv_pwrite(bs->file, reftable_offset, on_disk_reftable,
-                      reftable_length);
+                      reftable_length, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "ERROR writing reftable");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
     ret = bdrv_pwrite_sync(bs->file,
                            offsetof(QCowHeader, refcount_table_offset),
                            &reftable_offset_and_clusters,
-                           sizeof(reftable_offset_and_clusters));
+                           sizeof(reftable_offset_and_clusters), 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "ERROR setting reftable");
         goto fail;
@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
                 return -ENOMEM;
             }
 
-            ret = bdrv_pread(bs->file, l1_ofs, l1, l1_sz2);
+            ret = bdrv_pread(bs->file, l1_ofs, l1, l1_sz2, 0);
             if (ret < 0) {
                 g_free(l1);
                 return ret;
@@ -XXX,XX +XXX,XX @@ static int flush_refblock(BlockDriverState *bs, uint64_t **reftable,
             return ret;
         }
 
-        ret = bdrv_pwrite(bs->file, offset, refblock, s->cluster_size);
+        ret = bdrv_pwrite(bs->file, offset, refblock, s->cluster_size, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to write refblock");
             return ret;
@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
     }
 
     ret = bdrv_pwrite(bs->file, new_reftable_offset, new_reftable,
-                      new_reftable_size * REFTABLE_ENTRY_SIZE);
+                      new_reftable_size * REFTABLE_ENTRY_SIZE, 0);
 
     for (i = 0; i < new_reftable_size; i++) {
         be64_to_cpus(&new_reftable[i]);
@@ -XXX,XX +XXX,XX @@ int qcow2_shrink_reftable(BlockDriverState *bs)
     }
 
     ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset, reftable_tmp,
-                           s->refcount_table_size * REFTABLE_ENTRY_SIZE);
+                           s->refcount_table_size * REFTABLE_ENTRY_SIZE, 0);
     /*
      * If the write in the reftable failed the image may contain a partially
      * overwritten reftable. In this case it would be better to clear the
diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-snapshot.c
+++ b/block/qcow2-snapshot.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
 
         /* Read statically sized part of the snapshot header */
         offset = ROUND_UP(offset, 8);
-        ret = bdrv_pread(bs->file, offset, &h, sizeof(h));
+        ret = bdrv_pread(bs->file, offset, &h, sizeof(h), 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read snapshot table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
 
         /* Read known extra data */
         ret = bdrv_pread(bs->file, offset, &extra,
-                         MIN(sizeof(extra), sn->extra_data_size));
+                         MIN(sizeof(extra), sn->extra_data_size), 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read snapshot table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
             unknown_extra_data_size = sn->extra_data_size - sizeof(extra);
             sn->unknown_extra_data = g_malloc(unknown_extra_data_size);
             ret = bdrv_pread(bs->file, offset, sn->unknown_extra_data,
-                             unknown_extra_data_size);
+                             unknown_extra_data_size, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret,
                                  "Failed to read snapshot table");
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
 
         /* Read snapshot ID */
         sn->id_str = g_malloc(id_str_size + 1);
-        ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size);
+        ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read snapshot table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
 
         /* Read snapshot name */
         sn->name = g_malloc(name_size + 1);
-        ret = bdrv_pread(bs->file, offset, sn->name, name_size);
+        ret = bdrv_pread(bs->file, offset, sn->name, name_size, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read snapshot table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
         h.name_size = cpu_to_be16(name_size);
         offset = ROUND_UP(offset, 8);
 
-        ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h));
+        ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h), 0);
         if (ret < 0) {
             goto fail;
         }
         offset += sizeof(h);
 
-        ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra));
+        ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra), 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
             assert(sn->unknown_extra_data);
 
             ret = bdrv_pwrite(bs->file, offset, sn->unknown_extra_data,
-                              unknown_extra_data_size);
+                              unknown_extra_data_size, 0);
             if (ret < 0) {
                 goto fail;
             }
             offset += unknown_extra_data_size;
         }
 
-        ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size);
+        ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size, 0);
         if (ret < 0) {
             goto fail;
         }
         offset += id_str_size;
 
-        ret = bdrv_pwrite(bs->file, offset, sn->name, name_size);
+        ret = bdrv_pwrite(bs->file, offset, sn->name, name_size, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
     header_data.snapshots_offset    = cpu_to_be64(snapshots_offset);
 
     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
-                           &header_data, sizeof(header_data));
+                           &header_data, sizeof(header_data), 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
 
     /* qcow2_do_open() discards this information in check mode */
     ret = bdrv_pread(bs->file, offsetof(QCowHeader, nb_snapshots),
-                     &snapshot_table_pointer, sizeof(snapshot_table_pointer));
+                     &snapshot_table_pointer, sizeof(snapshot_table_pointer),
+                     0);
     if (ret < 0) {
         result->check_errors++;
         fprintf(stderr, "ERROR failed to read the snapshot table pointer from "
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
         snapshot_table_pointer.nb_snapshots = cpu_to_be32(s->nb_snapshots);
         ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
                                &snapshot_table_pointer.nb_snapshots,
-                               sizeof(snapshot_table_pointer.nb_snapshots));
+                               sizeof(snapshot_table_pointer.nb_snapshots), 0);
         if (ret < 0) {
             result->check_errors++;
             fprintf(stderr, "ERROR failed to update the snapshot count in the "
@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
     }
 
     ret = bdrv_pwrite(bs->file, sn->l1_table_offset, l1_table,
-                      s->l1_size * L1E_SIZE);
+                      s->l1_size * L1E_SIZE, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, sn->l1_table_offset,
-                     sn_l1_table, sn_l1_bytes);
+    ret = bdrv_pread(bs->file, sn->l1_table_offset, sn_l1_table, sn_l1_bytes,
+                     0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
     }
 
     ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, sn_l1_table,
-                           cur_l1_bytes);
+                           cur_l1_bytes, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
         return -ENOMEM;
     }
 
-    ret = bdrv_pread(bs->file, sn->l1_table_offset,
-                     new_l1_table, new_l1_bytes);
+    ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_table,
+                     new_l1_bytes, 0);
     if (ret < 0) {
         error_setg(errp, "Failed to read l1 table for snapshot");
         qemu_vfree(new_l1_table);
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
         return -1;
     }
 
-    ret = bdrv_pread(bs->file,
-                     s->crypto_header.offset + offset, buf, buflen);
+    ret = bdrv_pread(bs->file, s->crypto_header.offset + offset, buf, buflen,
+                     0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return -1;
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
         return -1;
     }
 
-    ret = bdrv_pwrite(bs->file,
-                      s->crypto_header.offset + offset, buf, buflen);
+    ret = bdrv_pwrite(bs->file, s->crypto_header.offset + offset, buf, buflen,
+                      0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return -1;
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
         printf("attempting to read extended header in offset %lu\n", offset);
 #endif
 
-        ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext));
+        ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext), 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
                              "pread fail from offset %" PRIu64, offset);
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                            sizeof(bs->backing_format));
                 return 2;
             }
-            ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len);
+            ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
                                  "Could not read format name");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
             if (p_feature_table != NULL) {
                 void *feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
-                ret = bdrv_pread(bs->file, offset , feature_table, ext.len);
+                ret = bdrv_pread(bs->file, offset, feature_table, ext.len, 0);
                 if (ret < 0) {
                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
                                      "Could not read table");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                 return -EINVAL;
             }
 
-            ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len);
+            ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret,
                                  "Unable to read CRYPTO header extension");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                 break;
             }
 
-            ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len);
+            ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "bitmaps_ext: "
                                  "Could not read ext header");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
         case QCOW2_EXT_MAGIC_DATA_FILE:
         {
             s->image_data_file = g_malloc0(ext.len + 1);
-            ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len);
+            ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret,
                                  "ERROR: Could not read data file name");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                 uext->len = ext.len;
                 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
 
-                ret = bdrv_pread(bs->file, offset , uext->data, uext->len);
+                ret = bdrv_pread(bs->file, offset, uext->data, uext->len, 0);
                 if (ret < 0) {
                     error_setg_errno(errp, -ret, "ERROR: unknown extension: "
                                      "Could not read data");
@@ -XXX,XX +XXX,XX @@ int qcow2_mark_dirty(BlockDriverState *bs)
 
     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
     ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
-                      &val, sizeof(val));
+                      &val, sizeof(val), 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
     uint64_t l1_vm_state_index;
     bool update_header = false;
 
-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
+    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read qcow2 header");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
         s->unknown_header_fields_size = header.header_length - sizeof(header);
         s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
         ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
-                         s->unknown_header_fields_size);
+                         s->unknown_header_fields_size, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
                              "fields");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
             goto fail;
         }
         ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
-                         s->l1_size * L1E_SIZE);
+                         s->l1_size * L1E_SIZE, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Could not read L1 table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
             goto fail;
         }
         ret = bdrv_pread(bs->file, header.backing_file_offset,
-                         bs->auto_backing_file, len);
+                         bs->auto_backing_file, len, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Could not read backing file name");
             goto fail;
@@ -XXX,XX +XXX,XX @@ int qcow2_update_header(BlockDriverState *bs)
     }
 
     /* Write the new header */
-    ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size);
+    ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
 
     /* write updated header.size */
     offset = cpu_to_be64(offset);
-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
-                           &offset, sizeof(offset));
+    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), &offset,
+                           sizeof(offset), 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to update the image size");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
     l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
     l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
-                           &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls));
+                           &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls), 0);
     if (ret < 0) {
         goto fail_broken_refcounts;
     }
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
 
     /* Enter the first refblock into the reftable */
     rt_entry = cpu_to_be64(2 * s->cluster_size);
-    ret = bdrv_pwrite_sync(bs->file, s->cluster_size,
-                           &rt_entry, sizeof(rt_entry));
+    ret = bdrv_pwrite_sync(bs->file, s->cluster_size, &rt_entry,
+                           sizeof(rt_entry), 0);
     if (ret < 0) {
         goto fail_broken_refcounts;
     }
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ int qed_write_header_sync(BDRVQEDState *s)
     int ret;
 
     qed_header_cpu_to_le(&s->header, &le);
-    ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le));
+    ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le), 0);
     if (ret != sizeof(le)) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int qed_read_string(BdrvChild *file, uint64_t offset, size_t n,
     if (n >= buflen) {
         return -EINVAL;
     }
-    ret = bdrv_pread(file, offset, buf, n);
+    ret = bdrv_pread(file, offset, buf, n, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_do_open(BlockDriverState *bs, QDict *options,
     int64_t file_size;
     int ret;
 
-    ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header));
+    ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header), 0);
     if (ret < 0) {
         error_setg(errp, "Failed to read QED header");
         return ret;
@@ -XXX,XX +XXX,XX @@ static int bdrv_qed_change_backing_file(BlockDriverState *bs,
     }
 
     /* Write new header */
-    ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len);
+    ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len, 0);
     g_free(buffer);
     if (ret == 0) {
         memcpy(&s->header, &new_header, sizeof(new_header));
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
 
     logout("\n");
 
-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
+    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     ret = bdrv_pread(bs->file, header.offset_bmap, s->bmap,
-                     bmap_size * SECTOR_SIZE);
+                     bmap_size * SECTOR_SIZE, 0);
     if (ret < 0) {
         goto fail_free_bmap;
     }
@@ -XXX,XX +XXX,XX @@ vdi_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
              * so this full-cluster write does not overlap a partial write
              * of the same cluster, issued from the "else" branch.
              */
-            ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size);
+            ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size, 0);
             qemu_co_rwlock_unlock(&s->bmap_lock);
         } else {
 nonallocating_write:
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
         assert(VDI_IS_ALLOCATED(bmap_first));
         *header = s->header;
         vdi_header_to_le(header);
-        ret = bdrv_pwrite(bs->file, 0, header, sizeof(*header));
+        ret = bdrv_pwrite(bs->file, 0, header, sizeof(*header), 0);
         g_free(header);
 
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
         logout("will write %u block map sectors starting from entry %u\n",
                n_sectors, bmap_first);
         ret = bdrv_pwrite(bs->file, offset * SECTOR_SIZE, base,
-                          n_sectors * SECTOR_SIZE);
+                          n_sectors * SECTOR_SIZE, 0);
     }
 
     return ret < 0 ? ret : 0;
diff --git a/block/vhdx-log.c b/block/vhdx-log.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx-log.c
+++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_peek_hdr(BlockDriverState *bs, VHDXLogEntries *log,
 
     offset = log->offset + read;
 
-    ret = bdrv_pread(bs->file, offset, hdr, sizeof(VHDXLogEntryHeader));
+    ret = bdrv_pread(bs->file, offset, hdr, sizeof(VHDXLogEntryHeader), 0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_read_sectors(BlockDriverState *bs, VHDXLogEntries *log,
         }
         offset = log->offset + read;
 
-        ret = bdrv_pread(bs->file, offset, buffer, VHDX_LOG_SECTOR_SIZE);
+        ret = bdrv_pread(bs->file, offset, buffer, VHDX_LOG_SECTOR_SIZE, 0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
             /* full */
             break;
         }
-        ret = bdrv_pwrite(bs->file, offset, buffer_tmp,
-                          VHDX_LOG_SECTOR_SIZE);
+        ret = bdrv_pwrite(bs->file, offset, buffer_tmp, VHDX_LOG_SECTOR_SIZE,
+                          0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush_desc(BlockDriverState *bs, VHDXLogDescriptor *desc,
     /* count is only > 1 if we are writing zeroes */
     for (i = 0; i < count; i++) {
         ret = bdrv_pwrite_sync(bs->file, file_offset, buffer,
-                               VHDX_LOG_SECTOR_SIZE);
+                               VHDX_LOG_SECTOR_SIZE, 0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
         if (i == 0 && leading_length) {
             /* partial sector at the front of the buffer */
             ret = bdrv_pread(bs->file, file_offset, merged_sector,
-                             VHDX_LOG_SECTOR_SIZE);
+                             VHDX_LOG_SECTOR_SIZE, 0);
             if (ret < 0) {
                 goto exit;
             }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
             sector_write = merged_sector;
         } else if (i == sectors - 1 && trailing_length) {
             /* partial sector at the end of the buffer */
-            ret = bdrv_pread(bs->file,
-                            file_offset,
-                            merged_sector + trailing_length,
-                            VHDX_LOG_SECTOR_SIZE - trailing_length);
+            ret = bdrv_pread(bs->file, file_offset,
+                             merged_sector + trailing_length,
+                             VHDX_LOG_SECTOR_SIZE - trailing_length, 0);
             if (ret < 0) {
                 goto exit;
             }
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr,
     buffer = qemu_blockalign(bs_file, VHDX_HEADER_SIZE);
     if (read) {
         /* if true, we can't assume the extra reserved bytes are 0 */
-        ret = bdrv_pread(file, offset, buffer, VHDX_HEADER_SIZE);
+        ret = bdrv_pread(file, offset, buffer, VHDX_HEADER_SIZE, 0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr,
     vhdx_header_le_export(hdr, header_le);
     vhdx_update_checksum(buffer, VHDX_HEADER_SIZE,
                          offsetof(VHDXHeader, checksum));
-    ret = bdrv_pwrite_sync(file, offset, header_le, sizeof(VHDXHeader));
+    ret = bdrv_pwrite_sync(file, offset, header_le, sizeof(VHDXHeader), 0);
 
 exit:
     qemu_vfree(buffer);
@@ -XXX,XX +XXX,XX @@ static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s,
     /* We have to read the whole VHDX_HEADER_SIZE instead of
      * sizeof(VHDXHeader), because the checksum is over the whole
      * region */
-    ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, buffer,
-                     VHDX_HEADER_SIZE);
+    ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, buffer, VHDX_HEADER_SIZE,
+                     0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s,
         }
     }
 
-    ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, buffer,
-                     VHDX_HEADER_SIZE);
+    ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, buffer, VHDX_HEADER_SIZE,
+                     0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s)
     buffer = qemu_blockalign(bs, VHDX_HEADER_BLOCK_SIZE);
 
     ret = bdrv_pread(bs->file, VHDX_REGION_TABLE_OFFSET, buffer,
-                     VHDX_HEADER_BLOCK_SIZE);
+                     VHDX_HEADER_BLOCK_SIZE, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
     buffer = qemu_blockalign(bs, VHDX_METADATA_TABLE_MAX_SIZE);
 
     ret = bdrv_pread(bs->file, s->metadata_rt.file_offset, buffer,
-                     VHDX_METADATA_TABLE_MAX_SIZE);
+                     VHDX_METADATA_TABLE_MAX_SIZE, 0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
                      s->metadata_entries.file_parameters_entry.offset
                                          + s->metadata_rt.file_offset,
                      &s->params,
-                     sizeof(s->params));
+                     sizeof(s->params),
+                     0);
 
     if (ret < 0) {
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
                      s->metadata_entries.virtual_disk_size_entry.offset
                                            + s->metadata_rt.file_offset,
                      &s->virtual_disk_size,
-                     sizeof(uint64_t));
+                     sizeof(uint64_t),
+                     0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
                      s->metadata_entries.logical_sector_size_entry.offset
                                              + s->metadata_rt.file_offset,
                      &s->logical_sector_size,
-                     sizeof(uint32_t));
+                     sizeof(uint32_t),
+                     0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
                      s->metadata_entries.phys_sector_size_entry.offset
                                           + s->metadata_rt.file_offset,
                      &s->physical_sector_size,
-                     sizeof(uint32_t));
+                     sizeof(uint32_t),
+                     0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
     QLIST_INIT(&s->regions);
 
     /* validate the file signature */
-    ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t));
+    ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t), 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length);
+    ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length, 0);
     if (ret < 0) {
         goto fail;
     }
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_read_cid(BlockDriverState *bs, int parent, uint32_t *pcid)
     int ret;
 
     desc = g_malloc0(DESC_SIZE);
-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
+    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
     if (ret < 0) {
         goto out;
     }
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
 
     desc = g_malloc0(DESC_SIZE);
     tmp_desc = g_malloc0(DESC_SIZE);
-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
+    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
     if (ret < 0) {
         goto out;
     }
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
         pstrcat(desc, DESC_SIZE, tmp_desc);
     }
 
-    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE);
+    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
 
 out:
     g_free(desc);
@@ -XXX,XX +XXX,XX @@ static int vmdk_parent_open(BlockDriverState *bs)
     int ret;
 
     desc = g_malloc0(DESC_SIZE + 1);
-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE);
+    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
     if (ret < 0) {
         goto out;
     }
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
         return -ENOMEM;
     }
 
-    ret = bdrv_pread(extent->file,
-                     extent->l1_table_offset,
-                     extent->l1_table,
-                     l1_size);
+    ret = bdrv_pread(extent->file, extent->l1_table_offset, extent->l1_table,
+                     l1_size, 0);
     if (ret < 0) {
         bdrv_refresh_filename(extent->file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
             ret = -ENOMEM;
             goto fail_l1;
         }
-        ret = bdrv_pread(extent->file,
-                         extent->l1_backup_table_offset,
-                         extent->l1_backup_table,
-                         l1_size);
+        ret = bdrv_pread(extent->file, extent->l1_backup_table_offset,
+                         extent->l1_backup_table, l1_size, 0);
         if (ret < 0) {
             bdrv_refresh_filename(extent->file->bs);
             error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
     VMDK3Header header;
     VmdkExtent *extent = NULL;
 
-    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
+    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header), 0);
     if (ret < 0) {
         bdrv_refresh_filename(file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_se_sparse(BlockDriverState *bs,
 
     assert(sizeof(const_header) == SECTOR_SIZE);
 
-    ret = bdrv_pread(file, 0, &const_header, sizeof(const_header));
+    ret = bdrv_pread(file, 0, &const_header, sizeof(const_header), 0);
     if (ret < 0) {
         bdrv_refresh_filename(file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_se_sparse(BlockDriverState *bs,
 
     assert(sizeof(volatile_header) == SECTOR_SIZE);
 
-    ret = bdrv_pread(file,
-                     const_header.volatile_header_offset * SECTOR_SIZE,
-                     &volatile_header, sizeof(volatile_header));
+    ret = bdrv_pread(file, const_header.volatile_header_offset * SECTOR_SIZE,
+                     &volatile_header, sizeof(volatile_header), 0);
     if (ret < 0) {
         bdrv_refresh_filename(file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static char *vmdk_read_desc(BdrvChild *file, uint64_t desc_offset, Error **errp)
     size = MIN(size, (1 << 20) - 1);  /* avoid unbounded allocation */
     buf = g_malloc(size + 1);
 
-    ret = bdrv_pread(file, desc_offset, buf, size);
+    ret = bdrv_pread(file, desc_offset, buf, size, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read from file");
         g_free(buf);
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
     int64_t l1_backup_offset = 0;
     bool compressed;
 
-    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header));
+    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header), 0);
     if (ret < 0) {
         bdrv_refresh_filename(file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
             } QEMU_PACKED eos_marker;
         } QEMU_PACKED footer;
 
-        ret = bdrv_pread(file,
-            bs->file->bs->total_sectors * 512 - 1536,
-            &footer, sizeof(footer));
+        ret = bdrv_pread(file, bs->file->bs->total_sectors * 512 - 1536,
+                         &footer, sizeof(footer), 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read footer");
             return ret;
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
             /* qcow2 emits this on bs->file instead of bs->backing */
             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_pread(bs->backing, offset, whole_grain,
-                             skip_start_bytes);
+                             skip_start_bytes, 0);
             if (ret < 0) {
                 ret = VMDK_ERROR;
                 goto exit;
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
         }
         BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
         ret = bdrv_pwrite(extent->file, cluster_offset, whole_grain,
-                          skip_start_bytes);
+                          skip_start_bytes, 0);
         if (ret < 0) {
             ret = VMDK_ERROR;
             goto exit;
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
                              whole_grain + skip_end_bytes,
-                             cluster_bytes - skip_end_bytes);
+                             cluster_bytes - skip_end_bytes, 0);
             if (ret < 0) {
                 ret = VMDK_ERROR;
                 goto exit;
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
         BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
         ret = bdrv_pwrite(extent->file, cluster_offset + skip_end_bytes,
                           whole_grain + skip_end_bytes,
-                          cluster_bytes - skip_end_bytes);
+                          cluster_bytes - skip_end_bytes, 0);
         if (ret < 0) {
             ret = VMDK_ERROR;
             goto exit;
@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
     if (bdrv_pwrite(extent->file,
                 ((int64_t)m_data->l2_offset * 512)
                     + (m_data->l2_index * sizeof(offset)),
-                &offset, sizeof(offset)) < 0) {
+                &offset, sizeof(offset), 0) < 0) {
         return VMDK_ERROR;
     }
     /* update backup L2 table */
@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
         if (bdrv_pwrite(extent->file,
                     ((int64_t)m_data->l2_offset * 512)
                         + (m_data->l2_index * sizeof(offset)),
-                    &offset, sizeof(offset)) < 0) {
+                    &offset, sizeof(offset), 0) < 0) {
             return VMDK_ERROR;
         }
     }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
     if (bdrv_pread(extent->file,
                 (int64_t)l2_offset * 512,
                 l2_table,
-                l2_size_bytes
+                l2_size_bytes,
+                0
             ) != l2_size_bytes) {
         return VMDK_ERROR;
     }
@@ -XXX,XX +XXX,XX @@ static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
     cluster_buf = g_malloc(buf_bytes);
     uncomp_buf = g_malloc(cluster_bytes);
     BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
-    ret = bdrv_pread(extent->file,
-                cluster_offset,
-                cluster_buf, buf_bytes);
+    ret = bdrv_pread(extent->file, cluster_offset, cluster_buf, buf_bytes, 0);
     if (ret < 0) {
         goto out;
     }
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, 0, &s->footer, sizeof(s->footer));
+    ret = bdrv_pread(bs->file, 0, &s->footer, sizeof(s->footer), 0);
     if (ret < 0) {
         error_setg(errp, "Unable to read VHD header");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
         }
 
         /* If a fixed disk, the footer is found only at the end of the file */
-        ret = bdrv_pread(bs->file, offset - sizeof(*footer),
-                         footer, sizeof(*footer));
+        ret = bdrv_pread(bs->file, offset - sizeof(*footer), footer,
+                         sizeof(*footer), 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
 
     if (disk_type == VHD_DYNAMIC) {
         ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset),
-                         &dyndisk_header, sizeof(dyndisk_header));
+                         &dyndisk_header, sizeof(dyndisk_header), 0);
         if (ret < 0) {
             error_setg(errp, "Error reading dynamic VHD header");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
         s->bat_offset = be64_to_cpu(dyndisk_header.table_offset);
 
         ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable,
-                         pagetable_size);
+                         pagetable_size, 0);
         if (ret < 0) {
             error_setg(errp, "Error reading pagetable");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
 
         s->last_bitmap_offset = bitmap_offset;
         memset(bitmap, 0xff, s->bitmap_size);
-        r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size);
+        r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size,
+                             0);
         if (r < 0) {
             *err = r;
             return -2;
@@ -XXX,XX +XXX,XX @@ static int rewrite_footer(BlockDriverState *bs)
     BDRVVPCState *s = bs->opaque;
     int64_t offset = s->free_data_block_offset;
 
-    ret = bdrv_pwrite_sync(bs->file, offset, &s->footer, sizeof(s->footer));
+    ret = bdrv_pwrite_sync(bs->file, offset, &s->footer, sizeof(s->footer), 0);
     if (ret < 0)
         return ret;
 
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
     /* Initialize the block's bitmap */
     memset(bitmap, 0xff, s->bitmap_size);
     ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
-        s->bitmap_size);
+                           s->bitmap_size, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
     /* Write BAT entry to disk */
     bat_offset = s->bat_offset + (4 * index);
     bat_value = cpu_to_be32(s->pagetable[index]);
-    ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4);
+    ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4, 0);
     if (ret < 0)
         goto fail;
 
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_read(BlockDriverState *bs, int64_t sector_num,
                              " allocated\n", sector_num,
                              n >> BDRV_SECTOR_BITS));
                 if (bdrv_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE,
-                               buf + i * 0x200, n) < 0) {
+                               buf + i * 0x200, n, 0) < 0) {
                     return -1;
                 }
                 i += (n >> BDRV_SECTOR_BITS) - 1;
@@ -XXX,XX +XXX,XX @@ static uint32_t get_cluster_count_for_direntry(BDRVVVFATState* s,
                             return -1;
                         }
                         res = bdrv_pwrite(s->qcow, offset * BDRV_SECTOR_SIZE,
-                                          s->cluster_buffer, BDRV_SECTOR_SIZE);
+                                          s->cluster_buffer, BDRV_SECTOR_SIZE,
+                                          0);
                         if (res < 0) {
                             return -2;
                         }
@@ -XXX,XX +XXX,XX @@ DLOG(checkpoint());
      */
 DLOG(fprintf(stderr, "Write to qcow backend: %d + %d\n", (int)sector_num, nb_sectors));
     ret = bdrv_pwrite(s->qcow, sector_num * BDRV_SECTOR_SIZE, buf,
-                      nb_sectors * BDRV_SECTOR_SIZE);
+                      nb_sectors * BDRV_SECTOR_SIZE, 0);
     if (ret < 0) {
         fprintf(stderr, "Error writing to qcow backend\n");
         return ret;
diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-block-iothread.c
+++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pread(BdrvChild *c)
     int ret;
 
     /* Success */
-    ret = bdrv_pread(c, 0, buf, sizeof(buf));
+    ret = bdrv_pread(c, 0, buf, sizeof(buf), 0);
     g_assert_cmpint(ret, ==, 512);
 
     /* Early error: Negative offset */
-    ret = bdrv_pread(c, -2, buf, sizeof(buf));
+    ret = bdrv_pread(c, -2, buf, sizeof(buf), 0);
     g_assert_cmpint(ret, ==, -EIO);
 }
 
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pwrite(BdrvChild *c)
     int ret;
 
     /* Success */
-    ret = bdrv_pwrite(c, 0, buf, sizeof(buf));
+    ret = bdrv_pwrite(c, 0, buf, sizeof(buf), 0);
     g_assert_cmpint(ret, ==, 512);
 
     /* Early error: Negative offset */
-    ret = bdrv_pwrite(c, -2, buf, sizeof(buf));
+    ret = bdrv_pwrite(c, -2, buf, sizeof(buf), 0);
     g_assert_cmpint(ret, ==, -EIO);
 }
 
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Swap 'buf' and 'bytes' around for consistency with
bdrv_co_{pread,pwrite}(), and in preparation to implement these
functions using generated_co_wrapper.

Callers were updated using this Coccinelle script:

@@ expression child, offset, buf, bytes, flags; @@
    - bdrv_pread(child, offset, buf, bytes, flags)
    + bdrv_pread(child, offset, bytes, buf, flags)

@@ expression child, offset, buf, bytes, flags; @@
    - bdrv_pwrite(child, offset, buf, bytes, flags)
    + bdrv_pwrite(child, offset, bytes, buf, flags)

@@ expression child, offset, buf, bytes, flags; @@
    - bdrv_pwrite_sync(child, offset, buf, bytes, flags)
    + bdrv_pwrite_sync(child, offset, bytes, buf, flags)

Resulting overly-long lines were then fixed by hand.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Message-Id: <20220609152744.3891847-3-afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/block-io.h         | 10 +++---
 block/blklogwrites.c             |  6 ++--
 block/bochs.c                    | 10 +++---
 block/cloop.c                    | 10 +++---
 block/crypto.c                   |  4 +--
 block/dmg.c                      | 26 +++++++--------
 block/io.c                       | 12 +++----
 block/parallels-ext.c            |  6 ++--
 block/parallels.c                | 10 +++---
 block/qcow.c                     | 34 +++++++++----------
 block/qcow2-bitmap.c             | 14 ++++----
 block/qcow2-cache.c              |  8 ++---
 block/qcow2-cluster.c            | 22 ++++++-------
 block/qcow2-refcount.c           | 56 +++++++++++++++++---------------
 block/qcow2-snapshot.c           | 48 +++++++++++++--------------
 block/qcow2.c                    | 47 ++++++++++++++-------------
 block/qed.c                      |  8 ++---
 block/vdi.c                      | 14 ++++----
 block/vhdx-log.c                 | 18 +++++-----
 block/vhdx.c                     | 28 ++++++++--------
 block/vmdk.c                     | 50 ++++++++++++++--------------
 block/vpc.c                      | 22 ++++++-------
 block/vvfat.c                    | 10 +++---
 tests/unit/test-block-iothread.c |  8 ++---
 24 files changed, 242 insertions(+), 239 deletions(-)

diff --git a/include/block/block-io.h b/include/block/block-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -XXX,XX +XXX,XX @@
 int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
                        int64_t bytes, BdrvRequestFlags flags);
 int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
-int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
+int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
                BdrvRequestFlags flags);
-int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
-                int64_t bytes, BdrvRequestFlags flags);
-int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
-                     const void *buf, int64_t bytes, BdrvRequestFlags flags);
+int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
+                const void *buf, BdrvRequestFlags flags);
+int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
+                     const void *buf, BdrvRequestFlags flags);
 /*
  * Efficiently zero a region of the disk image.  Note that this is a regular
  * I/O request like read or write and should have a reasonable size.  This
diff --git a/block/blklogwrites.c b/block/blklogwrites.c
index XXXXXXX..XXXXXXX 100644
--- a/block/blklogwrites.c
+++ b/block/blklogwrites.c
@@ -XXX,XX +XXX,XX @@ static uint64_t blk_log_writes_find_cur_log_sector(BdrvChild *log,
     struct log_write_entry cur_entry;
 
     while (cur_idx < nr_entries) {
-        int read_ret = bdrv_pread(log, cur_sector << sector_bits, &cur_entry,
-                                  sizeof(cur_entry), 0);
+        int read_ret = bdrv_pread(log, cur_sector << sector_bits,
+                                  sizeof(cur_entry), &cur_entry, 0);
         if (read_ret < 0) {
             error_setg_errno(errp, -read_ret,
                              "Failed to read log entry %"PRIu64, cur_idx);
@@ -XXX,XX +XXX,XX @@ static int blk_log_writes_open(BlockDriverState *bs, QDict *options, int flags,
             log_sb.nr_entries = cpu_to_le64(0);
             log_sb.sectorsize = cpu_to_le32(BDRV_SECTOR_SIZE);
         } else {
-            ret = bdrv_pread(s->log_file, 0, &log_sb, sizeof(log_sb), 0);
+            ret = bdrv_pread(s->log_file, 0, sizeof(log_sb), &log_sb, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "Could not read log superblock");
                 goto fail_log;
diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs), 0);
+    ret = bdrv_pread(bs->file, 0, sizeof(bochs), &bochs, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
         return -ENOMEM;
     }
 
-    ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_bitmap,
-                     s->catalog_size * 4, 0);
+    ret = bdrv_pread(bs->file, le32_to_cpu(bochs.header), s->catalog_size * 4,
+                     s->catalog_bitmap, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
         (s->extent_blocks + s->bitmap_blocks));
 
     /* read in bitmap for current extent */
-    ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8),
-                     &bitmap_entry, 1, 0);
+    ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8), 1,
+                     &bitmap_entry, 0);
     if (ret < 0) {
         return ret;
     }
diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     /* read header */
-    ret = bdrv_pread(bs->file, 128, &s->block_size, 4, 0);
+    ret = bdrv_pread(bs->file, 128, 4, &s->block_size, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    ret = bdrv_pread(bs->file, 128 + 4, &s->n_blocks, 4, 0);
+    ret = bdrv_pread(bs->file, 128 + 4, 4, &s->n_blocks, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
         return -ENOMEM;
     }
 
-    ret = bdrv_pread(bs->file, 128 + 4 + 4, s->offsets, offsets_size, 0);
+    ret = bdrv_pread(bs->file, 128 + 4 + 4, offsets_size, s->offsets, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
         int ret;
         uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];
 
-        ret = bdrv_pread(bs->file, s->offsets[block_num], s->compressed_block,
-                         bytes, 0);
+        ret = bdrv_pread(bs->file, s->offsets[block_num], bytes,
+                         s->compressed_block, 0);
         if (ret != bytes) {
             return -1;
         }
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
     BlockDriverState *bs = opaque;
     ssize_t ret;
 
-    ret = bdrv_pread(bs->file, offset, buf, buflen, 0);
+    ret = bdrv_pread(bs->file, offset, buflen, buf, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return ret;
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_write_func(QCryptoBlock *block,
     BlockDriverState *bs = opaque;
     ssize_t ret;
 
-    ret = bdrv_pwrite(bs->file, offset, buf, buflen, 0);
+    ret = bdrv_pwrite(bs->file, offset, buflen, buf, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not write encryption header");
         return ret;
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int read_uint64(BlockDriverState *bs, int64_t offset, uint64_t *result)
     uint64_t buffer;
     int ret;
 
-    ret = bdrv_pread(bs->file, offset, &buffer, 8, 0);
+    ret = bdrv_pread(bs->file, offset, 8, &buffer, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int read_uint32(BlockDriverState *bs, int64_t offset, uint32_t *result)
     uint32_t buffer;
     int ret;
 
-    ret = bdrv_pread(bs->file, offset, &buffer, 4, 0);
+    ret = bdrv_pread(bs->file, offset, 4, &buffer, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int64_t dmg_find_koly_offset(BdrvChild *file, Error **errp)
         offset = length - 511 - 512;
     }
     length = length < 515 ? length : 515;
-    ret = bdrv_pread(file, offset, buffer, length, 0);
+    ret = bdrv_pread(file, offset, length, buffer, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed while reading UDIF trailer");
         return ret;
@@ -XXX,XX +XXX,XX @@ static int dmg_read_resource_fork(BlockDriverState *bs, DmgHeaderState *ds,
         offset += 4;
 
         buffer = g_realloc(buffer, count);
-        ret = bdrv_pread(bs->file, offset, buffer, count, 0);
+        ret = bdrv_pread(bs->file, offset, count, buffer, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int dmg_read_plist_xml(BlockDriverState *bs, DmgHeaderState *ds,
 
     buffer = g_malloc(info_length + 1);
     buffer[info_length] = '\0';
-    ret = bdrv_pread(bs->file, info_begin, buffer, info_length, 0);
+    ret = bdrv_pread(bs->file, info_begin, info_length, buffer, 0);
     if (ret != info_length) {
         ret = -EINVAL;
         goto fail;
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
         case UDZO: { /* zlib compressed */
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
-                             s->lengths[chunk], 0);
+            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
+                             s->compressed_chunk, 0);
             if (ret != s->lengths[chunk]) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             }
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
-                             s->lengths[chunk], 0);
+            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
+                             s->compressed_chunk, 0);
             if (ret != s->lengths[chunk]) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             }
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->compressed_chunk,
-                             s->lengths[chunk], 0);
+            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
+                             s->compressed_chunk, 0);
             if (ret != s->lengths[chunk]) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             }
             break;
         case UDRW: /* copy */
-            ret = bdrv_pread(bs->file, s->offsets[chunk],
-                             s->uncompressed_chunk, s->lengths[chunk], 0);
+            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
+                             s->uncompressed_chunk, 0);
             if (ret != s->lengths[chunk]) {
                 return -1;
             }
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
 }
 
 /* See bdrv_pwrite() for the return codes */
-int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
+int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
                BdrvRequestFlags flags)
 {
     int ret;
@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int64_t bytes,
   -EINVAL      Invalid offset or number of bytes
   -EACCES      Trying to write a read-only device
 */
-int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
-                int64_t bytes, BdrvRequestFlags flags)
+int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
+                const void *buf, BdrvRequestFlags flags)
 {
     int ret;
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
@@ -XXX,XX +XXX,XX @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf,
  *
  * Returns 0 on success, -errno in error cases.
  */
-int bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
-                     const void *buf, int64_t count, BdrvRequestFlags flags)
+int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
+                     const void *buf, BdrvRequestFlags flags)
 {
     int ret;
     IO_CODE();
 
-    ret = bdrv_pwrite(child, offset, buf, count, flags);
+    ret = bdrv_pwrite(child, offset, bytes, buf, flags);
     if (ret < 0) {
         return ret;
     }
diff --git a/block/parallels-ext.c b/block/parallels-ext.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels-ext.c
+++ b/block/parallels-ext.c
@@ -XXX,XX +XXX,XX @@ static int parallels_load_bitmap_data(BlockDriverState *bs,
         if (entry == 1) {
             bdrv_dirty_bitmap_deserialize_ones(bitmap, offset, count, false);
         } else {
-            ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS, buf,
-                             s->cluster_size, 0);
+            ret = bdrv_pread(bs->file, entry << BDRV_SECTOR_BITS,
+                             s->cluster_size, buf, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret,
                                  "Failed to read bitmap data cluster");
@@ -XXX,XX +XXX,XX @@ int parallels_read_format_extension(BlockDriverState *bs,
 
     assert(ext_off > 0);
 
-    ret = bdrv_pread(bs->file, ext_off, ext_cluster, s->cluster_size, 0);
+    ret = bdrv_pread(bs->file, ext_off, s->cluster_size, ext_cluster, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to read Format Extension cluster");
         goto out;
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int parallels_co_flush_to_os(BlockDriverState *bs)
         if (off + to_write > s->header_size) {
             to_write = s->header_size - off;
         }
-        ret = bdrv_pwrite(bs->file, off, (uint8_t *)s->header + off, to_write,
+        ret = bdrv_pwrite(bs->file, off, to_write, (uint8_t *)s->header + off,
                           0);
         if (ret < 0) {
             qemu_co_mutex_unlock(&s->lock);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
 
     ret = 0;
     if (flush_bat) {
-        ret = bdrv_pwrite_sync(bs->file, 0, s->header, s->header_size, 0);
+        ret = bdrv_pwrite_sync(bs->file, 0, s->header_size, s->header, 0);
         if (ret < 0) {
             res->check_errors++;
             goto out;
@@ -XXX,XX +XXX,XX @@ static int parallels_update_header(BlockDriverState *bs)
     if (size > s->header_size) {
         size = s->header_size;
     }
-    return bdrv_pwrite_sync(bs->file, 0, s->header, size, 0);
+    return bdrv_pwrite_sync(bs->file, 0, size, s->header, 0);
 }
 
 static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph), 0);
+    ret = bdrv_pread(bs->file, 0, sizeof(ph), &ph, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
         s->header_size = size;
     }
 
-    ret = bdrv_pread(bs->file, 0, s->header, s->header_size, 0);
+    ret = bdrv_pread(bs->file, 0, s->header_size, s->header, 0);
     if (ret < 0) {
         goto fail;
     }
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
+    ret = bdrv_pread(bs->file, 0, sizeof(header), &header, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
-                     s->l1_size * sizeof(uint64_t), 0);
+    ret = bdrv_pread(bs->file, s->l1_table_offset,
+                     s->l1_size * sizeof(uint64_t), s->l1_table, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
             ret = -EINVAL;
             goto fail;
         }
-        ret = bdrv_pread(bs->file, header.backing_file_offset,
-                         bs->auto_backing_file, len, 0);
+        ret = bdrv_pread(bs->file, header.backing_file_offset, len,
+                         bs->auto_backing_file, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
         BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
         ret = bdrv_pwrite_sync(bs->file,
                                s->l1_table_offset + l1_index * sizeof(tmp),
-                               &tmp, sizeof(tmp), 0);
+                               sizeof(tmp), &tmp, 0);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
     BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
     if (new_l2_table) {
         memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
-        ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
-                               s->l2_size * sizeof(uint64_t), 0);
+        ret = bdrv_pwrite_sync(bs->file, l2_offset,
+                               s->l2_size * sizeof(uint64_t), l2_table, 0);
         if (ret < 0) {
             return ret;
         }
     } else {
-        ret = bdrv_pread(bs->file, l2_offset, l2_table,
-                         s->l2_size * sizeof(uint64_t), 0);
+        ret = bdrv_pread(bs->file, l2_offset, s->l2_size * sizeof(uint64_t),
+                         l2_table, 0);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
             cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);
             /* write the cluster content */
             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
-            ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache,
-                              s->cluster_size, 0);
+            ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_size,
+                              s->cluster_cache, 0);
             if (ret < 0) {
                 return ret;
             }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
                             }
                             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
                             ret = bdrv_pwrite(bs->file, cluster_offset + i,
-                                              s->cluster_data,
-                                              BDRV_SECTOR_SIZE, 0);
+                                              BDRV_SECTOR_SIZE,
+                                              s->cluster_data, 0);
                             if (ret < 0) {
                                 return ret;
                             }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
             BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
         }
         ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
-                               &tmp, sizeof(tmp), 0);
+                               sizeof(tmp), &tmp, 0);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
         csize = cluster_offset >> (63 - s->cluster_bits);
         csize &= (s->cluster_size - 1);
         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
-        ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize, 0);
+        ret = bdrv_pread(bs->file, coffset, csize, s->cluster_data, 0);
         if (ret != csize)
             return -1;
         if (decompress_buffer(s->cluster_cache, s->cluster_size,
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
     int ret;
 
     memset(s->l1_table, 0, l1_length);
-    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table, l1_length,
+    if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, l1_length, s->l1_table,
                          0) < 0)
         return -1;
     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-bitmap.c
+++ b/block/qcow2-bitmap.c
@@ -XXX,XX +XXX,XX @@ static int bitmap_table_load(BlockDriverState *bs, Qcow2BitmapTable *tb,
     }
 
     assert(tb->size <= BME_MAX_TABLE_SIZE);
-    ret = bdrv_pread(bs->file, tb->offset, table,
-                     tb->size * BME_TABLE_ENTRY_SIZE, 0);
+    ret = bdrv_pread(bs->file, tb->offset, tb->size * BME_TABLE_ENTRY_SIZE,
+                     table, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int load_bitmap_data(BlockDriverState *bs,
                  * already cleared */
             }
         } else {
-            ret = bdrv_pread(bs->file, data_offset, buf, s->cluster_size, 0);
+            ret = bdrv_pread(bs->file, data_offset, s->cluster_size, buf, 0);
             if (ret < 0) {
                 goto finish;
             }
@@ -XXX,XX +XXX,XX @@ static Qcow2BitmapList *bitmap_list_load(BlockDriverState *bs, uint64_t offset,
     }
     dir_end = dir + size;
 
-    ret = bdrv_pread(bs->file, offset, dir, size, 0);
+    ret = bdrv_pread(bs->file, offset, size, dir, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to read bitmap directory");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int bitmap_list_store(BlockDriverState *bs, Qcow2BitmapList *bm_list,
         goto fail;
     }
 
-    ret = bdrv_pwrite(bs->file, dir_offset, dir, dir_size, 0);
+    ret = bdrv_pwrite(bs->file, dir_offset, dir_size, dir, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static uint64_t *store_bitmap_data(BlockDriverState *bs,
             goto fail;
         }
 
-        ret = bdrv_pwrite(bs->file, off, buf, s->cluster_size, 0);
+        ret = bdrv_pwrite(bs->file, off, s->cluster_size, buf, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
                              bm_name);
@@ -XXX,XX +XXX,XX @@ static int store_bitmap(BlockDriverState *bs, Qcow2Bitmap *bm, Error **errp)
     }
 
     bitmap_table_to_be(tb, tb_size);
-    ret = bdrv_pwrite(bs->file, tb_offset, tb, tb_size * sizeof(tb[0]), 0);
+    ret = bdrv_pwrite(bs->file, tb_offset, tb_size * sizeof(tb[0]), tb, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to write bitmap '%s' to file",
                          bm_name);
diff --git a/block/qcow2-cache.c b/block/qcow2-cache.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cache.c
+++ b/block/qcow2-cache.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_cache_entry_flush(BlockDriverState *bs, Qcow2Cache *c, int i)
         BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
     }
 
-    ret = bdrv_pwrite(bs->file, c->entries[i].offset,
-                      qcow2_cache_get_table_addr(c, i), c->table_size, 0);
+    ret = bdrv_pwrite(bs->file, c->entries[i].offset, c->table_size,
+                      qcow2_cache_get_table_addr(c, i), 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int qcow2_cache_do_get(BlockDriverState *bs, Qcow2Cache *c,
             BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
         }
 
-        ret = bdrv_pread(bs->file, offset, qcow2_cache_get_table_addr(c, i),
-                         c->table_size, 0);
+        ret = bdrv_pread(bs->file, offset, c->table_size,
+                         qcow2_cache_get_table_addr(c, i), 0);
         if (ret < 0) {
             return ret;
         }
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_WRITE_TABLE);
     for(i = 0; i < s->l1_size; i++)
         new_l1_table[i] = cpu_to_be64(new_l1_table[i]);
-    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, new_l1_table,
-                           new_l1_size2, 0);
+    ret = bdrv_pwrite_sync(bs->file, new_l1_table_offset, new_l1_size2,
+                           new_l1_table, 0);
     if (ret < 0)
         goto fail;
     for(i = 0; i < s->l1_size; i++)
@@ -XXX,XX +XXX,XX @@ int qcow2_grow_l1_table(BlockDriverState *bs, uint64_t min_size,
     BLKDBG_EVENT(bs->file, BLKDBG_L1_GROW_ACTIVATE_TABLE);
     stl_be_p(data, new_l1_size);
     stq_be_p(data + 4, new_l1_table_offset);
-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size), data,
-                           sizeof(data), 0);
+    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_size),
+                           sizeof(data), data, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_write_l1_entry(BlockDriverState *bs, int l1_index)
     BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
     ret = bdrv_pwrite_sync(bs->file,
                            s->l1_table_offset + L1E_SIZE * l1_start_index,
-                           buf, bufsize, 0);
+                           bufsize, buf, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
                                       (void **)&l2_slice);
             } else {
                 /* load inactive L2 tables from disk */
-                ret = bdrv_pread(bs->file, slice_offset, l2_slice,
-                                 slice_size2, 0);
+                ret = bdrv_pread(bs->file, slice_offset, slice_size2,
+                                 l2_slice, 0);
             }
             if (ret < 0) {
                 goto fail;
@@ -XXX,XX +XXX,XX @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,
                         goto fail;
                     }
 
-                    ret = bdrv_pwrite(bs->file, slice_offset, l2_slice,
-                                      slice_size2, 0);
+                    ret = bdrv_pwrite(bs->file, slice_offset, slice_size2,
+                                      l2_slice, 0);
                     if (ret < 0) {
                         goto fail;
                     }
@@ -XXX,XX +XXX,XX @@ int qcow2_expand_zero_clusters(BlockDriverState *bs,
 
         l1_table = new_l1_table;
 
-        ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset, l1_table,
-                         l1_size2, 0);
+        ret = bdrv_pread(bs->file, s->snapshots[i].l1_table_offset, l1_size2,
+                         l1_table, 0);
         if (ret < 0) {
             goto fail;
         }
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ int qcow2_refcount_init(BlockDriverState *bs)
         }
         BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
         ret = bdrv_pread(bs->file, s->refcount_table_offset,
-                         s->refcount_table, refcount_table_size2, 0);
+                         refcount_table_size2, s->refcount_table, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,
         BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_HOOKUP);
         ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset +
                                refcount_table_index * REFTABLE_ENTRY_SIZE,
-            &data64, sizeof(data64), 0);
+            sizeof(data64), &data64, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
     }
 
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_WRITE_TABLE);
-    ret = bdrv_pwrite_sync(bs->file, table_offset, new_table,
-                           table_size * REFTABLE_ENTRY_SIZE, 0);
+    ret = bdrv_pwrite_sync(bs->file, table_offset,
+                           table_size * REFTABLE_ENTRY_SIZE, new_table, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t start_offset,
     data.d32 = cpu_to_be32(table_clusters);
     BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC_SWITCH_TABLE);
     ret = bdrv_pwrite_sync(bs->file,
-                           offsetof(QCowHeader, refcount_table_offset), &data,
-                           sizeof(data), 0);
+                           offsetof(QCowHeader, refcount_table_offset),
+                           sizeof(data), &data, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
         }
         l1_allocated = true;
 
-        ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2, 0);
+        ret = bdrv_pread(bs->file, l1_table_offset, l1_size2, l1_table, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ fail:
             cpu_to_be64s(&l1_table[i]);
         }
 
-        ret = bdrv_pwrite_sync(bs->file, l1_table_offset, l1_table, l1_size2,
+        ret = bdrv_pwrite_sync(bs->file, l1_table_offset, l1_size2, l1_table,
                                0);
 
         for (i = 0; i < l1_size; i++) {
@@ -XXX,XX +XXX,XX @@ static int fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
         goto fail;
     }
 
-    ret = bdrv_pwrite_sync(bs->file, l2e_offset, &l2_table[idx],
-                           l2_entry_size(s), 0);
+    ret = bdrv_pwrite_sync(bs->file, l2e_offset, l2_entry_size(s),
+                           &l2_table[idx], 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: Failed to overwrite L2 "
                 "table entry: %s\n", strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
     bool metadata_overlap;
 
     /* Read L2 table from disk */
-    ret = bdrv_pread(bs->file, l2_offset, l2_table, l2_size_bytes, 0);
+    ret = bdrv_pread(bs->file, l2_offset, l2_size_bytes, l2_table, 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
         res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
     }
 
     /* Read L1 table entries from disk */
-    ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size_bytes, 0);
+    ret = bdrv_pread(bs->file, l1_table_offset, l1_size_bytes, l1_table, 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
         res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
             }
         }
 
-        ret = bdrv_pread(bs->file, l2_offset, l2_table,
-                         s->l2_size * l2_entry_size(s), 0);
+        ret = bdrv_pread(bs->file, l2_offset, s->l2_size * l2_entry_size(s),
+                         l2_table, 0);
         if (ret < 0) {
             fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
                     strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
                 goto fail;
             }
 
-            ret = bdrv_pwrite(bs->file, l2_offset, l2_table, s->cluster_size,
+            ret = bdrv_pwrite(bs->file, l2_offset, s->cluster_size, l2_table,
                               0);
             if (ret < 0) {
                 fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcounts_write_refblocks(
         on_disk_refblock = (void *)((char *) *refcount_table +
                                     refblock_index * s->cluster_size);
 
-        ret = bdrv_pwrite(bs->file, refblock_offset, on_disk_refblock,
-                          s->cluster_size, 0);
+        ret = bdrv_pwrite(bs->file, refblock_offset, s->cluster_size,
+                          on_disk_refblock, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "ERROR writing refblock");
             return ret;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
     }
 
     assert(reftable_length < INT_MAX);
-    ret = bdrv_pwrite(bs->file, reftable_offset, on_disk_reftable,
-                      reftable_length, 0);
+    ret = bdrv_pwrite(bs->file, reftable_offset, reftable_length,
+                      on_disk_reftable, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "ERROR writing reftable");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
         cpu_to_be32(reftable_clusters);
     ret = bdrv_pwrite_sync(bs->file,
                            offsetof(QCowHeader, refcount_table_offset),
-                           &reftable_offset_and_clusters,
-                           sizeof(reftable_offset_and_clusters), 0);
+                           sizeof(reftable_offset_and_clusters),
+                           &reftable_offset_and_clusters, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "ERROR setting reftable");
         goto fail;
@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
                 return -ENOMEM;
             }
 
-            ret = bdrv_pread(bs->file, l1_ofs, l1, l1_sz2, 0);
+            ret = bdrv_pread(bs->file, l1_ofs, l1_sz2, l1, 0);
             if (ret < 0) {
                 g_free(l1);
                 return ret;
@@ -XXX,XX +XXX,XX @@ static int flush_refblock(BlockDriverState *bs, uint64_t **reftable,
             return ret;
         }
 
-        ret = bdrv_pwrite(bs->file, offset, refblock, s->cluster_size, 0);
+        ret = bdrv_pwrite(bs->file, offset, s->cluster_size, refblock, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to write refblock");
             return ret;
@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
         cpu_to_be64s(&new_reftable[i]);
     }
 
-    ret = bdrv_pwrite(bs->file, new_reftable_offset, new_reftable,
-                      new_reftable_size * REFTABLE_ENTRY_SIZE, 0);
+    ret = bdrv_pwrite(bs->file, new_reftable_offset,
+                      new_reftable_size * REFTABLE_ENTRY_SIZE, new_reftable,
+                      0);
 
     for (i = 0; i < new_reftable_size; i++) {
         be64_to_cpus(&new_reftable[i]);
@@ -XXX,XX +XXX,XX @@ int qcow2_shrink_reftable(BlockDriverState *bs)
         reftable_tmp[i] = unused_block ? 0 : cpu_to_be64(s->refcount_table[i]);
     }
 
-    ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset, reftable_tmp,
-                           s->refcount_table_size * REFTABLE_ENTRY_SIZE, 0);
+    ret = bdrv_pwrite_sync(bs->file, s->refcount_table_offset,
+                           s->refcount_table_size * REFTABLE_ENTRY_SIZE,
+                           reftable_tmp, 0);
     /*
      * If the write in the reftable failed the image may contain a partially
      * overwritten reftable. In this case it would be better to clear the
diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-snapshot.c
+++ b/block/qcow2-snapshot.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
 
         /* Read statically sized part of the snapshot header */
         offset = ROUND_UP(offset, 8);
-        ret = bdrv_pread(bs->file, offset, &h, sizeof(h), 0);
+        ret = bdrv_pread(bs->file, offset, sizeof(h), &h, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read snapshot table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
         }
 
         /* Read known extra data */
-        ret = bdrv_pread(bs->file, offset, &extra,
-                         MIN(sizeof(extra), sn->extra_data_size), 0);
+        ret = bdrv_pread(bs->file, offset,
+                         MIN(sizeof(extra), sn->extra_data_size), &extra, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read snapshot table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
             /* Store unknown extra data */
             unknown_extra_data_size = sn->extra_data_size - sizeof(extra);
             sn->unknown_extra_data = g_malloc(unknown_extra_data_size);
-            ret = bdrv_pread(bs->file, offset, sn->unknown_extra_data,
-                             unknown_extra_data_size, 0);
+            ret = bdrv_pread(bs->file, offset, unknown_extra_data_size,
+                             sn->unknown_extra_data, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret,
                                  "Failed to read snapshot table");
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
 
         /* Read snapshot ID */
         sn->id_str = g_malloc(id_str_size + 1);
-        ret = bdrv_pread(bs->file, offset, sn->id_str, id_str_size, 0);
+        ret = bdrv_pread(bs->file, offset, id_str_size, sn->id_str, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read snapshot table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_read_snapshots(BlockDriverState *bs, bool repair,
 
         /* Read snapshot name */
         sn->name = g_malloc(name_size + 1);
-        ret = bdrv_pread(bs->file, offset, sn->name, name_size, 0);
+        ret = bdrv_pread(bs->file, offset, name_size, sn->name, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read snapshot table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
         h.name_size = cpu_to_be16(name_size);
         offset = ROUND_UP(offset, 8);
 
-        ret = bdrv_pwrite(bs->file, offset, &h, sizeof(h), 0);
+        ret = bdrv_pwrite(bs->file, offset, sizeof(h), &h, 0);
         if (ret < 0) {
             goto fail;
         }
         offset += sizeof(h);
 
-        ret = bdrv_pwrite(bs->file, offset, &extra, sizeof(extra), 0);
+        ret = bdrv_pwrite(bs->file, offset, sizeof(extra), &extra, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
             assert(unknown_extra_data_size <= BDRV_REQUEST_MAX_BYTES);
             assert(sn->unknown_extra_data);
 
-            ret = bdrv_pwrite(bs->file, offset, sn->unknown_extra_data,
-                              unknown_extra_data_size, 0);
+            ret = bdrv_pwrite(bs->file, offset, unknown_extra_data_size,
+                              sn->unknown_extra_data, 0);
             if (ret < 0) {
                 goto fail;
             }
             offset += unknown_extra_data_size;
         }
 
-        ret = bdrv_pwrite(bs->file, offset, sn->id_str, id_str_size, 0);
+        ret = bdrv_pwrite(bs->file, offset, id_str_size, sn->id_str, 0);
         if (ret < 0) {
             goto fail;
         }
         offset += id_str_size;
 
-        ret = bdrv_pwrite(bs->file, offset, sn->name, name_size, 0);
+        ret = bdrv_pwrite(bs->file, offset, name_size, sn->name, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ int qcow2_write_snapshots(BlockDriverState *bs)
     header_data.snapshots_offset    = cpu_to_be64(snapshots_offset);
 
     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
-                           &header_data, sizeof(header_data), 0);
+                           sizeof(header_data), &header_data, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
 
     /* qcow2_do_open() discards this information in check mode */
     ret = bdrv_pread(bs->file, offsetof(QCowHeader, nb_snapshots),
-                     &snapshot_table_pointer, sizeof(snapshot_table_pointer),
+                     sizeof(snapshot_table_pointer), &snapshot_table_pointer,
                      0);
     if (ret < 0) {
         result->check_errors++;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
 
         snapshot_table_pointer.nb_snapshots = cpu_to_be32(s->nb_snapshots);
         ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
-                               &snapshot_table_pointer.nb_snapshots,
-                               sizeof(snapshot_table_pointer.nb_snapshots), 0);
+                               sizeof(snapshot_table_pointer.nb_snapshots),
+                               &snapshot_table_pointer.nb_snapshots, 0);
         if (ret < 0) {
             result->check_errors++;
             fprintf(stderr, "ERROR failed to update the snapshot count in the "
@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info)
         goto fail;
     }
 
-    ret = bdrv_pwrite(bs->file, sn->l1_table_offset, l1_table,
-                      s->l1_size * L1E_SIZE, 0);
+    ret = bdrv_pwrite(bs->file, sn->l1_table_offset, s->l1_size * L1E_SIZE,
+                      l1_table, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, sn->l1_table_offset, sn_l1_table, sn_l1_bytes,
+    ret = bdrv_pread(bs->file, sn->l1_table_offset, sn_l1_bytes, sn_l1_table,
                      0);
     if (ret < 0) {
         goto fail;
@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_goto(BlockDriverState *bs, const char *snapshot_id)
         goto fail;
     }
 
-    ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, sn_l1_table,
-                           cur_l1_bytes, 0);
+    ret = bdrv_pwrite_sync(bs->file, s->l1_table_offset, cur_l1_bytes,
+                           sn_l1_table, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_snapshot_load_tmp(BlockDriverState *bs,
         return -ENOMEM;
     }
 
-    ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_table,
-                     new_l1_bytes, 0);
+    ret = bdrv_pread(bs->file, sn->l1_table_offset, new_l1_bytes,
+                     new_l1_table, 0);
     if (ret < 0) {
         error_setg(errp, "Failed to read l1 table for snapshot");
         qemu_vfree(new_l1_table);
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
         return -1;
     }
 
-    ret = bdrv_pread(bs->file, s->crypto_header.offset + offset, buf, buflen,
+    ret = bdrv_pread(bs->file, s->crypto_header.offset + offset, buflen, buf,
                      0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read encryption header");
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
         return -1;
     }
 
-    ret = bdrv_pwrite(bs->file, s->crypto_header.offset + offset, buf, buflen,
+    ret = bdrv_pwrite(bs->file, s->crypto_header.offset + offset, buflen, buf,
                       0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read encryption header");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
         printf("attempting to read extended header in offset %lu\n", offset);
 #endif
 
-        ret = bdrv_pread(bs->file, offset, &ext, sizeof(ext), 0);
+        ret = bdrv_pread(bs->file, offset, sizeof(ext), &ext, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "qcow2_read_extension: ERROR: "
                              "pread fail from offset %" PRIu64, offset);
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                            sizeof(bs->backing_format));
                 return 2;
             }
-            ret = bdrv_pread(bs->file, offset, bs->backing_format, ext.len, 0);
+            ret = bdrv_pread(bs->file, offset, ext.len, bs->backing_format, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "ERROR: ext_backing_format: "
                                  "Could not read format name");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
         case QCOW2_EXT_MAGIC_FEATURE_TABLE:
             if (p_feature_table != NULL) {
                 void *feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
-                ret = bdrv_pread(bs->file, offset, feature_table, ext.len, 0);
+                ret = bdrv_pread(bs->file, offset, ext.len, feature_table, 0);
                 if (ret < 0) {
                     error_setg_errno(errp, -ret, "ERROR: ext_feature_table: "
                                      "Could not read table");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                 return -EINVAL;
             }
 
-            ret = bdrv_pread(bs->file, offset, &s->crypto_header, ext.len, 0);
+            ret = bdrv_pread(bs->file, offset, ext.len, &s->crypto_header, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret,
                                  "Unable to read CRYPTO header extension");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                 break;
             }
 
-            ret = bdrv_pread(bs->file, offset, &bitmaps_ext, ext.len, 0);
+            ret = bdrv_pread(bs->file, offset, ext.len, &bitmaps_ext, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "bitmaps_ext: "
                                  "Could not read ext header");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
         case QCOW2_EXT_MAGIC_DATA_FILE:
         {
             s->image_data_file = g_malloc0(ext.len + 1);
-            ret = bdrv_pread(bs->file, offset, s->image_data_file, ext.len, 0);
+            ret = bdrv_pread(bs->file, offset, ext.len, s->image_data_file, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret,
                                  "ERROR: Could not read data file name");
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                 uext->len = ext.len;
                 QLIST_INSERT_HEAD(&s->unknown_header_ext, uext, next);
 
-                ret = bdrv_pread(bs->file, offset, uext->data, uext->len, 0);
+                ret = bdrv_pread(bs->file, offset, uext->len, uext->data, 0);
                 if (ret < 0) {
                     error_setg_errno(errp, -ret, "ERROR: unknown extension: "
                                      "Could not read data");
@@ -XXX,XX +XXX,XX @@ int qcow2_mark_dirty(BlockDriverState *bs)
 
     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
     ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
-                      &val, sizeof(val), 0);
+                      sizeof(val), &val, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
     uint64_t l1_vm_state_index;
     bool update_header = false;
 
-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
+    ret = bdrv_pread(bs->file, 0, sizeof(header), &header, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read qcow2 header");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
     if (header.header_length > sizeof(header)) {
         s->unknown_header_fields_size = header.header_length - sizeof(header);
         s->unknown_header_fields = g_malloc(s->unknown_header_fields_size);
-        ret = bdrv_pread(bs->file, sizeof(header), s->unknown_header_fields,
-                         s->unknown_header_fields_size, 0);
+        ret = bdrv_pread(bs->file, sizeof(header),
+                         s->unknown_header_fields_size,
+                         s->unknown_header_fields, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Could not read unknown qcow2 header "
                              "fields");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
             ret = -ENOMEM;
             goto fail;
         }
-        ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_table,
-                         s->l1_size * L1E_SIZE, 0);
+        ret = bdrv_pread(bs->file, s->l1_table_offset, s->l1_size * L1E_SIZE,
+                         s->l1_table, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Could not read L1 table");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
             ret = -EINVAL;
             goto fail;
         }
-        ret = bdrv_pread(bs->file, header.backing_file_offset,
-                         bs->auto_backing_file, len, 0);
+        ret = bdrv_pread(bs->file, header.backing_file_offset, len,
+                         bs->auto_backing_file, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Could not read backing file name");
             goto fail;
@@ -XXX,XX +XXX,XX @@ int qcow2_update_header(BlockDriverState *bs)
     }
 
     /* Write the new header */
-    ret = bdrv_pwrite(bs->file, 0, header, s->cluster_size, 0);
+    ret = bdrv_pwrite(bs->file, 0, s->cluster_size, header, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
 
     /* write updated header.size */
     offset = cpu_to_be64(offset);
-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size), &offset,
-                           sizeof(offset), 0);
+    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
+                           sizeof(offset), &offset, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to update the image size");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
     l1_ofs_rt_ofs_cls.reftable_offset = cpu_to_be64(s->cluster_size);
     l1_ofs_rt_ofs_cls.reftable_clusters = cpu_to_be32(1);
     ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, l1_table_offset),
-                           &l1_ofs_rt_ofs_cls, sizeof(l1_ofs_rt_ofs_cls), 0);
+                           sizeof(l1_ofs_rt_ofs_cls), &l1_ofs_rt_ofs_cls, 0);
     if (ret < 0) {
         goto fail_broken_refcounts;
     }
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
 
     /* Enter the first refblock into the reftable */
     rt_entry = cpu_to_be64(2 * s->cluster_size);
-    ret = bdrv_pwrite_sync(bs->file, s->cluster_size, &rt_entry,
-                           sizeof(rt_entry), 0);
+    ret = bdrv_pwrite_sync(bs->file, s->cluster_size, sizeof(rt_entry),
+                           &rt_entry, 0);
     if (ret < 0) {
         goto fail_broken_refcounts;
     }
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ int qed_write_header_sync(BDRVQEDState *s)
     int ret;
 
     qed_header_cpu_to_le(&s->header, &le);
-    ret = bdrv_pwrite(s->bs->file, 0, &le, sizeof(le), 0);
+    ret = bdrv_pwrite(s->bs->file, 0, sizeof(le), &le, 0);
     if (ret != sizeof(le)) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int qed_read_string(BdrvChild *file, uint64_t offset, size_t n,
     if (n >= buflen) {
         return -EINVAL;
     }
-    ret = bdrv_pread(file, offset, buf, n, 0);
+    ret = bdrv_pread(file, offset, n, buf, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_do_open(BlockDriverState *bs, QDict *options,
     int64_t file_size;
     int ret;
 
-    ret = bdrv_pread(bs->file, 0, &le_header, sizeof(le_header), 0);
+    ret = bdrv_pread(bs->file, 0, sizeof(le_header), &le_header, 0);
     if (ret < 0) {
         error_setg(errp, "Failed to read QED header");
         return ret;
@@ -XXX,XX +XXX,XX @@ static int bdrv_qed_change_backing_file(BlockDriverState *bs,
     }
 
     /* Write new header */
-    ret = bdrv_pwrite_sync(bs->file, 0, buffer, buffer_len, 0);
+    ret = bdrv_pwrite_sync(bs->file, 0, buffer_len, buffer, 0);
     g_free(buffer);
     if (ret == 0) {
         memcpy(&s->header, &new_header, sizeof(new_header));
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
 
     logout("\n");
 
-    ret = bdrv_pread(bs->file, 0, &header, sizeof(header), 0);
+    ret = bdrv_pread(bs->file, 0, sizeof(header), &header, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, header.offset_bmap, s->bmap,
-                     bmap_size * SECTOR_SIZE, 0);
+    ret = bdrv_pread(bs->file, header.offset_bmap, bmap_size * SECTOR_SIZE,
+                     s->bmap, 0);
     if (ret < 0) {
         goto fail_free_bmap;
     }
@@ -XXX,XX +XXX,XX @@ vdi_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
              * so this full-cluster write does not overlap a partial write
              * of the same cluster, issued from the "else" branch.
              */
-            ret = bdrv_pwrite(bs->file, data_offset, block, s->block_size, 0);
+            ret = bdrv_pwrite(bs->file, data_offset, s->block_size, block, 0);
             qemu_co_rwlock_unlock(&s->bmap_lock);
         } else {
 nonallocating_write:
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
         assert(VDI_IS_ALLOCATED(bmap_first));
         *header = s->header;
         vdi_header_to_le(header);
-        ret = bdrv_pwrite(bs->file, 0, header, sizeof(*header), 0);
+        ret = bdrv_pwrite(bs->file, 0, sizeof(*header), header, 0);
         g_free(header);
 
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
         base = ((uint8_t *)&s->bmap[0]) + bmap_first * SECTOR_SIZE;
         logout("will write %u block map sectors starting from entry %u\n",
                n_sectors, bmap_first);
-        ret = bdrv_pwrite(bs->file, offset * SECTOR_SIZE, base,
-                          n_sectors * SECTOR_SIZE, 0);
+        ret = bdrv_pwrite(bs->file, offset * SECTOR_SIZE,
+                          n_sectors * SECTOR_SIZE, base, 0);
     }
 
     return ret < 0 ? ret : 0;
diff --git a/block/vhdx-log.c b/block/vhdx-log.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx-log.c
+++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_peek_hdr(BlockDriverState *bs, VHDXLogEntries *log,
 
     offset = log->offset + read;
 
-    ret = bdrv_pread(bs->file, offset, hdr, sizeof(VHDXLogEntryHeader), 0);
+    ret = bdrv_pread(bs->file, offset, sizeof(VHDXLogEntryHeader), hdr, 0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_read_sectors(BlockDriverState *bs, VHDXLogEntries *log,
         }
         offset = log->offset + read;
 
-        ret = bdrv_pread(bs->file, offset, buffer, VHDX_LOG_SECTOR_SIZE, 0);
+        ret = bdrv_pread(bs->file, offset, VHDX_LOG_SECTOR_SIZE, buffer, 0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
             /* full */
             break;
         }
-        ret = bdrv_pwrite(bs->file, offset, buffer_tmp, VHDX_LOG_SECTOR_SIZE,
+        ret = bdrv_pwrite(bs->file, offset, VHDX_LOG_SECTOR_SIZE, buffer_tmp,
                           0);
         if (ret < 0) {
             goto exit;
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush_desc(BlockDriverState *bs, VHDXLogDescriptor *desc,
 
     /* count is only > 1 if we are writing zeroes */
     for (i = 0; i < count; i++) {
-        ret = bdrv_pwrite_sync(bs->file, file_offset, buffer,
-                               VHDX_LOG_SECTOR_SIZE, 0);
+        ret = bdrv_pwrite_sync(bs->file, file_offset, VHDX_LOG_SECTOR_SIZE,
+                               buffer, 0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
 
         if (i == 0 && leading_length) {
             /* partial sector at the front of the buffer */
-            ret = bdrv_pread(bs->file, file_offset, merged_sector,
-                             VHDX_LOG_SECTOR_SIZE, 0);
+            ret = bdrv_pread(bs->file, file_offset, VHDX_LOG_SECTOR_SIZE,
+                             merged_sector, 0);
             if (ret < 0) {
                 goto exit;
             }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
         } else if (i == sectors - 1 && trailing_length) {
             /* partial sector at the end of the buffer */
             ret = bdrv_pread(bs->file, file_offset,
-                             merged_sector + trailing_length,
-                             VHDX_LOG_SECTOR_SIZE - trailing_length, 0);
+                             VHDX_LOG_SECTOR_SIZE - trailing_length,
+                             merged_sector + trailing_length, 0);
             if (ret < 0) {
                 goto exit;
             }
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr,
     buffer = qemu_blockalign(bs_file, VHDX_HEADER_SIZE);
     if (read) {
         /* if true, we can't assume the extra reserved bytes are 0 */
-        ret = bdrv_pread(file, offset, buffer, VHDX_HEADER_SIZE, 0);
+        ret = bdrv_pread(file, offset, VHDX_HEADER_SIZE, buffer, 0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int vhdx_write_header(BdrvChild *file, VHDXHeader *hdr,
     vhdx_header_le_export(hdr, header_le);
     vhdx_update_checksum(buffer, VHDX_HEADER_SIZE,
                          offsetof(VHDXHeader, checksum));
-    ret = bdrv_pwrite_sync(file, offset, header_le, sizeof(VHDXHeader), 0);
+    ret = bdrv_pwrite_sync(file, offset, sizeof(VHDXHeader), header_le, 0);
 
 exit:
     qemu_vfree(buffer);
@@ -XXX,XX +XXX,XX @@ static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s,
     /* We have to read the whole VHDX_HEADER_SIZE instead of
      * sizeof(VHDXHeader), because the checksum is over the whole
      * region */
-    ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, buffer, VHDX_HEADER_SIZE,
+    ret = bdrv_pread(bs->file, VHDX_HEADER1_OFFSET, VHDX_HEADER_SIZE, buffer,
                      0);
     if (ret < 0) {
         goto fail;
@@ -XXX,XX +XXX,XX @@ static void vhdx_parse_header(BlockDriverState *bs, BDRVVHDXState *s,
         }
     }
 
-    ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, buffer, VHDX_HEADER_SIZE,
+    ret = bdrv_pread(bs->file, VHDX_HEADER2_OFFSET, VHDX_HEADER_SIZE, buffer,
                      0);
     if (ret < 0) {
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int vhdx_open_region_tables(BlockDriverState *bs, BDRVVHDXState *s)
      * whole block */
     buffer = qemu_blockalign(bs, VHDX_HEADER_BLOCK_SIZE);
 
-    ret = bdrv_pread(bs->file, VHDX_REGION_TABLE_OFFSET, buffer,
-                     VHDX_HEADER_BLOCK_SIZE, 0);
+    ret = bdrv_pread(bs->file, VHDX_REGION_TABLE_OFFSET,
+                     VHDX_HEADER_BLOCK_SIZE, buffer, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
 
     buffer = qemu_blockalign(bs, VHDX_METADATA_TABLE_MAX_SIZE);
 
-    ret = bdrv_pread(bs->file, s->metadata_rt.file_offset, buffer,
-                     VHDX_METADATA_TABLE_MAX_SIZE, 0);
+    ret = bdrv_pread(bs->file, s->metadata_rt.file_offset,
+                     VHDX_METADATA_TABLE_MAX_SIZE, buffer, 0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
     ret = bdrv_pread(bs->file,
                      s->metadata_entries.file_parameters_entry.offset
                                          + s->metadata_rt.file_offset,
-                     &s->params,
                      sizeof(s->params),
+                     &s->params,
                      0);
 
     if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
     ret = bdrv_pread(bs->file,
                      s->metadata_entries.virtual_disk_size_entry.offset
                                            + s->metadata_rt.file_offset,
-                     &s->virtual_disk_size,
                      sizeof(uint64_t),
+                     &s->virtual_disk_size,
                      0);
     if (ret < 0) {
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
     ret = bdrv_pread(bs->file,
                      s->metadata_entries.logical_sector_size_entry.offset
                                              + s->metadata_rt.file_offset,
-                     &s->logical_sector_size,
                      sizeof(uint32_t),
+                     &s->logical_sector_size,
                      0);
     if (ret < 0) {
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int vhdx_parse_metadata(BlockDriverState *bs, BDRVVHDXState *s)
     ret = bdrv_pread(bs->file,
                      s->metadata_entries.phys_sector_size_entry.offset
                                           + s->metadata_rt.file_offset,
-                     &s->physical_sector_size,
                      sizeof(uint32_t),
+                     &s->physical_sector_size,
                      0);
     if (ret < 0) {
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
     QLIST_INIT(&s->regions);
 
     /* validate the file signature */
-    ret = bdrv_pread(bs->file, 0, &signature, sizeof(uint64_t), 0);
+    ret = bdrv_pread(bs->file, 0, sizeof(uint64_t), &signature, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, s->bat_offset, s->bat, s->bat_rt.length, 0);
+    ret = bdrv_pread(bs->file, s->bat_offset, s->bat_rt.length, s->bat, 0);
     if (ret < 0) {
         goto fail;
     }
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_read_cid(BlockDriverState *bs, int parent, uint32_t *pcid)
     int ret;
 
     desc = g_malloc0(DESC_SIZE);
-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
+    ret = bdrv_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
     if (ret < 0) {
         goto out;
     }
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
 
     desc = g_malloc0(DESC_SIZE);
     tmp_desc = g_malloc0(DESC_SIZE);
-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
+    ret = bdrv_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
     if (ret < 0) {
         goto out;
     }
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
         pstrcat(desc, DESC_SIZE, tmp_desc);
     }
 
-    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
+    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
 
 out:
     g_free(desc);
@@ -XXX,XX +XXX,XX @@ static int vmdk_parent_open(BlockDriverState *bs)
     int ret;
 
     desc = g_malloc0(DESC_SIZE + 1);
-    ret = bdrv_pread(bs->file, s->desc_offset, desc, DESC_SIZE, 0);
+    ret = bdrv_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
     if (ret < 0) {
         goto out;
     }
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
         return -ENOMEM;
     }
 
-    ret = bdrv_pread(extent->file, extent->l1_table_offset, extent->l1_table,
-                     l1_size, 0);
+    ret = bdrv_pread(extent->file, extent->l1_table_offset, l1_size,
+                     extent->l1_table, 0);
     if (ret < 0) {
         bdrv_refresh_filename(extent->file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_tables(BlockDriverState *bs, VmdkExtent *extent,
             goto fail_l1;
         }
         ret = bdrv_pread(extent->file, extent->l1_backup_table_offset,
-                         extent->l1_backup_table, l1_size, 0);
+                         l1_size, extent->l1_backup_table, 0);
         if (ret < 0) {
             bdrv_refresh_filename(extent->file->bs);
             error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmfs_sparse(BlockDriverState *bs,
     VMDK3Header header;
     VmdkExtent *extent = NULL;
 
-    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header), 0);
+    ret = bdrv_pread(file, sizeof(magic), sizeof(header), &header, 0);
     if (ret < 0) {
         bdrv_refresh_filename(file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_se_sparse(BlockDriverState *bs,
 
     assert(sizeof(const_header) == SECTOR_SIZE);
 
-    ret = bdrv_pread(file, 0, &const_header, sizeof(const_header), 0);
+    ret = bdrv_pread(file, 0, sizeof(const_header), &const_header, 0);
     if (ret < 0) {
         bdrv_refresh_filename(file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_se_sparse(BlockDriverState *bs,
     assert(sizeof(volatile_header) == SECTOR_SIZE);
 
     ret = bdrv_pread(file, const_header.volatile_header_offset * SECTOR_SIZE,
-                     &volatile_header, sizeof(volatile_header), 0);
+                     sizeof(volatile_header), &volatile_header, 0);
     if (ret < 0) {
         bdrv_refresh_filename(file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static char *vmdk_read_desc(BdrvChild *file, uint64_t desc_offset, Error **errp)
     size = MIN(size, (1 << 20) - 1);  /* avoid unbounded allocation */
     buf = g_malloc(size + 1);
 
-    ret = bdrv_pread(file, desc_offset, buf, size, 0);
+    ret = bdrv_pread(file, desc_offset, size, buf, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read from file");
         g_free(buf);
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
     int64_t l1_backup_offset = 0;
     bool compressed;
 
-    ret = bdrv_pread(file, sizeof(magic), &header, sizeof(header), 0);
+    ret = bdrv_pread(file, sizeof(magic), sizeof(header), &header, 0);
     if (ret < 0) {
         bdrv_refresh_filename(file->bs);
         error_setg_errno(errp, -ret,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_vmdk4(BlockDriverState *bs,
         } QEMU_PACKED footer;
 
         ret = bdrv_pread(file, bs->file->bs->total_sectors * 512 - 1536,
-                         &footer, sizeof(footer), 0);
+                         sizeof(footer), &footer, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to read footer");
             return ret;
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
         if (copy_from_backing) {
             /* qcow2 emits this on bs->file instead of bs->backing */
             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
-            ret = bdrv_pread(bs->backing, offset, whole_grain,
-                             skip_start_bytes, 0);
+            ret = bdrv_pread(bs->backing, offset, skip_start_bytes,
+                             whole_grain, 0);
             if (ret < 0) {
                 ret = VMDK_ERROR;
                 goto exit;
             }
         }
         BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
-        ret = bdrv_pwrite(extent->file, cluster_offset, whole_grain,
-                          skip_start_bytes, 0);
+        ret = bdrv_pwrite(extent->file, cluster_offset, skip_start_bytes,
+                          whole_grain, 0);
         if (ret < 0) {
             ret = VMDK_ERROR;
             goto exit;
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
             /* qcow2 emits this on bs->file instead of bs->backing */
             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
-                             whole_grain + skip_end_bytes,
-                             cluster_bytes - skip_end_bytes, 0);
+                             cluster_bytes - skip_end_bytes,
+                             whole_grain + skip_end_bytes, 0);
             if (ret < 0) {
                 ret = VMDK_ERROR;
                 goto exit;
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
         }
         BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
         ret = bdrv_pwrite(extent->file, cluster_offset + skip_end_bytes,
-                          whole_grain + skip_end_bytes,
-                          cluster_bytes - skip_end_bytes, 0);
+                          cluster_bytes - skip_end_bytes,
+                          whole_grain + skip_end_bytes, 0);
         if (ret < 0) {
             ret = VMDK_ERROR;
             goto exit;
@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
     if (bdrv_pwrite(extent->file,
                 ((int64_t)m_data->l2_offset * 512)
                     + (m_data->l2_index * sizeof(offset)),
-                &offset, sizeof(offset), 0) < 0) {
+                sizeof(offset), &offset, 0) < 0) {
         return VMDK_ERROR;
     }
     /* update backup L2 table */
@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
         if (bdrv_pwrite(extent->file,
                     ((int64_t)m_data->l2_offset * 512)
                         + (m_data->l2_index * sizeof(offset)),
-                    &offset, sizeof(offset), 0) < 0) {
+                    sizeof(offset), &offset, 0) < 0) {
             return VMDK_ERROR;
         }
     }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
     BLKDBG_EVENT(extent->file, BLKDBG_L2_LOAD);
     if (bdrv_pread(extent->file,
                 (int64_t)l2_offset * 512,
-                l2_table,
                 l2_size_bytes,
+                l2_table,
                 0
             ) != l2_size_bytes) {
         return VMDK_ERROR;
@@ -XXX,XX +XXX,XX @@ static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
     cluster_buf = g_malloc(buf_bytes);
     uncomp_buf = g_malloc(cluster_bytes);
     BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
-    ret = bdrv_pread(extent->file, cluster_offset, cluster_buf, buf_bytes, 0);
+    ret = bdrv_pread(extent->file, cluster_offset, buf_bytes, cluster_buf, 0);
     if (ret < 0) {
         goto out;
     }
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    ret = bdrv_pread(bs->file, 0, &s->footer, sizeof(s->footer), 0);
+    ret = bdrv_pread(bs->file, 0, sizeof(s->footer), &s->footer, 0);
     if (ret < 0) {
         error_setg(errp, "Unable to read VHD header");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
         }
 
         /* If a fixed disk, the footer is found only at the end of the file */
-        ret = bdrv_pread(bs->file, offset - sizeof(*footer), footer,
-                         sizeof(*footer), 0);
+        ret = bdrv_pread(bs->file, offset - sizeof(*footer), sizeof(*footer),
+                         footer, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
 
     if (disk_type == VHD_DYNAMIC) {
         ret = bdrv_pread(bs->file, be64_to_cpu(footer->data_offset),
-                         &dyndisk_header, sizeof(dyndisk_header), 0);
+                         sizeof(dyndisk_header), &dyndisk_header, 0);
         if (ret < 0) {
             error_setg(errp, "Error reading dynamic VHD header");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
 
         s->bat_offset = be64_to_cpu(dyndisk_header.table_offset);
 
-        ret = bdrv_pread(bs->file, s->bat_offset, s->pagetable,
-                         pagetable_size, 0);
+        ret = bdrv_pread(bs->file, s->bat_offset, pagetable_size,
+                         s->pagetable, 0);
         if (ret < 0) {
             error_setg(errp, "Error reading pagetable");
             goto fail;
@@ -XXX,XX +XXX,XX @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
 
         s->last_bitmap_offset = bitmap_offset;
         memset(bitmap, 0xff, s->bitmap_size);
-        r = bdrv_pwrite_sync(bs->file, bitmap_offset, bitmap, s->bitmap_size,
+        r = bdrv_pwrite_sync(bs->file, bitmap_offset, s->bitmap_size, bitmap,
                              0);
         if (r < 0) {
             *err = r;
@@ -XXX,XX +XXX,XX @@ static int rewrite_footer(BlockDriverState *bs)
     BDRVVPCState *s = bs->opaque;
     int64_t offset = s->free_data_block_offset;
 
-    ret = bdrv_pwrite_sync(bs->file, offset, &s->footer, sizeof(s->footer), 0);
+    ret = bdrv_pwrite_sync(bs->file, offset, sizeof(s->footer), &s->footer, 0);
     if (ret < 0)
         return ret;
 
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
 
     /* Initialize the block's bitmap */
     memset(bitmap, 0xff, s->bitmap_size);
-    ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset, bitmap,
-                           s->bitmap_size, 0);
+    ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset,
+                           s->bitmap_size, bitmap, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
     /* Write BAT entry to disk */
     bat_offset = s->bat_offset + (4 * index);
     bat_value = cpu_to_be32(s->pagetable[index]);
-    ret = bdrv_pwrite_sync(bs->file, bat_offset, &bat_value, 4, 0);
+    ret = bdrv_pwrite_sync(bs->file, bat_offset, 4, &bat_value, 0);
     if (ret < 0)
         goto fail;
 
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_read(BlockDriverState *bs, int64_t sector_num,
                 DLOG(fprintf(stderr, "sectors %" PRId64 "+%" PRId64
                              " allocated\n", sector_num,
                              n >> BDRV_SECTOR_BITS));
-                if (bdrv_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE,
-                               buf + i * 0x200, n, 0) < 0) {
+                if (bdrv_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE, n,
+                               buf + i * 0x200, 0) < 0) {
                     return -1;
                 }
                 i += (n >> BDRV_SECTOR_BITS) - 1;
@@ -XXX,XX +XXX,XX @@ static uint32_t get_cluster_count_for_direntry(BDRVVVFATState* s,
                             return -1;
                         }
                         res = bdrv_pwrite(s->qcow, offset * BDRV_SECTOR_SIZE,
-                                          s->cluster_buffer, BDRV_SECTOR_SIZE,
+                                          BDRV_SECTOR_SIZE, s->cluster_buffer,
                                           0);
                         if (res < 0) {
                             return -2;
@@ -XXX,XX +XXX,XX @@ DLOG(checkpoint());
      * Use qcow backend. Commit later.
      */
 DLOG(fprintf(stderr, "Write to qcow backend: %d + %d\n", (int)sector_num, nb_sectors));
-    ret = bdrv_pwrite(s->qcow, sector_num * BDRV_SECTOR_SIZE, buf,
-                      nb_sectors * BDRV_SECTOR_SIZE, 0);
+    ret = bdrv_pwrite(s->qcow, sector_num * BDRV_SECTOR_SIZE,
+                      nb_sectors * BDRV_SECTOR_SIZE, buf, 0);
     if (ret < 0) {
         fprintf(stderr, "Error writing to qcow backend\n");
         return ret;
diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-block-iothread.c
+++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pread(BdrvChild *c)
     int ret;
 
     /* Success */
-    ret = bdrv_pread(c, 0, buf, sizeof(buf), 0);
+    ret = bdrv_pread(c, 0, sizeof(buf), buf, 0);
     g_assert_cmpint(ret, ==, 512);
 
     /* Early error: Negative offset */
-    ret = bdrv_pread(c, -2, buf, sizeof(buf), 0);
+    ret = bdrv_pread(c, -2, sizeof(buf), buf, 0);
     g_assert_cmpint(ret, ==, -EIO);
 }
 
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pwrite(BdrvChild *c)
     int ret;
 
     /* Success */
-    ret = bdrv_pwrite(c, 0, buf, sizeof(buf), 0);
+    ret = bdrv_pwrite(c, 0, sizeof(buf), buf, 0);
     g_assert_cmpint(ret, ==, 512);
 
     /* Early error: Negative offset */
-    ret = bdrv_pwrite(c, -2, buf, sizeof(buf), 0);
+    ret = bdrv_pwrite(c, -2, sizeof(buf), buf, 0);
     g_assert_cmpint(ret, ==, -EIO);
 }
 
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

They currently return the value of their 'bytes' parameter on success.

Make them return 0 instead, for consistency with other I/O functions and
in preparation to implement them using generated_co_wrapper. This also
makes it clear that short reads/writes are not possible.

The few callers that rely on the previous behavior are adjusted
accordingly by hand.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20220609152744.3891847-4-afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/cloop.c                    |  2 +-
 block/crypto.c                   |  4 ++--
 block/dmg.c                      | 10 +++++-----
 block/io.c                       | 10 ++--------
 block/qcow.c                     |  2 +-
 block/qcow2.c                    |  4 ++--
 block/qed.c                      |  7 +------
 block/vdi.c                      |  2 +-
 block/vmdk.c                     |  5 ++---
 tests/unit/test-block-iothread.c |  4 ++--
 10 files changed, 19 insertions(+), 31 deletions(-)

diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
 
         ret = bdrv_pread(bs->file, s->offsets[block_num], bytes,
                          s->compressed_block, 0);
-        if (ret != bytes) {
+        if (ret < 0) {
             return -1;
         }
 
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return ret;
     }
-    return ret;
+    return buflen;
 }
 
 static ssize_t block_crypto_write_func(QCryptoBlock *block,
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_write_func(QCryptoBlock *block,
         error_setg_errno(errp, -ret, "Could not write encryption header");
         return ret;
     }
-    return ret;
+    return buflen;
 }
 
 
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_read_plist_xml(BlockDriverState *bs, DmgHeaderState *ds,
     buffer = g_malloc(info_length + 1);
     buffer[info_length] = '\0';
     ret = bdrv_pread(bs->file, info_begin, info_length, buffer, 0);
-    if (ret != info_length) {
+    if (ret < 0) {
         ret = -EINVAL;
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
              * inflated. */
             ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
                              s->compressed_chunk, 0);
-            if (ret != s->lengths[chunk]) {
+            if (ret < 0) {
                 return -1;
             }
 
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
              * inflated. */
             ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
                              s->compressed_chunk, 0);
-            if (ret != s->lengths[chunk]) {
+            if (ret < 0) {
                 return -1;
             }
 
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
              * inflated. */
             ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
                              s->compressed_chunk, 0);
-            if (ret != s->lengths[chunk]) {
+            if (ret < 0) {
                 return -1;
             }
 
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
         case UDRW: /* copy */
             ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
                              s->uncompressed_chunk, 0);
-            if (ret != s->lengths[chunk]) {
+            if (ret < 0) {
                 return -1;
             }
             break;
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
 int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
                BdrvRequestFlags flags)
 {
-    int ret;
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
     IO_CODE();
 
@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
         return -EINVAL;
     }
 
-    ret = bdrv_preadv(child, offset, bytes, &qiov, flags);
-
-    return ret < 0 ? ret : bytes;
+    return bdrv_preadv(child, offset, bytes, &qiov, flags);
 }
 
 /* Return no. of bytes on success or < 0 on error. Important errors are:
@@ -XXX,XX +XXX,XX @@ int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
 int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
                 const void *buf, BdrvRequestFlags flags)
 {
-    int ret;
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
     IO_CODE();
 
@@ -XXX,XX +XXX,XX @@ int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
         return -EINVAL;
     }
 
-    ret = bdrv_pwritev(child, offset, bytes, &qiov, flags);
-
-    return ret < 0 ? ret : bytes;
+    return bdrv_pwritev(child, offset, bytes, &qiov, flags);
 }
 
 /*
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
         csize &= (s->cluster_size - 1);
         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
         ret = bdrv_pread(bs->file, coffset, csize, s->cluster_data, 0);
-        if (ret != csize)
+        if (ret < 0)
             return -1;
         if (decompress_buffer(s->cluster_cache, s->cluster_size,
                               s->cluster_data, csize) < 0) {
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return -1;
     }
-    return ret;
+    return buflen;
 }
 
 
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return -1;
     }
-    return ret;
+    return buflen;
 }
 
 static QDict*
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static void qed_header_cpu_to_le(const QEDHeader *cpu, QEDHeader *le)
 int qed_write_header_sync(BDRVQEDState *s)
 {
     QEDHeader le;
-    int ret;
 
     qed_header_cpu_to_le(&s->header, &le);
-    ret = bdrv_pwrite(s->bs->file, 0, sizeof(le), &le, 0);
-    if (ret != sizeof(le)) {
-        return ret;
-    }
-    return 0;
+    return bdrv_pwrite(s->bs->file, 0, sizeof(le), &le, 0);
 }
 
 /**
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
                           n_sectors * SECTOR_SIZE, base, 0);
     }
 
-    return ret < 0 ? ret : 0;
+    return ret;
 }
 
 static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_parent_open(BlockDriverState *bs)
     if (ret < 0) {
         goto out;
     }
-    ret = 0;
 
     p_name = strstr(desc, "parentFileNameHint");
     if (p_name != NULL) {
@@ -XXX,XX +XXX,XX @@ static char *vmdk_read_desc(BdrvChild *file, uint64_t desc_offset, Error **errp)
         g_free(buf);
         return NULL;
     }
-    buf[ret] = 0;
+    buf[size] = 0;
 
     return buf;
 }
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
                 l2_size_bytes,
                 l2_table,
                 0
-            ) != l2_size_bytes) {
+            ) < 0) {
         return VMDK_ERROR;
     }
 
diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-block-iothread.c
+++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pread(BdrvChild *c)
 
     /* Success */
     ret = bdrv_pread(c, 0, sizeof(buf), buf, 0);
-    g_assert_cmpint(ret, ==, 512);
+    g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
     ret = bdrv_pread(c, -2, sizeof(buf), buf, 0);
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_pwrite(BdrvChild *c)
 
     /* Success */
     ret = bdrv_pwrite(c, 0, sizeof(buf), buf, 0);
-    g_assert_cmpint(ret, ==, 512);
+    g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
     ret = bdrv_pwrite(c, -2, sizeof(buf), buf, 0);
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

They currently return the value of their headerlen/buflen parameter on
success. Returning 0 instead makes it clear that short reads/writes are
not possible.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20220609152744.3891847-5-afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/crypto/block.h         | 32 ++++++++++-----------
 block/crypto.c                 | 52 +++++++++++++++++-----------------
 block/qcow2.c                  | 22 +++++++-------
 crypto/block-luks.c            |  8 +++---
 crypto/block.c                 |  6 ++--
 tests/unit/test-crypto-block.c | 38 ++++++++++++-------------
 6 files changed, 79 insertions(+), 79 deletions(-)

diff --git a/include/crypto/block.h b/include/crypto/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/crypto/block.h
+++ b/include/crypto/block.h
@@ -XXX,XX +XXX,XX @@ typedef struct QCryptoBlock QCryptoBlock;
 /* See also QCryptoBlockFormat, QCryptoBlockCreateOptions
  * and QCryptoBlockOpenOptions in qapi/crypto.json */
 
-typedef ssize_t (*QCryptoBlockReadFunc)(QCryptoBlock *block,
-                                        size_t offset,
-                                        uint8_t *buf,
-                                        size_t buflen,
-                                        void *opaque,
-                                        Error **errp);
+typedef int (*QCryptoBlockReadFunc)(QCryptoBlock *block,
+                                    size_t offset,
+                                    uint8_t *buf,
+                                    size_t buflen,
+                                    void *opaque,
+                                    Error **errp);
 
-typedef ssize_t (*QCryptoBlockInitFunc)(QCryptoBlock *block,
-                                        size_t headerlen,
-                                        void *opaque,
-                                        Error **errp);
+typedef int (*QCryptoBlockInitFunc)(QCryptoBlock *block,
+                                    size_t headerlen,
+                                    void *opaque,
+                                    Error **errp);
 
-typedef ssize_t (*QCryptoBlockWriteFunc)(QCryptoBlock *block,
-                                         size_t offset,
-                                         const uint8_t *buf,
-                                         size_t buflen,
-                                         void *opaque,
-                                         Error **errp);
+typedef int (*QCryptoBlockWriteFunc)(QCryptoBlock *block,
+                                     size_t offset,
+                                     const uint8_t *buf,
+                                     size_t buflen,
+                                     void *opaque,
+                                     Error **errp);
 
 /**
  * qcrypto_block_has_format:
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_probe_generic(QCryptoBlockFormat format,
 }
 
 
-static ssize_t block_crypto_read_func(QCryptoBlock *block,
-                                      size_t offset,
-                                      uint8_t *buf,
-                                      size_t buflen,
-                                      void *opaque,
-                                      Error **errp)
+static int block_crypto_read_func(QCryptoBlock *block,
+                                  size_t offset,
+                                  uint8_t *buf,
+                                  size_t buflen,
+                                  void *opaque,
+                                  Error **errp)
 {
     BlockDriverState *bs = opaque;
     ssize_t ret;
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_read_func(QCryptoBlock *block,
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return ret;
     }
-    return buflen;
+    return 0;
 }
 
-static ssize_t block_crypto_write_func(QCryptoBlock *block,
-                                       size_t offset,
-                                       const uint8_t *buf,
-                                       size_t buflen,
-                                       void *opaque,
-                                       Error **errp)
+static int block_crypto_write_func(QCryptoBlock *block,
+                                   size_t offset,
+                                   const uint8_t *buf,
+                                   size_t buflen,
+                                   void *opaque,
+                                   Error **errp)
 {
     BlockDriverState *bs = opaque;
     ssize_t ret;
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_write_func(QCryptoBlock *block,
         error_setg_errno(errp, -ret, "Could not write encryption header");
         return ret;
     }
-    return buflen;
+    return 0;
 }
 
 
@@ -XXX,XX +XXX,XX @@ struct BlockCryptoCreateData {
 };
 
 
-static ssize_t block_crypto_create_write_func(QCryptoBlock *block,
-                                              size_t offset,
-                                              const uint8_t *buf,
-                                              size_t buflen,
-                                              void *opaque,
-                                              Error **errp)
+static int block_crypto_create_write_func(QCryptoBlock *block,
+                                          size_t offset,
+                                          const uint8_t *buf,
+                                          size_t buflen,
+                                          void *opaque,
+                                          Error **errp)
 {
     struct BlockCryptoCreateData *data = opaque;
     ssize_t ret;
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_create_write_func(QCryptoBlock *block,
         error_setg_errno(errp, -ret, "Could not write encryption header");
         return ret;
     }
-    return ret;
+    return 0;
 }
 
-static ssize_t block_crypto_create_init_func(QCryptoBlock *block,
-                                             size_t headerlen,
-                                             void *opaque,
-                                             Error **errp)
+static int block_crypto_create_init_func(QCryptoBlock *block,
+                                         size_t headerlen,
+                                         void *opaque,
+                                         Error **errp)
 {
     struct BlockCryptoCreateData *data = opaque;
     Error *local_error = NULL;
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_create_init_func(QCryptoBlock *block,
                        data->prealloc, 0, &local_error);
 
     if (ret >= 0) {
-        return ret;
+        return 0;
     }
 
 error:
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
 }
 
 
-static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
-                                          uint8_t *buf, size_t buflen,
-                                          void *opaque, Error **errp)
+static int qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
+                                      uint8_t *buf, size_t buflen,
+                                      void *opaque, Error **errp)
 {
     BlockDriverState *bs = opaque;
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return -1;
     }
-    return buflen;
+    return 0;
 }
 
 
-static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
-                                          void *opaque, Error **errp)
+static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
+                                      void *opaque, Error **errp)
 {
     BlockDriverState *bs = opaque;
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
         return -1;
     }
 
-    return ret;
+    return 0;
 }
 
 
-static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
-                                           const uint8_t *buf, size_t buflen,
-                                           void *opaque, Error **errp)
+static int qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
+                                       const uint8_t *buf, size_t buflen,
+                                       void *opaque, Error **errp)
 {
     BlockDriverState *bs = opaque;
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
         error_setg_errno(errp, -ret, "Could not read encryption header");
         return -1;
     }
-    return buflen;
+    return 0;
 }
 
 static QDict*
diff --git a/crypto/block-luks.c b/crypto/block-luks.c
index XXXXXXX..XXXXXXX 100644
--- a/crypto/block-luks.c
+++ b/crypto/block-luks.c
@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_load_header(QCryptoBlock *block,
                                 void *opaque,
                                 Error **errp)
 {
-    ssize_t rv;
+    int rv;
     size_t i;
     QCryptoBlockLUKS *luks = block->opaque;
 
@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_store_key(QCryptoBlock *block,
                   QCRYPTO_BLOCK_LUKS_SECTOR_SIZE,
                   splitkey, splitkeylen,
                   opaque,
-                  errp) != splitkeylen) {
+                  errp) < 0) {
         goto cleanup;
     }
 
@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_load_key(QCryptoBlock *block,
     g_autofree uint8_t *splitkey = NULL;
     size_t splitkeylen;
     g_autofree uint8_t *possiblekey = NULL;
-    ssize_t rv;
+    int rv;
     g_autoptr(QCryptoCipher) cipher = NULL;
     uint8_t keydigest[QCRYPTO_BLOCK_LUKS_DIGEST_LEN];
     g_autoptr(QCryptoIVGen) ivgen = NULL;
@@ -XXX,XX +XXX,XX @@ qcrypto_block_luks_erase_key(QCryptoBlock *block,
                       garbagesplitkey,
                       splitkeylen,
                       opaque,
-                      &local_err) != splitkeylen) {
+                      &local_err) < 0) {
             error_propagate(errp, local_err);
             return -1;
         }
diff --git a/crypto/block.c b/crypto/block.c
index XXXXXXX..XXXXXXX 100644
--- a/crypto/block.c
+++ b/crypto/block.c
@@ -XXX,XX +XXX,XX @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
 }
 
 
-static ssize_t qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
+static int qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
         size_t headerlen, void *opaque, Error **errp)
 {
     size_t *headerlenp = opaque;
@@ -XXX,XX +XXX,XX @@ static ssize_t qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
 }
 
 
-static ssize_t qcrypto_block_headerlen_hdr_write_func(QCryptoBlock *block,
+static int qcrypto_block_headerlen_hdr_write_func(QCryptoBlock *block,
         size_t offset, const uint8_t *buf, size_t buflen,
         void *opaque, Error **errp)
 {
     /* Discard the bytes, we're not actually writing to an image */
-    return buflen;
+    return 0;
 }
 
 
diff --git a/tests/unit/test-crypto-block.c b/tests/unit/test-crypto-block.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-crypto-block.c
+++ b/tests/unit/test-crypto-block.c
@@ -XXX,XX +XXX,XX @@ static struct QCryptoBlockTestData {
 };
 
 
-static ssize_t test_block_read_func(QCryptoBlock *block,
-                                    size_t offset,
-                                    uint8_t *buf,
-                                    size_t buflen,
-                                    void *opaque,
-                                    Error **errp)
+static int test_block_read_func(QCryptoBlock *block,
+                                size_t offset,
+                                uint8_t *buf,
+                                size_t buflen,
+                                void *opaque,
+                                Error **errp)
 {
     Buffer *header = opaque;
 
@@ -XXX,XX +XXX,XX @@ static ssize_t test_block_read_func(QCryptoBlock *block,
 
     memcpy(buf, header->buffer + offset, buflen);
 
-    return buflen;
+    return 0;
 }
 
 
-static ssize_t test_block_init_func(QCryptoBlock *block,
-                                    size_t headerlen,
-                                    void *opaque,
-                                    Error **errp)
+static int test_block_init_func(QCryptoBlock *block,
+                                size_t headerlen,
+                                void *opaque,
+                                Error **errp)
 {
     Buffer *header = opaque;
 
@@ -XXX,XX +XXX,XX @@ static ssize_t test_block_init_func(QCryptoBlock *block,
 
     buffer_reserve(header, headerlen);
 
-    return headerlen;
+    return 0;
 }
 
 
-static ssize_t test_block_write_func(QCryptoBlock *block,
-                                     size_t offset,
-                                     const uint8_t *buf,
-                                     size_t buflen,
-                                     void *opaque,
-                                     Error **errp)
+static int test_block_write_func(QCryptoBlock *block,
+                                 size_t offset,
+                                 const uint8_t *buf,
+                                 size_t buflen,
+                                 void *opaque,
+                                 Error **errp)
 {
     Buffer *header = opaque;
 
@@ -XXX,XX +XXX,XX @@ static ssize_t test_block_write_func(QCryptoBlock *block,
     memcpy(header->buffer + offset, buf, buflen);
     header->offset = offset + buflen;
 
-    return buflen;
+    return 0;
 }
 
 
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

It does not mutate the buffer.

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 @@ static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
 }
 
 static inline int coroutine_fn bdrv_co_pwrite(BdrvChild *child,
-    int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags)
+    int64_t offset, unsigned int bytes, const void *buf, BdrvRequestFlags flags)
 {
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
     IO_CODE();
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

For consistency with other I/O functions, and in preparation to
implement bdrv_{pread,pwrite}() using generated_co_wrapper.

unsigned int fits in int64_t, so all callers remain correct.

bdrv_check_request32() is called further down the stack and causes -EIO
to be returned if 'bytes' is negative or greater than
BDRV_REQUEST_MAX_BYTES, which in turns never exceeds SIZE_MAX.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Message-Id: <20220609152744.3891847-7-afaria@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/coroutines.h           | 4 ++--
 include/block/block_int-io.h | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/block/coroutines.h b/block/coroutines.h
index XXXXXXX..XXXXXXX 100644
--- a/block/coroutines.h
+++ b/block/coroutines.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_do_flush(BlockBackend *blk);
  */
 
 int generated_co_wrapper
-bdrv_preadv(BdrvChild *child, int64_t offset, unsigned int bytes,
+bdrv_preadv(BdrvChild *child, int64_t offset, int64_t bytes,
             QEMUIOVector *qiov, BdrvRequestFlags flags);
 
 int generated_co_wrapper
-bdrv_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes,
+bdrv_pwritev(BdrvChild *child, int64_t offset, int64_t bytes,
              QEMUIOVector *qiov, BdrvRequestFlags flags);
 
 int generated_co_wrapper
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 @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
     QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags);
 
 static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
-    int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags)
+    int64_t offset, int64_t bytes, void *buf, BdrvRequestFlags flags)
 {
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
     IO_CODE();
@@ -XXX,XX +XXX,XX @@ static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
 }
 
 static inline int coroutine_fn bdrv_co_pwrite(BdrvChild *child,
-    int64_t offset, unsigned int bytes, const void *buf, BdrvRequestFlags flags)
+    int64_t offset, int64_t bytes, const void *buf, BdrvRequestFlags flags)
 {
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
     IO_CODE();
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

bdrv_{pread,pwrite}() now return -EIO instead of -EINVAL when 'bytes' is
negative, making them consistent with bdrv_{preadv,pwritev}() and
bdrv_co_{pread,pwrite,preadv,pwritev}().

bdrv_pwrite_zeroes() now also calls trace_bdrv_co_pwrite_zeroes() and
clears the BDRV_REQ_MAY_UNMAP flag when appropriate, which it didn't
previously.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Message-Id: <20220609152744.3891847-8-afaria@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/block/block-io.h | 15 +++++++++------
 block/io.c               | 41 ----------------------------------------
 2 files changed, 9 insertions(+), 47 deletions(-)

diff --git a/include/block/block-io.h b/include/block/block-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -XXX,XX +XXX,XX @@
  * to catch when they are accidentally called by the wrong API.
  */
 
-int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
-                       int64_t bytes, BdrvRequestFlags flags);
+int generated_co_wrapper bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
+                                            int64_t bytes,
+                                            BdrvRequestFlags flags);
 int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags);
-int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
-               BdrvRequestFlags flags);
-int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
-                const void *buf, BdrvRequestFlags flags);
+int generated_co_wrapper bdrv_pread(BdrvChild *child, int64_t offset,
+                                    int64_t bytes, void *buf,
+                                    BdrvRequestFlags flags);
+int generated_co_wrapper bdrv_pwrite(BdrvChild *child, int64_t offset,
+                                     int64_t bytes, const void *buf,
+                                     BdrvRequestFlags flags);
 int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
                      const void *buf, 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 @@ static int bdrv_check_request32(int64_t offset, int64_t bytes,
     return 0;
 }
 
-int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
-                       int64_t bytes, BdrvRequestFlags flags)
-{
-    IO_CODE();
-    return bdrv_pwritev(child, offset, bytes, NULL,
-                        BDRV_REQ_ZERO_WRITE | flags);
-}
-
 /*
  * Completely zero out a block device with the help of bdrv_pwrite_zeroes.
  * The operation is sped up by checking the block status and only writing
@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
     }
 }
 
-/* See bdrv_pwrite() for the return codes */
-int bdrv_pread(BdrvChild *child, int64_t offset, int64_t bytes, void *buf,
-               BdrvRequestFlags flags)
-{
-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
-    IO_CODE();
-
-    if (bytes < 0) {
-        return -EINVAL;
-    }
-
-    return bdrv_preadv(child, offset, bytes, &qiov, flags);
-}
-
-/* Return no. of bytes on success or < 0 on error. Important errors are:
-  -EIO         generic I/O error (may happen for all errors)
-  -ENOMEDIUM   No media inserted.
-  -EINVAL      Invalid offset or number of bytes
-  -EACCES      Trying to write a read-only device
-*/
-int bdrv_pwrite(BdrvChild *child, int64_t offset, int64_t bytes,
-                const void *buf, BdrvRequestFlags flags)
-{
-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
-    IO_CODE();
-
-    if (bytes < 0) {
-        return -EINVAL;
-    }
-
-    return bdrv_pwritev(child, offset, bytes, &qiov, flags);
-}
-
 /*
  * Writes to the file and ensures that no writes are reordered across this
  * request (acts as a barrier)
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Also convert bdrv_pwrite_sync() to being implemented using
generated_co_wrapper.

diff --git a/include/block/block-io.h b/include/block/block-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper bdrv_pread(BdrvChild *child, int64_t offset,
 int generated_co_wrapper bdrv_pwrite(BdrvChild *child, int64_t offset,
                                      int64_t bytes, const void *buf,
                                      BdrvRequestFlags flags);
-int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
-                     const void *buf, BdrvRequestFlags flags);
+int generated_co_wrapper bdrv_pwrite_sync(BdrvChild *child, int64_t offset,
+                                          int64_t bytes, const void *buf,
+                                          BdrvRequestFlags flags);
+int coroutine_fn bdrv_co_pwrite_sync(BdrvChild *child, int64_t offset,
+                                     int64_t bytes, const void *buf,
+                                     BdrvRequestFlags flags);
 /*
  * Efficiently zero a region of the disk image.  Note that this is a regular
  * I/O request like read or write and should have a reasonable size.  This
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
  *
  * Returns 0 on success, -errno in error cases.
  */
-int bdrv_pwrite_sync(BdrvChild *child, int64_t offset, int64_t bytes,
-                     const void *buf, BdrvRequestFlags flags)
+int coroutine_fn bdrv_co_pwrite_sync(BdrvChild *child, int64_t offset,
+                                     int64_t bytes, const void *buf,
+                                     BdrvRequestFlags flags)
 {
     int ret;
     IO_CODE();
 
-    ret = bdrv_pwrite(child, offset, bytes, buf, flags);
+    ret = bdrv_co_pwrite(child, offset, bytes, buf, flags);
     if (ret < 0) {
         return ret;
     }
 
-    ret = bdrv_flush(child->bs);
+    ret = bdrv_co_flush(child->bs);
     if (ret < 0) {
         return ret;
     }
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Convert uses of bdrv_pwrite_sync() into bdrv_co_pwrite_sync() when the
callers are already coroutine_fn.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20220609152744.3891847-10-afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/parallels.c      | 2 +-
 block/qcow2-snapshot.c | 6 +++---
 block/qcow2.c          | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
 
     ret = 0;
     if (flush_bat) {
-        ret = bdrv_pwrite_sync(bs->file, 0, s->header_size, s->header, 0);
+        ret = bdrv_co_pwrite_sync(bs->file, 0, s->header_size, s->header, 0);
         if (ret < 0) {
             res->check_errors++;
             goto out;
diff --git a/block/qcow2-snapshot.c b/block/qcow2-snapshot.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-snapshot.c
+++ b/block/qcow2-snapshot.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_check_read_snapshot_table(BlockDriverState *bs,
         assert(fix & BDRV_FIX_ERRORS);
 
         snapshot_table_pointer.nb_snapshots = cpu_to_be32(s->nb_snapshots);
-        ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
-                               sizeof(snapshot_table_pointer.nb_snapshots),
-                               &snapshot_table_pointer.nb_snapshots, 0);
+        ret = bdrv_co_pwrite_sync(bs->file, offsetof(QCowHeader, nb_snapshots),
+                                  sizeof(snapshot_table_pointer.nb_snapshots),
+                                  &snapshot_table_pointer.nb_snapshots, 0);
         if (ret < 0) {
             result->check_errors++;
             fprintf(stderr, "ERROR failed to update the snapshot count in the "
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
 
     /* write updated header.size */
     offset = cpu_to_be64(offset);
-    ret = bdrv_pwrite_sync(bs->file, offsetof(QCowHeader, size),
-                           sizeof(offset), &offset, 0);
+    ret = bdrv_co_pwrite_sync(bs->file, offsetof(QCowHeader, size),
+                              sizeof(offset), &offset, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to update the image size");
         goto fail;
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Use bdrv_pwrite_sync() instead of calling bdrv_pwrite() and bdrv_flush()
separately.

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ int qcow2_mark_dirty(BlockDriverState *bs)
     }
 
     val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY);
-    ret = bdrv_pwrite(bs->file, offsetof(QCowHeader, incompatible_features),
-                      sizeof(val), &val, 0);
-    if (ret < 0) {
-        return ret;
-    }
-    ret = bdrv_flush(bs->file->bs);
+    ret = bdrv_pwrite_sync(bs->file,
+                           offsetof(QCowHeader, incompatible_features),
+                           sizeof(val), &val, 0);
     if (ret < 0) {
         return ret;
     }
-- 
2.35.3

From: John Snow <jsnow@redhat.com>

Fixes: 58a6fdcc
Signed-off-by: John Snow <jsnow@redhat.com>
Tested-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20220616142659.3184115-2-jsnow@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 tests/qemu-iotests/223.out | 4 ++--
 tests/qemu-iotests/307.out | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/qemu-iotests/223.out b/tests/qemu-iotests/223.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/223.out
+++ b/tests/qemu-iotests/223.out
@@ -XXX,XX +XXX,XX @@ exports available: 3
  export: 'n2'
   description: some text
   size:  4194304
-  flags: 0xced ( flush fua trim zeroes df cache fast-zero )
+  flags: 0xded ( flush fua trim zeroes df multi cache fast-zero )
   min block: 1
   opt block: 4096
   max block: 33554432
@@ -XXX,XX +XXX,XX @@ exports available: 3
  export: 'n2'
   description: some text
   size:  4194304
-  flags: 0xced ( flush fua trim zeroes df cache fast-zero )
+  flags: 0xded ( flush fua trim zeroes df multi cache fast-zero )
   min block: 1
   opt block: 4096
   max block: 33554432
diff --git a/tests/qemu-iotests/307.out b/tests/qemu-iotests/307.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/307.out
+++ b/tests/qemu-iotests/307.out
@@ -XXX,XX +XXX,XX @@ exports available: 2
  export: 'export1'
   description: This is the writable second export
   size:  67108864
-  flags: 0xced ( flush fua trim zeroes df cache fast-zero )
+  flags: 0xded ( flush fua trim zeroes df multi cache fast-zero )
   min block: XXX
   opt block: XXX
   max block: XXX
@@ -XXX,XX +XXX,XX @@ exports available: 1
  export: 'export1'
   description: This is the writable second export
   size:  67108864
-  flags: 0xced ( flush fua trim zeroes df cache fast-zero )
+  flags: 0xded ( flush fua trim zeroes df multi cache fast-zero )
   min block: XXX
   opt block: XXX
   max block: XXX
-- 
2.35.3

From: John Snow <jsnow@redhat.com>

In certain container environments we may not have FUSE at all, so skip
the test in this circumstance too.

Signed-off-by: John Snow <jsnow@redhat.com>
Message-Id: <20220616142659.3184115-3-jsnow@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 tests/qemu-iotests/108 | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/qemu-iotests/108 b/tests/qemu-iotests/108
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/108
+++ b/tests/qemu-iotests/108
@@ -XXX,XX +XXX,XX @@ if sudo -n losetup &>/dev/null; then
 else
     loopdev=false
 
+    # Check for usable FUSE in the host environment:
+    if test ! -c "/dev/fuse"; then
+        _notrun 'No passwordless sudo nor usable /dev/fuse'
+    fi
+
     # QSD --export fuse will either yield "Parameter 'id' is missing"
     # or "Invalid parameter 'fuse'", depending on whether there is
     # FUSE support or not.
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

They currently return the value of their 'bytes' parameter on success.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Message-Id: <20220705161527.1054072-2-afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block.c                          |  8 +++++---
 block/block-backend.c            |  7 ++-----
 block/qcow.c                     |  6 +++---
 hw/block/m25p80.c                |  2 +-
 hw/misc/mac_via.c                |  4 ++--
 hw/misc/sifive_u_otp.c           |  2 +-
 hw/nvram/eeprom_at24c.c          |  8 ++++----
 hw/nvram/spapr_nvram.c           | 14 +++++++-------
 hw/ppc/pnv_pnor.c                |  2 +-
 qemu-img.c                       | 25 +++++++++----------------
 qemu-io-cmds.c                   | 18 ++++++++++++------
 tests/unit/test-block-iothread.c |  4 ++--
 12 files changed, 49 insertions(+), 51 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int find_image_format(BlockBackend *file, const char *filename,
         return ret;
     }
 
-    drv = bdrv_probe_all(buf, ret, filename);
+    drv = bdrv_probe_all(buf, sizeof(buf), filename);
     if (!drv) {
         error_setg(errp, "Could not determine image format: No compatible "
                    "driver found");
-        ret = -ENOENT;
+        *pdrv = NULL;
+        return -ENOENT;
     }
+
     *pdrv = drv;
-    return ret;
+    return 0;
 }
 
 /**
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes)
     ret = blk_do_preadv(blk, offset, bytes, &qiov, 0);
     blk_dec_in_flight(blk);
 
-    return ret < 0 ? ret : bytes;
+    return ret;
 }
 
 int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes,
                BdrvRequestFlags flags)
 {
-    int ret;
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
     IO_OR_GS_CODE();
 
-    ret = blk_pwritev_part(blk, offset, bytes, &qiov, 0, flags);
-
-    return ret < 0 ? ret : bytes;
+    return blk_pwritev_part(blk, offset, bytes, &qiov, 0, flags);
 }
 
 int64_t blk_getlength(BlockBackend *blk)
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
 
     /* write all the data */
     ret = blk_pwrite(qcow_blk, 0, &header, sizeof(header), 0);
-    if (ret != sizeof(header)) {
+    if (ret < 0) {
         goto exit;
     }
 
     if (qcow_opts->has_backing_file) {
         ret = blk_pwrite(qcow_blk, sizeof(header),
                          qcow_opts->backing_file, backing_filename_len, 0);
-        if (ret != backing_filename_len) {
+        if (ret < 0) {
             goto exit;
         }
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
          i++) {
         ret = blk_pwrite(qcow_blk, header_size + BDRV_SECTOR_SIZE * i,
                          tmp, BDRV_SECTOR_SIZE, 0);
-        if (ret != BDRV_SECTOR_SIZE) {
+        if (ret < 0) {
             g_free(tmp);
             goto exit;
         }
diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/m25p80.c
+++ b/hw/block/m25p80.c
@@ -XXX,XX +XXX,XX @@ static void m25p80_realize(SSIPeripheral *ss, Error **errp)
         trace_m25p80_binding(s);
         s->storage = blk_blockalign(s->blk, s->size);
 
-        if (blk_pread(s->blk, 0, s->storage, s->size) != s->size) {
+        if (blk_pread(s->blk, 0, s->storage, s->size) < 0) {
             error_setg(errp, "failed to read the initial flash content");
             return;
         }
diff --git a/hw/misc/mac_via.c b/hw/misc/mac_via.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/misc/mac_via.c
+++ b/hw/misc/mac_via.c
@@ -XXX,XX +XXX,XX @@ static void mos6522_q800_via1_realize(DeviceState *dev, Error **errp)
             return;
         }
 
-        len = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM));
-        if (len != sizeof(v1s->PRAM)) {
+        ret = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM));
+        if (ret < 0) {
             error_setg(errp, "can't read PRAM contents");
             return;
         }
diff --git a/hw/misc/sifive_u_otp.c b/hw/misc/sifive_u_otp.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/misc/sifive_u_otp.c
+++ b/hw/misc/sifive_u_otp.c
@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)
                 return;
             }
 
-            if (blk_pread(s->blk, 0, s->fuse, filesize) != filesize) {
+            if (blk_pread(s->blk, 0, s->fuse, filesize) < 0) {
                 error_setg(errp, "failed to read the initial flash content");
                 return;
             }
diff --git a/hw/nvram/eeprom_at24c.c b/hw/nvram/eeprom_at24c.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/nvram/eeprom_at24c.c
+++ b/hw/nvram/eeprom_at24c.c
@@ -XXX,XX +XXX,XX @@ int at24c_eeprom_event(I2CSlave *s, enum i2c_event event)
     case I2C_START_RECV:
         DPRINTK("clear\n");
         if (ee->blk && ee->changed) {
-            int len = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
-            if (len != ee->rsize) {
+            int ret = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
+            if (ret < 0) {
                 ERR(TYPE_AT24C_EE
                         " : failed to write backing file\n");
             }
@@ -XXX,XX +XXX,XX @@ void at24c_eeprom_reset(DeviceState *state)
     memset(ee->mem, 0, ee->rsize);
 
     if (ee->blk) {
-        int len = blk_pread(ee->blk, 0, ee->mem, ee->rsize);
+        int ret = blk_pread(ee->blk, 0, ee->mem, ee->rsize);
 
-        if (len != ee->rsize) {
+        if (ret < 0) {
             ERR(TYPE_AT24C_EE
                     " : Failed initial sync with backing file\n");
         }
diff --git a/hw/nvram/spapr_nvram.c b/hw/nvram/spapr_nvram.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/nvram/spapr_nvram.c
+++ b/hw/nvram/spapr_nvram.c
@@ -XXX,XX +XXX,XX @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
 {
     SpaprNvram *nvram = spapr->nvram;
     hwaddr offset, buffer, len;
-    int alen;
+    int ret;
     void *membuf;
 
     if ((nargs != 3) || (nret != 2)) {
@@ -XXX,XX +XXX,XX @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
 
     membuf = cpu_physical_memory_map(buffer, &len, false);
 
-    alen = len;
+    ret = 0;
     if (nvram->blk) {
-        alen = blk_pwrite(nvram->blk, offset, membuf, len, 0);
+        ret = blk_pwrite(nvram->blk, offset, membuf, len, 0);
     }
 
     assert(nvram->buf);
@@ -XXX,XX +XXX,XX @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
 
     cpu_physical_memory_unmap(membuf, len, 0, len);
 
-    rtas_st(rets, 0, (alen < len) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
-    rtas_st(rets, 1, (alen < 0) ? 0 : alen);
+    rtas_st(rets, 0, (ret < 0) ? RTAS_OUT_HW_ERROR : RTAS_OUT_SUCCESS);
+    rtas_st(rets, 1, (ret < 0) ? 0 : len);
 }
 
 static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
     }
 
     if (nvram->blk) {
-        int alen = blk_pread(nvram->blk, 0, nvram->buf, nvram->size);
+        ret = blk_pread(nvram->blk, 0, nvram->buf, nvram->size);
 
-        if (alen != nvram->size) {
+        if (ret < 0) {
             error_setg(errp, "can't read spapr-nvram contents");
             return;
         }
diff --git a/hw/ppc/pnv_pnor.c b/hw/ppc/pnv_pnor.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ppc/pnv_pnor.c
+++ b/hw/ppc/pnv_pnor.c
@@ -XXX,XX +XXX,XX @@ static void pnv_pnor_realize(DeviceState *dev, Error **errp)
 
         s->storage = blk_blockalign(s->blk, s->size);
 
-        if (blk_pread(s->blk, 0, s->storage, s->size) != s->size) {
+        if (blk_pread(s->blk, 0, s->storage, s->size) < 0) {
             error_setg(errp, "failed to read the initial flash content");
             return;
         }
diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static int img_dd(int argc, char **argv)
     in.buf = g_new(uint8_t, in.bsz);
 
     for (out_pos = 0; in_pos < size; block_count++) {
-        int in_ret, out_ret;
+        int bytes = (in_pos + in.bsz > size) ? size - in_pos : in.bsz;
 
-        if (in_pos + in.bsz > size) {
-            in_ret = blk_pread(blk1, in_pos, in.buf, size - in_pos);
-        } else {
-            in_ret = blk_pread(blk1, in_pos, in.buf, in.bsz);
-        }
-        if (in_ret < 0) {
+        ret = blk_pread(blk1, in_pos, in.buf, bytes);
+        if (ret < 0) {
             error_report("error while reading from input image file: %s",
-                         strerror(-in_ret));
-            ret = -1;
+                         strerror(-ret));
             goto out;
         }
-        in_pos += in_ret;
+        in_pos += bytes;
 
-        out_ret = blk_pwrite(blk2, out_pos, in.buf, in_ret, 0);
-
-        if (out_ret < 0) {
+        ret = blk_pwrite(blk2, out_pos, in.buf, bytes, 0);
+        if (ret < 0) {
             error_report("error while writing to output image file: %s",
-                         strerror(-out_ret));
-            ret = -1;
+                         strerror(-ret));
             goto out;
         }
-        out_pos += out_ret;
+        out_pos += bytes;
     }
 
 out:
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ fail:
 static int do_pread(BlockBackend *blk, char *buf, int64_t offset,
                     int64_t bytes, int64_t *total)
 {
+    int ret;
+
     if (bytes > INT_MAX) {
         return -ERANGE;
     }
 
-    *total = blk_pread(blk, offset, (uint8_t *)buf, bytes);
-    if (*total < 0) {
-        return *total;
+    ret = blk_pread(blk, offset, (uint8_t *)buf, bytes);
+    if (ret < 0) {
+        return ret;
     }
+    *total = bytes;
     return 1;
 }
 
 static int do_pwrite(BlockBackend *blk, char *buf, int64_t offset,
                      int64_t bytes, int flags, int64_t *total)
 {
+    int ret;
+
     if (bytes > INT_MAX) {
         return -ERANGE;
     }
 
-    *total = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags);
-    if (*total < 0) {
-        return *total;
+    ret = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags);
+    if (ret < 0) {
+        return ret;
     }
+    *total = bytes;
     return 1;
 }
 
diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-block-iothread.c
+++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pread(BlockBackend *blk)
 
     /* Success */
     ret = blk_pread(blk, 0, buf, sizeof(buf));
-    g_assert_cmpint(ret, ==, 512);
+    g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
     ret = blk_pread(blk, -2, buf, sizeof(buf));
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwrite(BlockBackend *blk)
 
     /* Success */
     ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
-    g_assert_cmpint(ret, ==, 512);
+    g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
     ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

For consistency with other I/O functions, and in preparation to
implement it using generated_co_wrapper.

Callers were updated using this Coccinelle script:

@@ expression blk, offset, buf, bytes; @@
    - blk_pread(blk, offset, buf, bytes)
    + blk_pread(blk, offset, buf, bytes, 0)

It had no effect on hw/block/nand.c, presumably due to the #if, so that
file was updated manually.

Overly-long lines were then fixed by hand.

From: Alberto Faria <afaria@redhat.com>

Swap 'buf' and 'bytes' around for consistency with
blk_co_{pread,pwrite}(), and in preparation to implement these functions
using generated_co_wrapper.

Callers were updated using this Coccinelle script:

@@ expression blk, offset, buf, bytes, flags; @@
    - blk_pread(blk, offset, buf, bytes, flags)
    + blk_pread(blk, offset, bytes, buf, flags)

@@ expression blk, offset, buf, bytes, flags; @@
    - blk_pwrite(blk, offset, buf, bytes, flags)
    + blk_pwrite(blk, offset, bytes, buf, flags)

It had no effect on hw/block/nand.c, presumably due to the #if, so that
file was updated manually.

Overly-long lines were then fixed by hand.

diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
  * the "I/O or GS" API.
  */
 
-int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes,
+int blk_pread(BlockBackend *blk, int64_t offset, int bytes, void *buf,
               BdrvRequestFlags flags);
-int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes,
+int blk_pwrite(BlockBackend *blk, int64_t offset, int bytes, const void *buf,
                BdrvRequestFlags flags);
 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
                                int64_t bytes, QEMUIOVector *qiov,
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int find_image_format(BlockBackend *file, const char *filename,
         return ret;
     }
 
-    ret = blk_pread(file, 0, buf, sizeof(buf), 0);
+    ret = blk_pread(file, 0, sizeof(buf), buf, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read image for determining its "
                          "format");
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
                         flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
 }
 
-int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes,
+int blk_pread(BlockBackend *blk, int64_t offset, int bytes, void *buf,
               BdrvRequestFlags flags)
 {
     int ret;
@@ -XXX,XX +XXX,XX @@ int blk_pread(BlockBackend *blk, int64_t offset, void *buf, int bytes,
     return ret;
 }
 
-int blk_pwrite(BlockBackend *blk, int64_t offset, const void *buf, int bytes,
+int blk_pwrite(BlockBackend *blk, int64_t offset, int bytes, const void *buf,
                BdrvRequestFlags flags)
 {
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
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 @@ int bdrv_commit(BlockDriverState *bs)
             goto ro_cleanup;
         }
         if (ret) {
-            ret = blk_pread(src, offset, buf, n, 0);
+            ret = blk_pread(src, offset, n, buf, 0);
             if (ret < 0) {
                 goto ro_cleanup;
             }
 
-            ret = blk_pwrite(backing, offset, buf, n, 0);
+            ret = blk_pwrite(backing, offset, n, buf, 0);
             if (ret < 0) {
                 goto ro_cleanup;
             }
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_write_func(QCryptoBlock *block,
     struct BlockCryptoCreateData *data = opaque;
     ssize_t ret;
 
-    ret = blk_pwrite(data->blk, offset, buf, buflen, 0);
+    ret = blk_pwrite(data->blk, offset, buflen, buf, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not write encryption header");
         return ret;
diff --git a/block/export/fuse.c b/block/export/fuse.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/fuse.c
+++ b/block/export/fuse.c
@@ -XXX,XX +XXX,XX @@ static void fuse_read(fuse_req_t req, fuse_ino_t inode,
         return;
     }
 
-    ret = blk_pread(exp->common.blk, offset, buf, size, 0);
+    ret = blk_pread(exp->common.blk, offset, size, buf, 0);
     if (ret >= 0) {
         fuse_reply_buf(req, buf, size);
     } else {
@@ -XXX,XX +XXX,XX @@ static void fuse_write(fuse_req_t req, fuse_ino_t inode, const char *buf,
         }
     }
 
-    ret = blk_pwrite(exp->common.blk, offset, buf, size, 0);
+    ret = blk_pwrite(exp->common.blk, offset, size, buf, 0);
     if (ret >= 0) {
         fuse_reply_write(req, size);
     } else {
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,
     memset(tmp, 0, sizeof(tmp));
     memcpy(tmp, &header, sizeof(header));
 
-    ret = blk_pwrite(blk, 0, tmp, BDRV_SECTOR_SIZE, 0);
+    ret = blk_pwrite(blk, 0, BDRV_SECTOR_SIZE, tmp, 0);
     if (ret < 0) {
         goto exit;
     }
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
     }
 
     /* write all the data */
-    ret = blk_pwrite(qcow_blk, 0, &header, sizeof(header), 0);
+    ret = blk_pwrite(qcow_blk, 0, sizeof(header), &header, 0);
     if (ret < 0) {
         goto exit;
     }
 
     if (qcow_opts->has_backing_file) {
-        ret = blk_pwrite(qcow_blk, sizeof(header),
-                         qcow_opts->backing_file, backing_filename_len, 0);
+        ret = blk_pwrite(qcow_blk, sizeof(header), backing_filename_len,
+                         qcow_opts->backing_file, 0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
     for (i = 0; i < DIV_ROUND_UP(sizeof(uint64_t) * l1_size, BDRV_SECTOR_SIZE);
          i++) {
         ret = blk_pwrite(qcow_blk, header_size + BDRV_SECTOR_SIZE * i,
-                         tmp, BDRV_SECTOR_SIZE, 0);
+                         BDRV_SECTOR_SIZE, tmp, 0);
         if (ret < 0) {
             g_free(tmp);
             goto exit;
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
             cpu_to_be64(QCOW2_INCOMPAT_EXTL2);
     }
 
-    ret = blk_pwrite(blk, 0, header, cluster_size, 0);
+    ret = blk_pwrite(blk, 0, cluster_size, header, 0);
     g_free(header);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not write qcow2 header");
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
     /* Write a refcount table with one refcount block */
     refcount_table = g_malloc0(2 * cluster_size);
     refcount_table[0] = cpu_to_be64(2 * cluster_size);
-    ret = blk_pwrite(blk, cluster_size, refcount_table, 2 * cluster_size, 0);
+    ret = blk_pwrite(blk, cluster_size, 2 * cluster_size, refcount_table, 0);
     g_free(refcount_table);
 
     if (ret < 0) {
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
     }
 
     qed_header_cpu_to_le(&header, &le_header);
-    ret = blk_pwrite(blk, 0, &le_header, sizeof(le_header), 0);
+    ret = blk_pwrite(blk, 0, sizeof(le_header), &le_header, 0);
     if (ret < 0) {
         goto out;
     }
-    ret = blk_pwrite(blk, sizeof(le_header), qed_opts->backing_file,
-                     header.backing_filename_size, 0);
+    ret = blk_pwrite(blk, sizeof(le_header), header.backing_filename_size,
+                     qed_opts->backing_file, 0);
     if (ret < 0) {
         goto out;
     }
 
     l1_table = g_malloc0(l1_size);
-    ret = blk_pwrite(blk, header.l1_table_offset, l1_table, l1_size, 0);
+    ret = blk_pwrite(blk, header.l1_table_offset, l1_size, l1_table, 0);
     if (ret < 0) {
         goto out;
     }
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
         vdi_header_print(&header);
     }
     vdi_header_to_le(&header);
-    ret = blk_pwrite(blk, offset, &header, sizeof(header), 0);
+    ret = blk_pwrite(blk, offset, sizeof(header), &header, 0);
     if (ret < 0) {
         error_setg(errp, "Error writing header");
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
                 bmap[i] = VDI_UNALLOCATED;
             }
         }
-        ret = blk_pwrite(blk, offset, bmap, bmap_size, 0);
+        ret = blk_pwrite(blk, offset, bmap_size, bmap, 0);
         if (ret < 0) {
             error_setg(errp, "Error writing bmap");
             goto exit;
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_metadata(BlockBackend *blk,
                                    VHDX_META_FLAGS_IS_VIRTUAL_DISK;
     vhdx_metadata_entry_le_export(&md_table_entry[4]);
 
-    ret = blk_pwrite(blk, metadata_offset, buffer, VHDX_HEADER_BLOCK_SIZE, 0);
+    ret = blk_pwrite(blk, metadata_offset, VHDX_HEADER_BLOCK_SIZE, buffer, 0);
     if (ret < 0) {
         goto exit;
     }
 
-    ret = blk_pwrite(blk, metadata_offset + (64 * KiB), entry_buffer,
-                     VHDX_METADATA_ENTRY_BUFFER_SIZE, 0);
+    ret = blk_pwrite(blk, metadata_offset + (64 * KiB),
+                     VHDX_METADATA_ENTRY_BUFFER_SIZE, entry_buffer, 0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
             s->bat[sinfo.bat_idx] = cpu_to_le64(s->bat[sinfo.bat_idx]);
             sector_num += s->sectors_per_block;
         }
-        ret = blk_pwrite(blk, file_offset, s->bat, length, 0);
+        ret = blk_pwrite(blk, file_offset, length, s->bat, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to write the BAT");
             goto exit;
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_region_table(BlockBackend *blk,
     }
 
     /* Now write out the region headers to disk */
-    ret = blk_pwrite(blk, VHDX_REGION_TABLE_OFFSET, buffer,
-                     VHDX_HEADER_BLOCK_SIZE, 0);
+    ret = blk_pwrite(blk, VHDX_REGION_TABLE_OFFSET, VHDX_HEADER_BLOCK_SIZE,
+                     buffer, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to write first region table");
         goto exit;
     }
 
-    ret = blk_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, buffer,
-                     VHDX_HEADER_BLOCK_SIZE, 0);
+    ret = blk_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, VHDX_HEADER_BLOCK_SIZE,
+                     buffer, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to write second region table");
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
     creator = g_utf8_to_utf16("QEMU v" QEMU_VERSION, -1, NULL,
                               &creator_items, NULL);
     signature = cpu_to_le64(VHDX_FILE_SIGNATURE);
-    ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET, &signature, sizeof(signature),
+    ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET, sizeof(signature), &signature,
                      0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to write file signature");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,
     }
     if (creator) {
         ret = blk_pwrite(blk, VHDX_FILE_ID_OFFSET + sizeof(signature),
-                         creator, creator_items * sizeof(gunichar2), 0);
+                         creator_items * sizeof(gunichar2), creator, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to write creator field");
             goto delete_and_exit;
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
     header.check_bytes[3] = 0xa;
 
     /* write all the data */
-    ret = blk_pwrite(blk, 0, &magic, sizeof(magic), 0);
+    ret = blk_pwrite(blk, 0, sizeof(magic), &magic, 0);
     if (ret < 0) {
         error_setg(errp, QERR_IO_ERROR);
         goto exit;
     }
-    ret = blk_pwrite(blk, sizeof(magic), &header, sizeof(header), 0);
+    ret = blk_pwrite(blk, sizeof(magic), sizeof(header), &header, 0);
     if (ret < 0) {
         error_setg(errp, QERR_IO_ERROR);
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
         gd_buf[i] = cpu_to_le32(tmp);
     }
     ret = blk_pwrite(blk, le64_to_cpu(header.rgd_offset) * BDRV_SECTOR_SIZE,
-                     gd_buf, gd_buf_size, 0);
+                     gd_buf_size, gd_buf, 0);
     if (ret < 0) {
         error_setg(errp, QERR_IO_ERROR);
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
         gd_buf[i] = cpu_to_le32(tmp);
     }
     ret = blk_pwrite(blk, le64_to_cpu(header.gd_offset) * BDRV_SECTOR_SIZE,
-                     gd_buf, gd_buf_size, 0);
+                     gd_buf_size, gd_buf, 0);
     if (ret < 0) {
         error_setg(errp, QERR_IO_ERROR);
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size,
         desc_offset = 0x200;
     }
 
-    ret = blk_pwrite(blk, desc_offset, desc, desc_len, 0);
+    ret = blk_pwrite(blk, desc_offset, desc_len, desc, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not write description");
         goto exit;
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
     block_size = 0x200000;
     num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512);
 
-    ret = blk_pwrite(blk, offset, footer, sizeof(*footer), 0);
+    ret = blk_pwrite(blk, offset, sizeof(*footer), footer, 0);
     if (ret < 0) {
         goto fail;
     }
 
     offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
-    ret = blk_pwrite(blk, offset, footer, sizeof(*footer), 0);
+    ret = blk_pwrite(blk, offset, sizeof(*footer), footer, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
 
     memset(bat_sector, 0xFF, 512);
     for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
-        ret = blk_pwrite(blk, offset, bat_sector, 512, 0);
+        ret = blk_pwrite(blk, offset, 512, bat_sector, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
     /* Write the header */
     offset = 512;
 
-    ret = blk_pwrite(blk, offset, &dyndisk_header, sizeof(dyndisk_header), 0);
+    ret = blk_pwrite(blk, offset, sizeof(dyndisk_header), &dyndisk_header, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, VHDFooter *footer,
         return ret;
     }
 
-    ret = blk_pwrite(blk, total_size - sizeof(*footer),
-                     footer, sizeof(*footer), 0);
+    ret = blk_pwrite(blk, total_size - sizeof(*footer), sizeof(*footer),
+                     footer, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Unable to write VHD header");
         return ret;
diff --git a/hw/arm/allwinner-h3.c b/hw/arm/allwinner-h3.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/allwinner-h3.c
+++ b/hw/arm/allwinner-h3.c
@@ -XXX,XX +XXX,XX @@ void allwinner_h3_bootrom_setup(AwH3State *s, BlockBackend *blk)
     const int64_t rom_size = 32 * KiB;
     g_autofree uint8_t *buffer = g_new0(uint8_t, rom_size);
 
-    if (blk_pread(blk, 8 * KiB, buffer, rom_size, 0) < 0) {
+    if (blk_pread(blk, 8 * KiB, rom_size, buffer, 0) < 0) {
         error_setg(&error_fatal, "%s: failed to read BlockBackend data",
                    __func__);
         return;
diff --git a/hw/arm/aspeed.c b/hw/arm/aspeed.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/arm/aspeed.c
+++ b/hw/arm/aspeed.c
@@ -XXX,XX +XXX,XX @@ static void write_boot_rom(DriveInfo *dinfo, hwaddr addr, size_t rom_size,
     }
 
     storage = g_malloc0(rom_size);
-    if (blk_pread(blk, 0, storage, rom_size, 0) < 0) {
+    if (blk_pread(blk, 0, rom_size, storage, 0) < 0) {
         error_setg(errp, "failed to read the initial flash content");
         return;
     }
diff --git a/hw/block/block.c b/hw/block/block.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/block.c
+++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blk_check_size_and_read_all(BlockBackend *blk, void *buf, hwaddr size,
      * block device and read only on demand.
      */
     assert(size <= BDRV_REQUEST_MAX_BYTES);
-    ret = blk_pread(blk, 0, buf, size, 0);
+    ret = blk_pread(blk, 0, size, buf, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "can't read block backend");
         return false;
diff --git a/hw/block/fdc.c b/hw/block/fdc.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/fdc.c
+++ b/hw/block/fdc.c
@@ -XXX,XX +XXX,XX @@ int fdctrl_transfer_handler(void *opaque, int nchan, int dma_pos, int dma_len)
         if (fdctrl->data_dir != FD_DIR_WRITE ||
             len < FD_SECTOR_LEN || rel_pos != 0) {
             /* READ & SCAN commands and realign to a sector for WRITE */
-            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
-                          BDRV_SECTOR_SIZE, 0) < 0) {
+            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
+                          fdctrl->fifo, 0) < 0) {
                 FLOPPY_DPRINTF("Floppy: error getting sector %d\n",
                                fd_sector(cur_drv));
                 /* Sure, image size is too small... */
@@ -XXX,XX +XXX,XX @@ int fdctrl_transfer_handler(void *opaque, int nchan, int dma_pos, int dma_len)
 
             k->read_memory(fdctrl->dma, nchan, fdctrl->fifo + rel_pos,
                            fdctrl->data_pos, len);
-            if (blk_pwrite(cur_drv->blk, fd_offset(cur_drv),
-                           fdctrl->fifo, BDRV_SECTOR_SIZE, 0) < 0) {
+            if (blk_pwrite(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
+                           fdctrl->fifo, 0) < 0) {
                 FLOPPY_DPRINTF("error writing sector %d\n",
                                fd_sector(cur_drv));
                 fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00);
@@ -XXX,XX +XXX,XX @@ static uint32_t fdctrl_read_data(FDCtrl *fdctrl)
                                    fd_sector(cur_drv));
                     return 0;
                 }
-            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
-                          BDRV_SECTOR_SIZE, 0)
+            if (blk_pread(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
+                          fdctrl->fifo, 0)
                 < 0) {
                 FLOPPY_DPRINTF("error getting sector %d\n",
                                fd_sector(cur_drv));
@@ -XXX,XX +XXX,XX @@ static void fdctrl_format_sector(FDCtrl *fdctrl)
     }
     memset(fdctrl->fifo, 0, FD_SECTOR_LEN);
     if (cur_drv->blk == NULL ||
-        blk_pwrite(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
-                   BDRV_SECTOR_SIZE, 0) < 0) {
+        blk_pwrite(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
+                   fdctrl->fifo, 0) < 0) {
         FLOPPY_DPRINTF("error formatting sector %d\n", fd_sector(cur_drv));
         fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM | FD_SR0_SEEK, 0x00, 0x00);
     } else {
@@ -XXX,XX +XXX,XX @@ static void fdctrl_write_data(FDCtrl *fdctrl, uint32_t value)
         if (pos == FD_SECTOR_LEN - 1 ||
             fdctrl->data_pos == fdctrl->data_len) {
             cur_drv = get_cur_drv(fdctrl);
-            if (blk_pwrite(cur_drv->blk, fd_offset(cur_drv), fdctrl->fifo,
-                           BDRV_SECTOR_SIZE, 0) < 0) {
+            if (blk_pwrite(cur_drv->blk, fd_offset(cur_drv), BDRV_SECTOR_SIZE,
+                           fdctrl->fifo, 0) < 0) {
                 FLOPPY_DPRINTF("error writing sector %d\n",
                                fd_sector(cur_drv));
                 break;
diff --git a/hw/block/hd-geometry.c b/hw/block/hd-geometry.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/hd-geometry.c
+++ b/hw/block/hd-geometry.c
@@ -XXX,XX +XXX,XX @@ static int guess_disk_lchs(BlockBackend *blk,
 
     blk_get_geometry(blk, &nb_sectors);
 
-    if (blk_pread(blk, 0, buf, BDRV_SECTOR_SIZE, 0) < 0) {
+    if (blk_pread(blk, 0, BDRV_SECTOR_SIZE, buf, 0) < 0) {
         return -1;
     }
     /* test msdos magic */
diff --git a/hw/block/m25p80.c b/hw/block/m25p80.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/m25p80.c
+++ b/hw/block/m25p80.c
@@ -XXX,XX +XXX,XX @@ static void m25p80_realize(SSIPeripheral *ss, Error **errp)
         trace_m25p80_binding(s);
         s->storage = blk_blockalign(s->blk, s->size);
 
-        if (blk_pread(s->blk, 0, s->storage, s->size, 0) < 0) {
+        if (blk_pread(s->blk, 0, s->size, s->storage, 0) < 0) {
             error_setg(errp, "failed to read the initial flash content");
             return;
         }
diff --git a/hw/block/nand.c b/hw/block/nand.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nand.c
+++ b/hw/block/nand.c
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_write_, NAND_PAGE_SIZE)(NANDFlashState *s)
         sector = SECTOR(s->addr);
         off = (s->addr & PAGE_MASK) + s->offset;
         soff = SECTOR_OFFSET(s->addr);
-        if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
-                      PAGE_SECTORS << BDRV_SECTOR_BITS, 0) < 0) {
+        if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS,
+                      PAGE_SECTORS << BDRV_SECTOR_BITS, iobuf, 0) < 0) {
             printf("%s: read error in sector %" PRIu64 "\n", __func__, sector);
             return;
         }
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_write_, NAND_PAGE_SIZE)(NANDFlashState *s)
                             MIN(OOB_SIZE, off + s->iolen - NAND_PAGE_SIZE));
         }
 
-        if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
-                       PAGE_SECTORS << BDRV_SECTOR_BITS, 0) < 0) {
+        if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS,
+                       PAGE_SECTORS << BDRV_SECTOR_BITS, iobuf, 0) < 0) {
             printf("%s: write error in sector %" PRIu64 "\n", __func__, sector);
         }
     } else {
         off = PAGE_START(s->addr) + (s->addr & PAGE_MASK) + s->offset;
         sector = off >> 9;
         soff = off & 0x1ff;
-        if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
-                      (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, 0) < 0) {
+        if (blk_pread(s->blk, sector << BDRV_SECTOR_BITS,
+                      (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, iobuf, 0) < 0) {
             printf("%s: read error in sector %" PRIu64 "\n", __func__, sector);
             return;
         }
 
         mem_and(iobuf + soff, s->io, s->iolen);
 
-        if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS, iobuf,
-                       (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, 0) < 0) {
+        if (blk_pwrite(s->blk, sector << BDRV_SECTOR_BITS,
+                       (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, iobuf, 0) < 0) {
             printf("%s: write error in sector %" PRIu64 "\n", __func__, sector);
         }
     }
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_erase_, NAND_PAGE_SIZE)(NANDFlashState *s)
         i = SECTOR(addr);
         page = SECTOR(addr + (1 << (ADDR_SHIFT + s->erase_shift)));
         for (; i < page; i ++)
-            if (blk_pwrite(s->blk, i << BDRV_SECTOR_BITS, iobuf,
-                           BDRV_SECTOR_SIZE, 0) < 0) {
+            if (blk_pwrite(s->blk, i << BDRV_SECTOR_BITS,
+                           BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
                 printf("%s: write error in sector %" PRIu64 "\n", __func__, i);
             }
     } else {
         addr = PAGE_START(addr);
         page = addr >> 9;
-        if (blk_pread(s->blk, page << BDRV_SECTOR_BITS, iobuf,
-                      BDRV_SECTOR_SIZE, 0) < 0) {
+        if (blk_pread(s->blk, page << BDRV_SECTOR_BITS,
+                      BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
             printf("%s: read error in sector %" PRIu64 "\n", __func__, page);
         }
         memset(iobuf + (addr & 0x1ff), 0xff, (~addr & 0x1ff) + 1);
-        if (blk_pwrite(s->blk, page << BDRV_SECTOR_BITS, iobuf,
-                       BDRV_SECTOR_SIZE, 0) < 0) {
+        if (blk_pwrite(s->blk, page << BDRV_SECTOR_BITS,
+                       BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
             printf("%s: write error in sector %" PRIu64 "\n", __func__, page);
         }
 
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_erase_, NAND_PAGE_SIZE)(NANDFlashState *s)
         i = (addr & ~0x1ff) + 0x200;
         for (addr += ((NAND_PAGE_SIZE + OOB_SIZE) << s->erase_shift) - 0x200;
                         i < addr; i += 0x200) {
-            if (blk_pwrite(s->blk, i, iobuf, BDRV_SECTOR_SIZE, 0) < 0) {
+            if (blk_pwrite(s->blk, i, BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
                 printf("%s: write error in sector %" PRIu64 "\n",
                        __func__, i >> 9);
             }
         }
 
         page = i >> 9;
-        if (blk_pread(s->blk, page << BDRV_SECTOR_BITS, iobuf,
-                      BDRV_SECTOR_SIZE, 0) < 0) {
+        if (blk_pread(s->blk, page << BDRV_SECTOR_BITS,
+                      BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
             printf("%s: read error in sector %" PRIu64 "\n", __func__, page);
         }
         memset(iobuf, 0xff, ((addr - 1) & 0x1ff) + 1);
-        if (blk_pwrite(s->blk, page << BDRV_SECTOR_BITS, iobuf,
-                       BDRV_SECTOR_SIZE, 0) < 0) {
+        if (blk_pwrite(s->blk, page << BDRV_SECTOR_BITS,
+                       BDRV_SECTOR_SIZE, iobuf, 0) < 0) {
             printf("%s: write error in sector %" PRIu64 "\n", __func__, page);
         }
     }
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_load_, NAND_PAGE_SIZE)(NANDFlashState *s,
 
     if (s->blk) {
         if (s->mem_oob) {
-            if (blk_pread(s->blk, SECTOR(addr) << BDRV_SECTOR_BITS, s->io,
-                          PAGE_SECTORS << BDRV_SECTOR_BITS, 0) < 0) {
+            if (blk_pread(s->blk, SECTOR(addr) << BDRV_SECTOR_BITS,
+                          PAGE_SECTORS << BDRV_SECTOR_BITS, s->io, 0) < 0) {
                 printf("%s: read error in sector %" PRIu64 "\n",
                                 __func__, SECTOR(addr));
             }
@@ -XXX,XX +XXX,XX @@ static void glue(nand_blk_load_, NAND_PAGE_SIZE)(NANDFlashState *s,
                             OOB_SIZE);
             s->ioaddr = s->io + SECTOR_OFFSET(s->addr) + offset;
         } else {
-            if (blk_pread(s->blk, PAGE_START(addr), s->io,
-                          (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, 0) < 0) {
+            if (blk_pread(s->blk, PAGE_START(addr),
+                          (PAGE_SECTORS + 2) << BDRV_SECTOR_BITS, s->io, 0)
+                < 0) {
                 printf("%s: read error in sector %" PRIu64 "\n",
                                 __func__, PAGE_START(addr) >> 9);
             }
diff --git a/hw/block/onenand.c b/hw/block/onenand.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/onenand.c
+++ b/hw/block/onenand.c
@@ -XXX,XX +XXX,XX @@ static void onenand_reset(OneNANDState *s, int cold)
         /* Lock the whole flash */
         memset(s->blockwp, ONEN_LOCK_LOCKED, s->blocks);
 
-        if (s->blk_cur && blk_pread(s->blk_cur, 0, s->boot[0],
-                                    8 << BDRV_SECTOR_BITS, 0) < 0) {
+        if (s->blk_cur && blk_pread(s->blk_cur, 0, 8 << BDRV_SECTOR_BITS,
+                                    s->boot[0], 0) < 0) {
             hw_error("%s: Loading the BootRAM failed.\n", __func__);
         }
     }
@@ -XXX,XX +XXX,XX @@ static inline int onenand_load_main(OneNANDState *s, int sec, int secn,
     assert(UINT32_MAX >> BDRV_SECTOR_BITS > sec);
     assert(UINT32_MAX >> BDRV_SECTOR_BITS > secn);
     if (s->blk_cur) {
-        return blk_pread(s->blk_cur, sec << BDRV_SECTOR_BITS, dest,
-                         secn << BDRV_SECTOR_BITS, 0) < 0;
+        return blk_pread(s->blk_cur, sec << BDRV_SECTOR_BITS,
+                         secn << BDRV_SECTOR_BITS, dest, 0) < 0;
     } else if (sec + secn > s->secs_cur) {
         return 1;
     }
@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn,
         uint8_t *dp = 0;
         if (s->blk_cur) {
             dp = g_malloc(size);
-            if (!dp || blk_pread(s->blk_cur, offset, dp, size, 0) < 0) {
+            if (!dp || blk_pread(s->blk_cur, offset, size, dp, 0) < 0) {
                 result = 1;
             }
         } else {
@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_main(OneNANDState *s, int sec, int secn,
                 dp[i] &= sp[i];
             }
             if (s->blk_cur) {
-                result = blk_pwrite(s->blk_cur, offset, dp, size, 0) < 0;
+                result = blk_pwrite(s->blk_cur, offset, size, dp, 0) < 0;
             }
         }
         if (dp && s->blk_cur) {
@@ -XXX,XX +XXX,XX @@ static inline int onenand_load_spare(OneNANDState *s, int sec, int secn,
 
     if (s->blk_cur) {
         uint32_t offset = (s->secs_cur + (sec >> 5)) << BDRV_SECTOR_BITS;
-        if (blk_pread(s->blk_cur, offset, buf, BDRV_SECTOR_SIZE, 0) < 0) {
+        if (blk_pread(s->blk_cur, offset, BDRV_SECTOR_SIZE, buf, 0) < 0) {
             return 1;
         }
         memcpy(dest, buf + ((sec & 31) << 4), secn << 4);
@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn,
         if (s->blk_cur) {
             dp = g_malloc(512);
             if (!dp
-                || blk_pread(s->blk_cur, offset, dp, BDRV_SECTOR_SIZE, 0) < 0) {
+                || blk_pread(s->blk_cur, offset, BDRV_SECTOR_SIZE, dp, 0) < 0) {
                 result = 1;
             } else {
                 dpp = dp + ((sec & 31) << 4);
@@ -XXX,XX +XXX,XX @@ static inline int onenand_prog_spare(OneNANDState *s, int sec, int secn,
                 dpp[i] &= sp[i];
             }
             if (s->blk_cur) {
-                result = blk_pwrite(s->blk_cur, offset, dp,
-                                    BDRV_SECTOR_SIZE, 0) < 0;
+                result = blk_pwrite(s->blk_cur, offset, BDRV_SECTOR_SIZE, dp,
+                                    0) < 0;
             }
         }
         g_free(dp);
@@ -XXX,XX +XXX,XX @@ static inline int onenand_erase(OneNANDState *s, int sec, int num)
     for (; num > 0; num--, sec++) {
         if (s->blk_cur) {
             int erasesec = s->secs_cur + (sec >> 5);
-            if (blk_pwrite(s->blk_cur, sec << BDRV_SECTOR_BITS, blankbuf,
-                           BDRV_SECTOR_SIZE, 0) < 0) {
+            if (blk_pwrite(s->blk_cur, sec << BDRV_SECTOR_BITS,
+                           BDRV_SECTOR_SIZE, blankbuf, 0) < 0) {
                 goto fail;
             }
-            if (blk_pread(s->blk_cur, erasesec << BDRV_SECTOR_BITS, tmpbuf,
-                          BDRV_SECTOR_SIZE, 0) < 0) {
+            if (blk_pread(s->blk_cur, erasesec << BDRV_SECTOR_BITS,
+                          BDRV_SECTOR_SIZE, tmpbuf, 0) < 0) {
                 goto fail;
             }
             memcpy(tmpbuf + ((sec & 31) << 4), blankbuf, 1 << 4);
-            if (blk_pwrite(s->blk_cur, erasesec << BDRV_SECTOR_BITS, tmpbuf,
-                           BDRV_SECTOR_SIZE, 0) < 0) {
+            if (blk_pwrite(s->blk_cur, erasesec << BDRV_SECTOR_BITS,
+                           BDRV_SECTOR_SIZE, tmpbuf, 0) < 0) {
                 goto fail;
             }
         } else {
diff --git a/hw/block/pflash_cfi01.c b/hw/block/pflash_cfi01.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/pflash_cfi01.c
+++ b/hw/block/pflash_cfi01.c
@@ -XXX,XX +XXX,XX @@ static void pflash_update(PFlashCFI01 *pfl, int offset,
         /* widen to sector boundaries */
         offset = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);
         offset_end = QEMU_ALIGN_UP(offset_end, BDRV_SECTOR_SIZE);
-        ret = blk_pwrite(pfl->blk, offset, pfl->storage + offset,
-                   offset_end - offset, 0);
+        ret = blk_pwrite(pfl->blk, offset, offset_end - offset,
+                         pfl->storage + offset, 0);
         if (ret < 0) {
             /* TODO set error bit in status */
             error_report("Could not update PFLASH: %s", strerror(-ret));
diff --git a/hw/block/pflash_cfi02.c b/hw/block/pflash_cfi02.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/pflash_cfi02.c
+++ b/hw/block/pflash_cfi02.c
@@ -XXX,XX +XXX,XX @@ static void pflash_update(PFlashCFI02 *pfl, int offset, int size)
         /* widen to sector boundaries */
         offset = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);
         offset_end = QEMU_ALIGN_UP(offset_end, BDRV_SECTOR_SIZE);
-        ret = blk_pwrite(pfl->blk, offset, pfl->storage + offset,
-                   offset_end - offset, 0);
+        ret = blk_pwrite(pfl->blk, offset, offset_end - offset,
+                         pfl->storage + offset, 0);
         if (ret < 0) {
             /* TODO set error bit in status */
             error_report("Could not update PFLASH: %s", strerror(-ret));
diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ide/atapi.c
+++ b/hw/ide/atapi.c
@@ -XXX,XX +XXX,XX @@ cd_read_sector_sync(IDEState *s)
     switch (s->cd_sector_size) {
     case 2048:
         ret = blk_pread(s->blk, (int64_t)s->lba << ATAPI_SECTOR_BITS,
-                        s->io_buffer, ATAPI_SECTOR_SIZE, 0);
+                        ATAPI_SECTOR_SIZE, s->io_buffer, 0);
         break;
     case 2352:
         ret = blk_pread(s->blk, (int64_t)s->lba << ATAPI_SECTOR_BITS,
-                        s->io_buffer + 16, ATAPI_SECTOR_SIZE, 0);
+                        ATAPI_SECTOR_SIZE, s->io_buffer + 16, 0);
         if (ret >= 0) {
             cd_data_to_raw(s->io_buffer, s->lba);
         }
diff --git a/hw/misc/mac_via.c b/hw/misc/mac_via.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/misc/mac_via.c
+++ b/hw/misc/mac_via.c
@@ -XXX,XX +XXX,XX @@ static void via1_one_second(void *opaque)
 static void pram_update(MOS6522Q800VIA1State *v1s)
 {
     if (v1s->blk) {
-        if (blk_pwrite(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM), 0) < 0) {
+        if (blk_pwrite(v1s->blk, 0, sizeof(v1s->PRAM), v1s->PRAM, 0) < 0) {
             qemu_log("pram_update: cannot write to file\n");
         }
     }
@@ -XXX,XX +XXX,XX @@ static void mos6522_q800_via1_realize(DeviceState *dev, Error **errp)
             return;
         }
 
-        ret = blk_pread(v1s->blk, 0, v1s->PRAM, sizeof(v1s->PRAM), 0);
+        ret = blk_pread(v1s->blk, 0, sizeof(v1s->PRAM), v1s->PRAM, 0);
         if (ret < 0) {
             error_setg(errp, "can't read PRAM contents");
             return;
diff --git a/hw/misc/sifive_u_otp.c b/hw/misc/sifive_u_otp.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/misc/sifive_u_otp.c
+++ b/hw/misc/sifive_u_otp.c
@@ -XXX,XX +XXX,XX @@ static uint64_t sifive_u_otp_read(void *opaque, hwaddr addr, unsigned int size)
             if (s->blk) {
                 int32_t buf;
 
-                if (blk_pread(s->blk, s->pa * SIFIVE_U_OTP_FUSE_WORD, &buf,
-                              SIFIVE_U_OTP_FUSE_WORD, 0) < 0) {
+                if (blk_pread(s->blk, s->pa * SIFIVE_U_OTP_FUSE_WORD,
+                              SIFIVE_U_OTP_FUSE_WORD, &buf, 0) < 0) {
                     error_report("read error index<%d>", s->pa);
                     return 0xff;
                 }
@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_write(void *opaque, hwaddr addr,
             /* write to backend */
             if (s->blk) {
                 if (blk_pwrite(s->blk, s->pa * SIFIVE_U_OTP_FUSE_WORD,
-                               &s->fuse[s->pa], SIFIVE_U_OTP_FUSE_WORD,
-                               0) < 0) {
+                               SIFIVE_U_OTP_FUSE_WORD, &s->fuse[s->pa], 0)
+                    < 0) {
                     error_report("write error index<%d>", s->pa);
                 }
             }
@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)
                 return;
             }
 
-            if (blk_pread(s->blk, 0, s->fuse, filesize, 0) < 0) {
+            if (blk_pread(s->blk, 0, filesize, s->fuse, 0) < 0) {
                 error_setg(errp, "failed to read the initial flash content");
                 return;
             }
@@ -XXX,XX +XXX,XX @@ static void sifive_u_otp_realize(DeviceState *dev, Error **errp)
 
         serial_data = s->serial;
         if (blk_pwrite(s->blk, index * SIFIVE_U_OTP_FUSE_WORD,
-                       &serial_data, SIFIVE_U_OTP_FUSE_WORD, 0) < 0) {
+                       SIFIVE_U_OTP_FUSE_WORD, &serial_data, 0) < 0) {
             error_setg(errp, "failed to write index<%d>", index);
             return;
         }
 
         serial_data = ~(s->serial);
         if (blk_pwrite(s->blk, (index + 1) * SIFIVE_U_OTP_FUSE_WORD,
-                       &serial_data, SIFIVE_U_OTP_FUSE_WORD, 0) < 0) {
+                       SIFIVE_U_OTP_FUSE_WORD, &serial_data, 0) < 0) {
             error_setg(errp, "failed to write index<%d>", index + 1);
             return;
         }
diff --git a/hw/nvram/eeprom_at24c.c b/hw/nvram/eeprom_at24c.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/nvram/eeprom_at24c.c
+++ b/hw/nvram/eeprom_at24c.c
@@ -XXX,XX +XXX,XX @@ int at24c_eeprom_event(I2CSlave *s, enum i2c_event event)
     case I2C_START_RECV:
         DPRINTK("clear\n");
         if (ee->blk && ee->changed) {
-            int ret = blk_pwrite(ee->blk, 0, ee->mem, ee->rsize, 0);
+            int ret = blk_pwrite(ee->blk, 0, ee->rsize, ee->mem, 0);
             if (ret < 0) {
                 ERR(TYPE_AT24C_EE
                         " : failed to write backing file\n");
@@ -XXX,XX +XXX,XX @@ void at24c_eeprom_reset(DeviceState *state)
     memset(ee->mem, 0, ee->rsize);
 
     if (ee->blk) {
-        int ret = blk_pread(ee->blk, 0, ee->mem, ee->rsize, 0);
+        int ret = blk_pread(ee->blk, 0, ee->rsize, ee->mem, 0);
 
         if (ret < 0) {
             ERR(TYPE_AT24C_EE
diff --git a/hw/nvram/spapr_nvram.c b/hw/nvram/spapr_nvram.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/nvram/spapr_nvram.c
+++ b/hw/nvram/spapr_nvram.c
@@ -XXX,XX +XXX,XX @@ static void rtas_nvram_store(PowerPCCPU *cpu, SpaprMachineState *spapr,
 
     ret = 0;
     if (nvram->blk) {
-        ret = blk_pwrite(nvram->blk, offset, membuf, len, 0);
+        ret = blk_pwrite(nvram->blk, offset, len, membuf, 0);
     }
 
     assert(nvram->buf);
@@ -XXX,XX +XXX,XX @@ static void spapr_nvram_realize(SpaprVioDevice *dev, Error **errp)
     }
 
     if (nvram->blk) {
-        ret = blk_pread(nvram->blk, 0, nvram->buf, nvram->size, 0);
+        ret = blk_pread(nvram->blk, 0, nvram->size, nvram->buf, 0);
 
         if (ret < 0) {
             error_setg(errp, "can't read spapr-nvram contents");
@@ -XXX,XX +XXX,XX @@ static void postload_update_cb(void *opaque, bool running, RunState state)
     qemu_del_vm_change_state_handler(nvram->vmstate);
     nvram->vmstate = NULL;
 
-    blk_pwrite(nvram->blk, 0, nvram->buf, nvram->size, 0);
+    blk_pwrite(nvram->blk, 0, nvram->size, nvram->buf, 0);
 }
 
 static int spapr_nvram_post_load(void *opaque, int version_id)
diff --git a/hw/nvram/xlnx-bbram.c b/hw/nvram/xlnx-bbram.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/nvram/xlnx-bbram.c
+++ b/hw/nvram/xlnx-bbram.c
@@ -XXX,XX +XXX,XX @@ static void bbram_bdrv_read(XlnxBBRam *s, Error **errp)
                     blk_name(s->blk));
     }
 
-    if (blk_pread(s->blk, 0, ram, nr, 0) < 0) {
+    if (blk_pread(s->blk, 0, nr, ram, 0) < 0) {
         error_setg(errp,
                    "%s: Failed to read %u bytes from BBRAM backstore.",
                    blk_name(s->blk), nr);
@@ -XXX,XX +XXX,XX @@ static void bbram_bdrv_sync(XlnxBBRam *s, uint64_t hwaddr)
     }
 
     offset = hwaddr - A_BBRAM_0;
-    rc = blk_pwrite(s->blk, offset, &le32, 4, 0);
+    rc = blk_pwrite(s->blk, offset, 4, &le32, 0);
     if (rc < 0) {
         bbram_bdrv_error(s, rc, g_strdup_printf("write to offset %u", offset));
     }
diff --git a/hw/nvram/xlnx-efuse.c b/hw/nvram/xlnx-efuse.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/nvram/xlnx-efuse.c
+++ b/hw/nvram/xlnx-efuse.c
@@ -XXX,XX +XXX,XX @@ static int efuse_bdrv_read(XlnxEFuse *s, Error **errp)
                     blk_name(s->blk));
     }
 
-    if (blk_pread(s->blk, 0, ram, nr, 0) < 0) {
+    if (blk_pread(s->blk, 0, nr, ram, 0) < 0) {
         error_setg(errp, "%s: Failed to read %u bytes from eFUSE backstore.",
                    blk_name(s->blk), nr);
         return -1;
@@ -XXX,XX +XXX,XX @@ static void efuse_bdrv_sync(XlnxEFuse *s, unsigned int bit)
     le32 = cpu_to_le32(xlnx_efuse_get_row(s, bit));
 
     row_offset = (bit / 32) * 4;
-    if (blk_pwrite(s->blk, row_offset, &le32, 4, 0) < 0) {
+    if (blk_pwrite(s->blk, row_offset, 4, &le32, 0) < 0) {
         error_report("%s: Failed to write offset %u of eFUSE backstore.",
                      blk_name(s->blk), row_offset);
     }
diff --git a/hw/ppc/pnv_pnor.c b/hw/ppc/pnv_pnor.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ppc/pnv_pnor.c
+++ b/hw/ppc/pnv_pnor.c
@@ -XXX,XX +XXX,XX @@ static void pnv_pnor_update(PnvPnor *s, int offset, int size)
     offset = QEMU_ALIGN_DOWN(offset, BDRV_SECTOR_SIZE);
     offset_end = QEMU_ALIGN_UP(offset_end, BDRV_SECTOR_SIZE);
 
-    ret = blk_pwrite(s->blk, offset, s->storage + offset,
-                     offset_end - offset, 0);
+    ret = blk_pwrite(s->blk, offset, offset_end - offset, s->storage + offset,
+                     0);
     if (ret < 0) {
         error_report("Could not update PNOR offset=0x%" PRIx32" : %s", offset,
                      strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static void pnv_pnor_realize(DeviceState *dev, Error **errp)
 
         s->storage = blk_blockalign(s->blk, s->size);
 
-        if (blk_pread(s->blk, 0, s->storage, s->size, 0) < 0) {
+        if (blk_pread(s->blk, 0, s->size, s->storage, 0) < 0) {
             error_setg(errp, "failed to read the initial flash content");
             return;
         }
diff --git a/hw/sd/sd.c b/hw/sd/sd.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/sd/sd.c
+++ b/hw/sd/sd.c
@@ -XXX,XX +XXX,XX @@ void sd_set_cb(SDState *sd, qemu_irq readonly, qemu_irq insert)
 static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len)
 {
     trace_sdcard_read_block(addr, len);
-    if (!sd->blk || blk_pread(sd->blk, addr, sd->data, len, 0) < 0) {
+    if (!sd->blk || blk_pread(sd->blk, addr, len, sd->data, 0) < 0) {
         fprintf(stderr, "sd_blk_read: read error on host side\n");
     }
 }
@@ -XXX,XX +XXX,XX @@ static void sd_blk_read(SDState *sd, uint64_t addr, uint32_t len)
 static void sd_blk_write(SDState *sd, uint64_t addr, uint32_t len)
 {
     trace_sdcard_write_block(addr, len);
-    if (!sd->blk || blk_pwrite(sd->blk, addr, sd->data, len, 0) < 0) {
+    if (!sd->blk || blk_pwrite(sd->blk, addr, len, sd->data, 0) < 0) {
         fprintf(stderr, "sd_blk_write: write error on host side\n");
     }
 }
diff --git a/migration/block.c b/migration/block.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/block.c
+++ b/migration/block.c
@@ -XXX,XX +XXX,XX @@ static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds,
                 blk_mig_unlock();
             } else {
                 ret = blk_pread(bmds->blk, sector * BDRV_SECTOR_SIZE,
-                                blk->buf, nr_sectors * BDRV_SECTOR_SIZE, 0);
+                                nr_sectors * BDRV_SECTOR_SIZE, blk->buf, 0);
                 if (ret < 0) {
                     goto error;
                 }
@@ -XXX,XX +XXX,XX @@ static int block_load(QEMUFile *f, void *opaque, int version_id)
                                                 cluster_size,
                                                 BDRV_REQ_MAY_UNMAP);
                     } else {
-                        ret = blk_pwrite(blk, cur_addr, cur_buf,
-                                         cluster_size, 0);
+                        ret = blk_pwrite(blk, cur_addr, cluster_size, cur_buf,
+                                         0);
                     }
                     if (ret < 0) {
                         break;
diff --git a/nbd/server.c b/nbd/server.c
index XXXXXXX..XXXXXXX 100644
--- a/nbd/server.c
+++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn nbd_co_send_sparse_read(NBDClient *client,
             stl_be_p(&chunk.length, pnum);
             ret = nbd_co_send_iov(client, iov, 1, errp);
         } else {
-            ret = blk_pread(exp->common.blk, offset + progress,
-                            data + progress, pnum, 0);
+            ret = blk_pread(exp->common.blk, offset + progress, pnum,
+                            data + progress, 0);
             if (ret < 0) {
                 error_setg_errno(errp, -ret, "reading from file failed");
                 break;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_do_cmd_read(NBDClient *client, NBDRequest *request,
                                        data, request->len, errp);
     }
 
-    ret = blk_pread(exp->common.blk, request->from, data, request->len, 0);
+    ret = blk_pread(exp->common.blk, request->from, request->len, data, 0);
     if (ret < 0) {
         return nbd_send_generic_reply(client, request->handle, ret,
                                       "reading from file failed", errp);
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_handle_request(NBDClient *client,
         if (request->flags & NBD_CMD_FLAG_FUA) {
             flags |= BDRV_REQ_FUA;
         }
-        ret = blk_pwrite(exp->common.blk, request->from, data, request->len,
+        ret = blk_pwrite(exp->common.blk, request->from, request->len, data,
                          flags);
         return nbd_send_generic_reply(client, request->handle, ret,
                                       "writing to file failed", errp);
diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static int check_empty_sectors(BlockBackend *blk, int64_t offset,
     int ret = 0;
     int64_t idx;
 
-    ret = blk_pread(blk, offset, buffer, bytes, 0);
+    ret = blk_pread(blk, offset, bytes, buffer, 0);
     if (ret < 0) {
         error_report("Error while reading offset %" PRId64 " of %s: %s",
                      offset, filename, strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int img_compare(int argc, char **argv)
                 int64_t pnum;
 
                 chunk = MIN(chunk, IO_BUF_SIZE);
-                ret = blk_pread(blk1, offset, buf1, chunk, 0);
+                ret = blk_pread(blk1, offset, chunk, buf1, 0);
                 if (ret < 0) {
                     error_report("Error while reading offset %" PRId64
                                  " of %s: %s",
@@ -XXX,XX +XXX,XX @@ static int img_compare(int argc, char **argv)
                     ret = 4;
                     goto out;
                 }
-                ret = blk_pread(blk2, offset, buf2, chunk, 0);
+                ret = blk_pread(blk2, offset, chunk, buf2, 0);
                 if (ret < 0) {
                     error_report("Error while reading offset %" PRId64
                                  " of %s: %s",
@@ -XXX,XX +XXX,XX @@ static int img_rebase(int argc, char **argv)
                     n = old_backing_size - offset;
                 }
 
-                ret = blk_pread(blk_old_backing, offset, buf_old, n, 0);
+                ret = blk_pread(blk_old_backing, offset, n, buf_old, 0);
                 if (ret < 0) {
                     error_report("error while reading from old backing file");
                     goto out;
@@ -XXX,XX +XXX,XX @@ static int img_rebase(int argc, char **argv)
                     n = new_backing_size - offset;
                 }
 
-                ret = blk_pread(blk_new_backing, offset, buf_new, n, 0);
+                ret = blk_pread(blk_new_backing, offset, n, buf_new, 0);
                 if (ret < 0) {
                     error_report("error while reading from new backing file");
                     goto out;
@@ -XXX,XX +XXX,XX @@ static int img_rebase(int argc, char **argv)
                     if (buf_old_is_zero) {
                         ret = blk_pwrite_zeroes(blk, offset + written, pnum, 0);
                     } else {
-                        ret = blk_pwrite(blk, offset + written,
-                                         buf_old + written, pnum, 0);
+                        ret = blk_pwrite(blk, offset + written, pnum,
+                                         buf_old + written, 0);
                     }
                     if (ret < 0) {
                         error_report("Error while writing to COW image: %s",
@@ -XXX,XX +XXX,XX @@ static int img_dd(int argc, char **argv)
     for (out_pos = 0; in_pos < size; block_count++) {
         int bytes = (in_pos + in.bsz > size) ? size - in_pos : in.bsz;
 
-        ret = blk_pread(blk1, in_pos, in.buf, bytes, 0);
+        ret = blk_pread(blk1, in_pos, bytes, in.buf, 0);
         if (ret < 0) {
             error_report("error while reading from input image file: %s",
                          strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int img_dd(int argc, char **argv)
         }
         in_pos += bytes;
 
-        ret = blk_pwrite(blk2, out_pos, in.buf, bytes, 0);
+        ret = blk_pwrite(blk2, out_pos, bytes, in.buf, 0);
         if (ret < 0) {
             error_report("error while writing to output image file: %s",
                          strerror(-ret));
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static int do_pread(BlockBackend *blk, char *buf, int64_t offset,
         return -ERANGE;
     }
 
-    ret = blk_pread(blk, offset, (uint8_t *)buf, bytes, 0);
+    ret = blk_pread(blk, offset, bytes, (uint8_t *)buf, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int do_pwrite(BlockBackend *blk, char *buf, int64_t offset,
         return -ERANGE;
     }
 
-    ret = blk_pwrite(blk, offset, (uint8_t *)buf, bytes, flags);
+    ret = blk_pwrite(blk, offset, bytes, (uint8_t *)buf, flags);
     if (ret < 0) {
         return ret;
     }
diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-block-iothread.c
+++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pread(BlockBackend *blk)
     int ret;
 
     /* Success */
-    ret = blk_pread(blk, 0, buf, sizeof(buf), 0);
+    ret = blk_pread(blk, 0, sizeof(buf), buf, 0);
     g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
-    ret = blk_pread(blk, -2, buf, sizeof(buf), 0);
+    ret = blk_pread(blk, -2, sizeof(buf), buf, 0);
     g_assert_cmpint(ret, ==, -EIO);
 }
 
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwrite(BlockBackend *blk)
     int ret;
 
     /* Success */
-    ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
+    ret = blk_pwrite(blk, 0, sizeof(buf), buf, 0);
     g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
-    ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);
+    ret = blk_pwrite(blk, -2, sizeof(buf), buf, 0);
     g_assert_cmpint(ret, ==, -EIO);
 }
 
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

For consistency with other I/O functions, and in preparation to
implement them using generated_co_wrapper.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-5-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/sysemu/block-backend-io.h | 6 +++---
 block/block-backend.c             | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

From: Alberto Faria <afaria@redhat.com>

It does not mutate the buffer.

From: Alberto Faria <afaria@redhat.com>

We need to add include/sysemu/block-backend-io.h to the inputs of the
block-gen.c target defined in block/meson.build.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-7-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/coroutines.h                |  4 ----
 include/sysemu/block-backend-io.h | 10 ++++++----
 block/block-backend.c             | 23 -----------------------
 block/meson.build                 |  1 +
 4 files changed, 7 insertions(+), 31 deletions(-)

diff --git a/block/coroutines.h b/block/coroutines.h
index XXXXXXX..XXXXXXX 100644
--- a/block/coroutines.h
+++ b/block/coroutines.h
@@ -XXX,XX +XXX,XX @@ bdrv_common_block_status_above(BlockDriverState *bs,
 int generated_co_wrapper
 nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
 
-int generated_co_wrapper
-blk_do_preadv(BlockBackend *blk, int64_t offset, int64_t bytes,
-              QEMUIOVector *qiov, BdrvRequestFlags flags);
-
 int generated_co_wrapper
 blk_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
                     QEMUIOVector *qiov, size_t qiov_offset,
diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_copy_range(BlockBackend *blk_in, int64_t off_in,
  * the "I/O or GS" API.
  */
 
-int blk_pread(BlockBackend *blk, int64_t offset, int64_t bytes, void *buf,
-              BdrvRequestFlags flags);
-int blk_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
-               const void *buf, BdrvRequestFlags flags);
+int generated_co_wrapper blk_pread(BlockBackend *blk, int64_t offset,
+                                   int64_t bytes, void *buf,
+                                   BdrvRequestFlags flags);
+int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
+                                    int64_t bytes, const void *buf,
+                                    BdrvRequestFlags flags);
 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
                                int64_t bytes, QEMUIOVector *qiov,
                                BdrvRequestFlags flags);
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
                         flags | BDRV_REQ_ZERO_WRITE, cb, opaque);
 }
 
-int blk_pread(BlockBackend *blk, int64_t offset, int64_t bytes, void *buf,
-              BdrvRequestFlags flags)
-{
-    int ret;
-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
-    IO_OR_GS_CODE();
-
-    blk_inc_in_flight(blk);
-    ret = blk_do_preadv(blk, offset, bytes, &qiov, flags);
-    blk_dec_in_flight(blk);
-
-    return ret;
-}
-
-int blk_pwrite(BlockBackend *blk, int64_t offset, int64_t bytes,
-               const void *buf, BdrvRequestFlags flags)
-{
-    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
-    IO_OR_GS_CODE();
-
-    return blk_pwritev_part(blk, offset, bytes, &qiov, 0, flags);
-}
-
 int64_t blk_getlength(BlockBackend *blk)
 {
     IO_CODE();
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_gen_c = custom_target('block-gen.c',
                             input: files(
                                       '../include/block/block-io.h',
                                       '../include/block/block-global-state.h',
+                                      '../include/sysemu/block-backend-io.h',
                                       'coroutines.h'
                                       ),
                             command: [wrapper_py, '@OUTPUT@', '@INPUT@'])
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Implement them using generated_co_wrapper.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-8-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/sysemu/block-backend-io.h |  6 +++++
 tests/unit/test-block-iothread.c  | 42 ++++++++++++++++++++++++++++++-
 2 files changed, 47 insertions(+), 1 deletion(-)

From: Alberto Faria <afaria@redhat.com>

Implement blk_preadv_part() using generated_co_wrapper.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-9-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/coroutines.h                |  5 -----
 include/sysemu/block-backend-io.h |  7 +++++++
 block/block-backend.c             | 30 +++++++++++++++++++++++-------
 tests/unit/test-block-iothread.c  | 19 +++++++++++++++++++
 4 files changed, 49 insertions(+), 12 deletions(-)

diff --git a/block/coroutines.h b/block/coroutines.h
index XXXXXXX..XXXXXXX 100644
--- a/block/coroutines.h
+++ b/block/coroutines.h
@@ -XXX,XX +XXX,XX @@ nbd_co_do_establish_connection(BlockDriverState *bs, bool blocking,
                                Error **errp);
 
 
-int coroutine_fn
-blk_co_do_preadv(BlockBackend *blk, int64_t offset, int64_t bytes,
-                 QEMUIOVector *qiov, BdrvRequestFlags flags);
-
-
 int coroutine_fn
 blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
                        QEMUIOVector *qiov, size_t qiov_offset,
diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_pread(BlockBackend *blk, int64_t offset,
 int generated_co_wrapper blk_pwrite(BlockBackend *blk, int64_t offset,
                                     int64_t bytes, const void *buf,
                                     BdrvRequestFlags flags);
+int generated_co_wrapper blk_preadv_part(BlockBackend *blk, int64_t offset,
+                                         int64_t bytes, QEMUIOVector *qiov,
+                                         size_t qiov_offset,
+                                         BdrvRequestFlags flags);
+int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
+                                    int64_t bytes, QEMUIOVector *qiov,
+                                    size_t qiov_offset, BdrvRequestFlags flags);
 int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
                                     int64_t bytes, QEMUIOVector *qiov,
                                     BdrvRequestFlags flags);
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
 }
 
 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
-int coroutine_fn
-blk_co_do_preadv(BlockBackend *blk, int64_t offset, int64_t bytes,
-                 QEMUIOVector *qiov, BdrvRequestFlags flags)
+static int coroutine_fn
+blk_co_do_preadv_part(BlockBackend *blk, int64_t offset, int64_t bytes,
+                      QEMUIOVector *qiov, size_t qiov_offset,
+                      BdrvRequestFlags flags)
 {
     int ret;
     BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ blk_co_do_preadv(BlockBackend *blk, int64_t offset, int64_t bytes,
                 bytes, false);
     }
 
-    ret = bdrv_co_preadv(blk->root, offset, bytes, qiov, flags);
+    ret = bdrv_co_preadv_part(blk->root, offset, bytes, qiov, qiov_offset,
+                              flags);
     bdrv_dec_in_flight(bs);
     return ret;
 }
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
     IO_OR_GS_CODE();
 
     blk_inc_in_flight(blk);
-    ret = blk_co_do_preadv(blk, offset, bytes, qiov, flags);
+    ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, 0, flags);
+    blk_dec_in_flight(blk);
+
+    return ret;
+}
+
+int coroutine_fn blk_co_preadv_part(BlockBackend *blk, int64_t offset,
+                                    int64_t bytes, QEMUIOVector *qiov,
+                                    size_t qiov_offset, BdrvRequestFlags flags)
+{
+    int ret;
+    IO_OR_GS_CODE();
+
+    blk_inc_in_flight(blk);
+    ret = blk_co_do_preadv_part(blk, offset, bytes, qiov, qiov_offset, flags);
     blk_dec_in_flight(blk);
 
     return ret;
@@ -XXX,XX +XXX,XX @@ static void blk_aio_read_entry(void *opaque)
     QEMUIOVector *qiov = rwco->iobuf;
 
     assert(qiov->size == acb->bytes);
-    rwco->ret = blk_co_do_preadv(rwco->blk, rwco->offset, acb->bytes,
-                                 qiov, rwco->flags);
+    rwco->ret = blk_co_do_preadv_part(rwco->blk, rwco->offset, acb->bytes, qiov,
+                                      0, rwco->flags);
     blk_aio_complete(acb);
 }
 
diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-block-iothread.c
+++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_pwritev(BlockBackend *blk)
     g_assert_cmpint(ret, ==, -EIO);
 }
 
+static void test_sync_op_blk_preadv_part(BlockBackend *blk)
+{
+    uint8_t buf[512];
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, sizeof(buf));
+    int ret;
+
+    /* Success */
+    ret = blk_preadv_part(blk, 0, sizeof(buf), &qiov, 0, 0);
+    g_assert_cmpint(ret, ==, 0);
+
+    /* Early error: Negative offset */
+    ret = blk_preadv_part(blk, -2, sizeof(buf), &qiov, 0, 0);
+    g_assert_cmpint(ret, ==, -EIO);
+}
+
 static void test_sync_op_load_vmstate(BdrvChild *c)
 {
     uint8_t buf[512];
@@ -XXX,XX +XXX,XX @@ const SyncOpTest sync_op_tests[] = {
         .name   = "/sync-op/pwritev",
         .fn     = NULL,
         .blkfn  = test_sync_op_blk_pwritev,
+    }, {
+        .name   = "/sync-op/preadv_part",
+        .fn     = NULL,
+        .blkfn  = test_sync_op_blk_preadv_part,
     }, {
         .name   = "/sync-op/load_vmstate",
         .fn     = test_sync_op_load_vmstate,
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Also convert it into a generated_co_wrapper.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-10-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/coroutines.h                |  5 -----
 include/sysemu/block-backend-io.h |  4 ++++
 block/block-backend.c             | 14 --------------
 tests/unit/test-block-iothread.c  | 19 +++++++++++++++++++
 4 files changed, 23 insertions(+), 19 deletions(-)

diff --git a/block/coroutines.h b/block/coroutines.h
index XXXXXXX..XXXXXXX 100644
--- a/block/coroutines.h
+++ b/block/coroutines.h
@@ -XXX,XX +XXX,XX @@ bdrv_common_block_status_above(BlockDriverState *bs,
 int generated_co_wrapper
 nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
 
-int generated_co_wrapper
-blk_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
-                    QEMUIOVector *qiov, size_t qiov_offset,
-                    BdrvRequestFlags flags);
-
 int generated_co_wrapper
 blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
 
diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_preadv(BlockBackend *blk, int64_t offset,
 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
                                int64_t bytes, QEMUIOVector *qiov,
                                BdrvRequestFlags flags);
+int generated_co_wrapper blk_pwritev_part(BlockBackend *blk, int64_t offset,
+                                          int64_t bytes, QEMUIOVector *qiov,
+                                          size_t qiov_offset,
+                                          BdrvRequestFlags flags);
 int coroutine_fn blk_co_pwritev_part(BlockBackend *blk, int64_t offset,
                                      int64_t bytes,
                                      QEMUIOVector *qiov, size_t qiov_offset,
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
     return blk_co_pwritev_part(blk, offset, bytes, qiov, 0, flags);
 }
 
-static int coroutine_fn blk_pwritev_part(BlockBackend *blk, int64_t offset,
-                                         int64_t bytes,
-                                         QEMUIOVector *qiov, size_t qiov_offset,
-                                         BdrvRequestFlags flags)
-{
-    int ret;
-
-    blk_inc_in_flight(blk);
-    ret = blk_do_pwritev_part(blk, offset, bytes, qiov, qiov_offset, flags);
-    blk_dec_in_flight(blk);
-
-    return ret;
-}
-
 typedef struct BlkRwCo {
     BlockBackend *blk;
     int64_t offset;
diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-block-iothread.c
+++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_blk_preadv_part(BlockBackend *blk)
     g_assert_cmpint(ret, ==, -EIO);
 }
 
+static void test_sync_op_blk_pwritev_part(BlockBackend *blk)
+{
+    uint8_t buf[512] = { 0 };
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, sizeof(buf));
+    int ret;
+
+    /* Success */
+    ret = blk_pwritev_part(blk, 0, sizeof(buf), &qiov, 0, 0);
+    g_assert_cmpint(ret, ==, 0);
+
+    /* Early error: Negative offset */
+    ret = blk_pwritev_part(blk, -2, sizeof(buf), &qiov, 0, 0);
+    g_assert_cmpint(ret, ==, -EIO);
+}
+
 static void test_sync_op_load_vmstate(BdrvChild *c)
 {
     uint8_t buf[512];
@@ -XXX,XX +XXX,XX @@ const SyncOpTest sync_op_tests[] = {
         .name   = "/sync-op/preadv_part",
         .fn     = NULL,
         .blkfn  = test_sync_op_blk_preadv_part,
+    }, {
+        .name   = "/sync-op/pwritev_part",
+        .fn     = NULL,
+        .blkfn  = test_sync_op_blk_pwritev_part,
     }, {
         .name   = "/sync-op/load_vmstate",
         .fn     = test_sync_op_load_vmstate,
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Swap 'buf' and 'bytes' around for consistency with other I/O functions.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-11-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/sysemu/block-backend-io.h | 4 ++--
 block/block-backend.c             | 4 ++--
 qemu-img.c                        | 2 +-
 qemu-io-cmds.c                    | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

From: Alberto Faria <afaria@redhat.com>

Also convert blk_pwrite_compressed() into a generated_co_wrapper.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-12-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/sysemu/block-backend-io.h |  7 +++++--
 block/block-backend.c             |  8 ++++----
 tests/unit/test-block-iothread.c  | 18 ++++++++++++++++++
 3 files changed, 27 insertions(+), 6 deletions(-)

From: Alberto Faria <afaria@redhat.com>

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-13-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/sysemu/block-backend-io.h |  5 +++--
 block/block-backend.c             |  8 --------
 tests/unit/test-block-iothread.c  | 17 +++++++++++++++++
 3 files changed, 20 insertions(+), 10 deletions(-)

From: Alberto Faria <afaria@redhat.com>

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-14-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/coroutines.h                |  3 ---
 include/sysemu/block-backend-io.h |  3 ++-
 block/block-backend.c             | 12 ------------
 3 files changed, 2 insertions(+), 16 deletions(-)

diff --git a/block/coroutines.h b/block/coroutines.h
index XXXXXXX..XXXXXXX 100644
--- a/block/coroutines.h
+++ b/block/coroutines.h
@@ -XXX,XX +XXX,XX @@ nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
 int generated_co_wrapper
 blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
 
-int generated_co_wrapper
-blk_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
-
 int generated_co_wrapper blk_do_flush(BlockBackend *blk);
 
 #endif /* BLOCK_COROUTINES_H */
diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ static inline int coroutine_fn blk_co_pwrite(BlockBackend *blk, int64_t offset,
     return blk_co_pwritev(blk, offset, bytes, &qiov, flags);
 }
 
+int generated_co_wrapper blk_pdiscard(BlockBackend *blk, int64_t offset,
+                                      int64_t bytes);
 int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
                                  int64_t bytes);
 
@@ -XXX,XX +XXX,XX @@ int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
                                                const void *buf);
 int coroutine_fn blk_co_pwrite_compressed(BlockBackend *blk, int64_t offset,
                                           int64_t bytes, const void *buf);
-int blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
 int generated_co_wrapper blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
                                            int64_t bytes,
                                            BdrvRequestFlags flags);
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
     return ret;
 }
 
-int blk_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes)
-{
-    int ret;
-    IO_OR_GS_CODE();
-
-    blk_inc_in_flight(blk);
-    ret = blk_do_pdiscard(blk, offset, bytes);
-    blk_dec_in_flight(blk);
-
-    return ret;
-}
-
 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
 int coroutine_fn blk_co_do_flush(BlockBackend *blk)
 {
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-15-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/coroutines.h                |  2 --
 include/sysemu/block-backend-io.h |  2 +-
 block/block-backend.c             | 11 -----------
 3 files changed, 1 insertion(+), 14 deletions(-)

From: Alberto Faria <afaria@redhat.com>

Also convert blk_ioctl() into a generated_co_wrapper.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-16-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/coroutines.h                | 6 ------
 include/sysemu/block-backend-io.h | 5 ++++-
 block/block-backend.c             | 7 ++++---
 3 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/block/coroutines.h b/block/coroutines.h
index XXXXXXX..XXXXXXX 100644
--- a/block/coroutines.h
+++ b/block/coroutines.h
@@ -XXX,XX +XXX,XX @@ blk_co_do_pwritev_part(BlockBackend *blk, int64_t offset, int64_t bytes,
                        QEMUIOVector *qiov, size_t qiov_offset,
                        BdrvRequestFlags flags);
 
-int coroutine_fn
-blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
-
 int coroutine_fn
 blk_co_do_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes);
 
@@ -XXX,XX +XXX,XX @@ bdrv_common_block_status_above(BlockDriverState *bs,
 int generated_co_wrapper
 nbd_do_establish_connection(BlockDriverState *bs, bool blocking, Error **errp);
 
-int generated_co_wrapper
-blk_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
-
 #endif /* BLOCK_COROUTINES_H */
diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend-io.h
+++ b/include/sysemu/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,
 int generated_co_wrapper blk_flush(BlockBackend *blk);
 int coroutine_fn blk_co_flush(BlockBackend *blk);
 
-int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf);
+int generated_co_wrapper blk_ioctl(BlockBackend *blk, unsigned long int req,
+                                   void *buf);
+int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
+                              void *buf);
 
 int generated_co_wrapper blk_pwrite_compressed(BlockBackend *blk,
                                                int64_t offset, int64_t bytes,
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ void blk_aio_cancel_async(BlockAIOCB *acb)
 }
 
 /* To be called between exactly one pair of blk_inc/dec_in_flight() */
-int coroutine_fn
+static int coroutine_fn
 blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
 {
     IO_CODE();
@@ -XXX,XX +XXX,XX @@ blk_co_do_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
     return bdrv_co_ioctl(blk_bs(blk), req, buf);
 }
 
-int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
+int coroutine_fn blk_co_ioctl(BlockBackend *blk, unsigned long int req,
+                              void *buf)
 {
     int ret;
     IO_OR_GS_CODE();
 
     blk_inc_in_flight(blk);
-    ret = blk_do_ioctl(blk, req, buf);
+    ret = blk_co_do_ioctl(blk, req, buf);
     blk_dec_in_flight(blk);
 
     return ret;
-- 
2.35.3

From: Alberto Faria <afaria@redhat.com>

Also convert blk_truncate() into a generated_co_wrapper.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-17-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/sysemu/block-backend-io.h |  8 ++++++--
 block/block-backend.c             |  7 ++++---
 tests/unit/test-block-iothread.c  | 14 ++++++++++++++
 3 files changed, 24 insertions(+), 5 deletions(-)

From: Alberto Faria <afaria@redhat.com>

Keep generated_co_wrapper and coroutine_fn pairs together. This should
make it clear that each I/O function has these two versions.

Also move blk_co_{pread,pwrite}()'s implementations out of the header
file for consistency.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20220705161527.1054072-18-afaria@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 include/sysemu/block-backend-io.h | 77 +++++++++++++------------------
 block/block-backend.c             | 22 +++++++++
 2 files changed, 54 insertions(+), 45 deletions(-)

From: Alberto Faria <afaria@redhat.com>

Some can be made static, others are unused generated_co_wrappers.

Signed-off-by: Alberto Faria <afaria@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220705161527.1054072-19-afaria@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
---
 block/coroutines.h    | 19 -------------------
 block/block-backend.c |  6 +++---
 2 files changed, 3 insertions(+), 22 deletions(-)

error_report() only works once monitor_init_globals_core() has been
called, which is not the case when parsing the --daemonize option.  Use
fprintf(stderr, ...) instead.

Fixes: 2525edd85fec53e23fda98974a15e3b3c8957596 ("qsd: Add --daemonize")
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220609122852.21140-1-hreitz@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
---
 storage-daemon/qemu-storage-daemon.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/storage-daemon/qemu-storage-daemon.c b/storage-daemon/qemu-storage-daemon.c
index XXXXXXX..XXXXXXX 100644
--- a/storage-daemon/qemu-storage-daemon.c
+++ b/storage-daemon/qemu-storage-daemon.c
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[], bool pre_init_pass)
             }
         case OPTION_DAEMONIZE:
             if (os_set_daemonize(true) < 0) {
-                error_report("--daemonize not supported in this build");
+                /*
+                 * --daemonize is parsed before monitor_init_globals_core(), so
+                 * error_report() does not work yet
+                 */
+                fprintf(stderr, "--daemonize not supported in this build\n");
                 exit(EXIT_FAILURE);
             }
             break;
-- 
2.35.3

After writing the PID file, we register an atexit() handler to unlink it
when the process terminates.  However, if the process has changed its
working directory in the meantime (e.g. in os_setup_post() when
daemonizing), this will not work when the PID file path was relative.
Therefore, pass the absolute path (created with realpath()) to the
unlink() call in the atexit() handler.

(realpath() needs a path pointing to an existing file, so we cannot use
it before qemu_write_pidfile().)

Reproducer:
$ cd /tmp
$ qemu-storage-daemon --daemonize --pidfile qsd.pid
$ file qsd.pid
qsd.pid: ASCII text
$ kill $(cat qsd.pid)
$ file qsd.pid
qsd.pid: ASCII text

(qsd.pid should be gone after the process has terminated.)

Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2092322
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220609122701.17172-2-hreitz@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
---
 storage-daemon/qemu-storage-daemon.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/storage-daemon/qemu-storage-daemon.c b/storage-daemon/qemu-storage-daemon.c
index XXXXXXX..XXXXXXX 100644
--- a/storage-daemon/qemu-storage-daemon.c
+++ b/storage-daemon/qemu-storage-daemon.c
@@ -XXX,XX +XXX,XX @@
 #include "trace/control.h"
 
 static const char *pid_file;
+static char *pid_file_realpath;
 static volatile bool exit_requested = false;
 
 void qemu_system_killed(int signal, pid_t pid)
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[], bool pre_init_pass)
 
 static void pid_file_cleanup(void)
 {
-    unlink(pid_file);
+    unlink(pid_file_realpath);
 }
 
 static void pid_file_init(void)
@@ -XXX,XX +XXX,XX @@ static void pid_file_init(void)
         exit(EXIT_FAILURE);
     }
 
+    pid_file_realpath = g_malloc(PATH_MAX);
+    if (!realpath(pid_file, pid_file_realpath)) {
+        error_report("cannot resolve PID file path: %s: %s",
+                     pid_file, strerror(errno));
+        unlink(pid_file);
+        exit(EXIT_FAILURE);
+    }
+
     atexit(pid_file_cleanup);
 }
 
-- 
2.35.3

Currently, the exit notifier for unlinking the PID file is registered
unconditionally.  Limit it to only when we actually do create a PID
file.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220609122701.17172-3-hreitz@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
---
 softmmu/vl.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/softmmu/vl.c b/softmmu/vl.c
index XXXXXXX..XXXXXXX 100644
--- a/softmmu/vl.c
+++ b/softmmu/vl.c
@@ -XXX,XX +XXX,XX @@ static Notifier qemu_unlink_pidfile_notifier;
 
 static void qemu_unlink_pidfile(Notifier *n, void *data)
 {
-    if (pid_file) {
-        unlink(pid_file);
-    }
+    unlink(pid_file);
 }
 
 static const QEMUOption *lookup_opt(int argc, char **argv,
@@ -XXX,XX +XXX,XX @@ static void qemu_maybe_daemonize(const char *pid_file)
     os_daemonize();
     rcu_disable_atfork();
 
-    if (pid_file && !qemu_write_pidfile(pid_file, &err)) {
-        error_reportf_err(err, "cannot create PID file: ");
-        exit(1);
-    }
+    if (pid_file) {
+        if (!qemu_write_pidfile(pid_file, &err)) {
+            error_reportf_err(err, "cannot create PID file: ");
+            exit(1);
+        }
 
-    qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
-    qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);
+        qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
+        qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);
+    }
 }
 
 static void qemu_init_displays(void)
-- 
2.35.3

After writing the PID file, we register an exit notifier to unlink it
when the process terminates.  However, if the process has changed its
working directory in the meantime (e.g. in os_setup_post() when
daemonizing), this will not work when the PID file path was relative.
Therefore, pass the absolute path (created with realpath()) to the
unlink() call in the exit notifier.

(realpath() needs a path pointing to an existing file, so we cannot use
it before qemu_write_pidfile().)

Reproducer:
$ cd /tmp
$ qemu-system-x86_64 --daemonize --pidfile qemu.pid
$ file qemu.pid
qemu.pid: ASCII text
$ kill $(cat qemu.pid)
$ file qemu.pid
qemu.pid: ASCII text

(qemu.pid should be gone after the process has terminated.)

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220609122701.17172-4-hreitz@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
---
 softmmu/vl.c | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/softmmu/vl.c b/softmmu/vl.c
index XXXXXXX..XXXXXXX 100644
--- a/softmmu/vl.c
+++ b/softmmu/vl.c
@@ -XXX,XX +XXX,XX @@ machine_parse_property_opt(QemuOptsList *opts_list, const char *propname,
 }
 
 static const char *pid_file;
-static Notifier qemu_unlink_pidfile_notifier;
+struct UnlinkPidfileNotifier {
+    Notifier notifier;
+    char *pid_file_realpath;
+};
+static struct UnlinkPidfileNotifier qemu_unlink_pidfile_notifier;
 
 static void qemu_unlink_pidfile(Notifier *n, void *data)
 {
-    unlink(pid_file);
+    struct UnlinkPidfileNotifier *upn;
+
+    upn = DO_UPCAST(struct UnlinkPidfileNotifier, notifier, n);
+    unlink(upn->pid_file_realpath);
 }
 
 static const QEMUOption *lookup_opt(int argc, char **argv,
@@ -XXX,XX +XXX,XX @@ static void qemu_maybe_daemonize(const char *pid_file)
     rcu_disable_atfork();
 
     if (pid_file) {
+        char *pid_file_realpath = NULL;
+
         if (!qemu_write_pidfile(pid_file, &err)) {
             error_reportf_err(err, "cannot create PID file: ");
             exit(1);
         }
 
-        qemu_unlink_pidfile_notifier.notify = qemu_unlink_pidfile;
-        qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier);
+        pid_file_realpath = g_malloc0(PATH_MAX);
+        if (!realpath(pid_file, pid_file_realpath)) {
+            error_report("cannot resolve PID file path: %s: %s",
+                         pid_file, strerror(errno));
+            unlink(pid_file);
+            exit(1);
+        }
+
+        qemu_unlink_pidfile_notifier = (struct UnlinkPidfileNotifier) {
+            .notifier = {
+                .notify = qemu_unlink_pidfile,
+            },
+            .pid_file_realpath = pid_file_realpath,
+        };
+        qemu_add_exit_notifier(&qemu_unlink_pidfile_notifier.notifier);
     }
 }
 
-- 
2.35.3