Series comparison

-[PULL 00/15] Block layer patches
+[PULL 00/13] Block layer patches
-The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e:
+The following changes since commit 2e3408b3cc7de4e87a9adafc8c19bfce3abec947:
-  Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100)
+  Merge tag 'misc-pull-request' of gitlab.com:marcandre.lureau/qemu into staging (2022-05-03 09:13:17 -0700)
 are available in the Git repository at:
   git://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809:
+for you to fetch changes up to c1fe694357a328c807ae3cc6961c19e923448fcc:
-  qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200)
+  coroutine-win32: use QEMU_DEFINE_STATIC_CO_TLS() (2022-05-04 15:55:23 +0200)
 ----------------------------------------------------------------
-Block layer patches:
+Block layer patches
-- Fix resize (extending) of short overlays
+- Fix and re-enable GLOBAL_STATE_CODE assertions
-- nvme: introduce PMR support from NVMe 1.4 spec
+- vhost-user: Fixes for VHOST_USER_ADD/REM_MEM_REG
-- qemu-storage-daemon: Fix non-string --object properties
+- vmdk: Fix reopening bs->file
 - coroutine: use QEMU_DEFINE_STATIC_CO_TLS()
 - docs/qemu-img: Fix list of formats which implement check
 ----------------------------------------------------------------
-Alberto Garcia (1):
+Denis V. Lunev (1):
-      qcow2: Add incompatibility note between backing files and raw external data files
+      qemu-img: properly list formats which have consistency check implemented
-Andrzej Jakowski (1):
+Hanna Reitz (6):
-      nvme: introduce PMR support from NVMe 1.4 spec
+      block: Classify bdrv_get_flags() as I/O function
       qcow2: Do not reopen data_file in invalidate_cache
       Revert "main-loop: Disable GLOBAL_STATE_CODE() assertions"
       iotests: Add regression test for issue 945
       block/vmdk: Fix reopening bs->file
       iotests/reopen-file: Test reopening file child
-Kevin Wolf (12):
+Kevin Wolf (3):
-      block: Add flags to BlockDriver.bdrv_co_truncate()
+      docs/vhost-user: Clarifications for VHOST_USER_ADD/REM_MEM_REG
-      block: Add flags to bdrv(_co)_truncate()
+      libvhost-user: Fix extra vu_add/rem_mem_reg reply
-      block-backend: Add flags to blk_truncate()
+      vhost-user: Don't pass file descriptor for VHOST_USER_REM_MEM_REG
       qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
       raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
       file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
       block: truncate: Don't make backing file data visible
       iotests: Filter testfiles out in filter_img_info()
       iotests: Test committing to short backing file
       qcow2: Forward ZERO_WRITE flag for full preallocation
       qom: Factor out user_creatable_add_dict()
       qemu-storage-daemon: Fix non-string --object properties
-Paolo Bonzini (1):
+Stefan Hajnoczi (3):
-      qemu-iotests: allow qcow2 external discarded clusters to contain stale data
+      coroutine-ucontext: use QEMU_DEFINE_STATIC_CO_TLS()
       coroutine: use QEMU_DEFINE_STATIC_CO_TLS()
       coroutine-win32: use QEMU_DEFINE_STATIC_CO_TLS()
- docs/interop/qcow2.txt          |   3 +
+ docs/interop/vhost-user.rst                        |  17 ++++
- hw/block/nvme.h                 |   2 +
+ docs/tools/qemu-img.rst                            |   4 +-
- include/block/block.h           |   5 +-
+ include/block/block-global-state.h                 |   1 -
- include/block/block_int.h       |  10 +-
+ include/block/block-io.h                           |   1 +
- include/block/nvme.h            | 172 ++++++++++++++++++++++++++
+ include/qemu/main-loop.h                           |   3 +-
- include/qom/object_interfaces.h |  16 +++
+ block.c                                            |   2 +-
- include/sysemu/block-backend.h  |   2 +-
+ block/qcow2.c                                      | 104 ++++++++++++---------
- block.c                         |   3 +-
+ block/vmdk.c                                       |  56 ++++++++++-
- block/block-backend.c           |   4 +-
+ hw/virtio/vhost-user.c                             |   2 +-
- block/commit.c                  |   4 +-
+ subprojects/libvhost-user/libvhost-user.c          |  17 ++--
- block/crypto.c                  |   7 +-
+ util/coroutine-ucontext.c                          |  38 +++++---
- block/file-posix.c              |   6 +-
+ util/coroutine-win32.c                             |  18 +++-
- block/file-win32.c              |   2 +-
+ util/qemu-coroutine.c                              |  41 ++++----
- block/gluster.c                 |   1 +
+ tests/qemu-iotests/tests/export-incoming-iothread  |  81 ++++++++++++++++
- block/io.c                      |  43 ++++++-
+ .../tests/export-incoming-iothread.out             |   5 +
- block/iscsi.c                   |   2 +-
+ tests/qemu-iotests/tests/reopen-file               |  89 ++++++++++++++++++
- block/mirror.c                  |   2 +-
+ tests/qemu-iotests/tests/reopen-file.out           |   5 +
- block/nfs.c                     |   3 +-
+files changed, 388 insertions(+), 96 deletions(-)
- block/parallels.c               |   6 +-
+ create mode 100755 tests/qemu-iotests/tests/export-incoming-iothread
- block/qcow.c                    |   4 +-
+ create mode 100644 tests/qemu-iotests/tests/export-incoming-iothread.out
- block/qcow2-cluster.c           |   2 +-
+ create mode 100755 tests/qemu-iotests/tests/reopen-file
- block/qcow2-refcount.c          |   2 +-
+ create mode 100644 tests/qemu-iotests/tests/reopen-file.out
  block/qcow2.c                   |  73 +++++++++--
  block/qed.c                     |   3 +-
  block/raw-format.c              |   6 +-
  block/rbd.c                     |   1 +
  block/sheepdog.c                |   4 +-
  block/ssh.c                     |   2 +-
  block/vdi.c                     |   2 +-
  block/vhdx-log.c                |   2 +-
  block/vhdx.c                    |   6 +-
  block/vmdk.c                    |   8 +-
  block/vpc.c                     |   2 +-
  blockdev.c                      |   2 +-
  hw/block/nvme.c                 | 109 ++++++++++++++++
  qemu-img.c                      |   2 +-
  qemu-io-cmds.c                  |   2 +-
  qemu-storage-daemon.c           |   4 +-
  qom/object_interfaces.c         |  31 +++++
  qom/qom-qmp-cmds.c              |  24 +---
  tests/test-block-iothread.c     |   9 +-
  tests/qemu-iotests/iotests.py   |   5 +-
  hw/block/Makefile.objs          |   2 +-
  hw/block/trace-events           |   4 +
  tests/qemu-iotests/244          |  10 +-
  tests/qemu-iotests/244.out      |   9 +-
  tests/qemu-iotests/274          | 155 +++++++++++++++++++++++
  tests/qemu-iotests/274.out      | 268 ++++++++++++++++++++++++++++++++++++++++
  tests/qemu-iotests/group        |   1 +
 files changed, 951 insertions(+), 96 deletions(-)
  create mode 100755 tests/qemu-iotests/274
  create mode 100644 tests/qemu-iotests/274.out

-[PULL 13/15] nvme: introduce PMR support from NVMe 1.4 spec
+[PULL 01/13] qemu-img: properly list formats which have consistency check implemented
-From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
+From: "Denis V. Lunev" <den@openvz.org>
-This patch introduces support for PMR that has been defined as part of NVMe 1.4
+Simple grep for the .bdrv_co_check callback presence gives the following
-spec. User can now specify a pmrdev option that should point to HostMemoryBackend.
+list of block drivers
-pmrdev memory region will subsequently be exposed as PCI BAR 2 in emulated NVMe
+* QED
-device. Guest OS can perform mmio read and writes to the PMR region that will stay
+* VDI
-persistent across system reboot.
+* VHDX
 * VMDK
 * Parallels
 which have this callback. The presense of the callback means that
 consistency check is supported.
-Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
+The patch updates documentation accordingly.
-Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Denis V. Lunev <den@openvz.org>
-Message-Id: <20200330164656.9348-1-andrzej.jakowski@linux.intel.com>
+CC: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Keith Busch <kbusch@kernel.org>
+CC: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20220407083932.531965-1-den@openvz.org>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- hw/block/nvme.h        |   2 +
+ docs/tools/qemu-img.rst | 4 ++--
- include/block/nvme.h   | 172 +++++++++++++++++++++++++++++++++++++++++
+file changed, 2 insertions(+), 2 deletions(-)
  hw/block/nvme.c        | 109 ++++++++++++++++++++++++++
  hw/block/Makefile.objs |   2 +-
  hw/block/trace-events  |   4 +
 files changed, 288 insertions(+), 1 deletion(-)
-diff --git a/hw/block/nvme.h b/hw/block/nvme.h
+diff --git a/docs/tools/qemu-img.rst b/docs/tools/qemu-img.rst
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/nvme.h
+--- a/docs/tools/qemu-img.rst
-+++ b/hw/block/nvme.h
++++ b/docs/tools/qemu-img.rst
-@@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl {
+@@ -XXX,XX +XXX,XX @@ Command description:
-     uint64_t    timestamp_set_qemu_clock_ms;    /* QEMU clock time */
+   ``-r all`` fixes all kinds of errors, with a higher risk of choosing the
+   wrong fix or hiding corruption that has already occurred.
-     char            *serial;
-+    HostMemoryBackend *pmrdev;
+-  Only the formats ``qcow2``, ``qed`` and ``vdi`` support
-+
+-  consistency checks.
-     NvmeNamespace   *namespaces;
++  Only the formats ``qcow2``, ``qed``, ``parallels``, ``vhdx``, ``vmdk`` and
-     NvmeSQueue      **sq;
++  ``vdi`` support consistency checks.
-     NvmeCQueue      **cq;
-diff --git a/include/block/nvme.h b/include/block/nvme.h
+   In case the image does not have any inconsistencies, check exits with ``0``.
-index XXXXXXX..XXXXXXX 100644
+   Other exit codes indicate the kind of inconsistency found or if another error
 --- a/include/block/nvme.h
 +++ b/include/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeBar {
      uint64_t    acq;
      uint32_t    cmbloc;
      uint32_t    cmbsz;
 +    uint8_t     padding[3520]; /* not used by QEMU */
 +    uint32_t    pmrcap;
 +    uint32_t    pmrctl;
 +    uint32_t    pmrsts;
 +    uint32_t    pmrebs;
 +    uint32_t    pmrswtp;
 +    uint32_t    pmrmsc;
  } NvmeBar;
  enum NvmeCapShift {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapShift {
      CAP_CSS_SHIFT      = 37,
      CAP_MPSMIN_SHIFT   = 48,
      CAP_MPSMAX_SHIFT   = 52,
 +    CAP_PMR_SHIFT      = 56,
  };
  enum NvmeCapMask {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
      CAP_CSS_MASK       = 0xff,
      CAP_MPSMIN_MASK    = 0xf,
      CAP_MPSMAX_MASK    = 0xf,
 +    CAP_PMR_MASK       = 0x1,
  };
  #define NVME_CAP_MQES(cap)  (((cap) >> CAP_MQES_SHIFT)   & CAP_MQES_MASK)
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
                                                             << CAP_MPSMIN_SHIFT)
  #define NVME_CAP_SET_MPSMAX(cap, val) (cap |= (uint64_t)(val & CAP_MPSMAX_MASK)\
                                                              << CAP_MPSMAX_SHIFT)
 +#define NVME_CAP_SET_PMRS(cap, val) (cap |= (uint64_t)(val & CAP_PMR_MASK)\
 +                                                            << CAP_PMR_SHIFT)
  enum NvmeCcShift {
      CC_EN_SHIFT     = 0,
@@ -XXX,XX +XXX,XX @@ enum NvmeCmbszMask {
  #define NVME_CMBSZ_GETSIZE(cmbsz) \
      (NVME_CMBSZ_SZ(cmbsz) * (1 << (12 + 4 * NVME_CMBSZ_SZU(cmbsz))))
 +enum NvmePmrcapShift {
 +    PMRCAP_RDS_SHIFT      = 3,
 +    PMRCAP_WDS_SHIFT      = 4,
 +    PMRCAP_BIR_SHIFT      = 5,
 +    PMRCAP_PMRTU_SHIFT    = 8,
 +    PMRCAP_PMRWBM_SHIFT   = 10,
 +    PMRCAP_PMRTO_SHIFT    = 16,
 +    PMRCAP_CMSS_SHIFT     = 24,
 +};
 +
 +enum NvmePmrcapMask {
 +    PMRCAP_RDS_MASK      = 0x1,
 +    PMRCAP_WDS_MASK      = 0x1,
 +    PMRCAP_BIR_MASK      = 0x7,
 +    PMRCAP_PMRTU_MASK    = 0x3,
 +    PMRCAP_PMRWBM_MASK   = 0xf,
 +    PMRCAP_PMRTO_MASK    = 0xff,
 +    PMRCAP_CMSS_MASK     = 0x1,
 +};
 +
 +#define NVME_PMRCAP_RDS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_RDS_SHIFT)   & PMRCAP_RDS_MASK)
 +#define NVME_PMRCAP_WDS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_WDS_SHIFT)   & PMRCAP_WDS_MASK)
 +#define NVME_PMRCAP_BIR(pmrcap)    \
 +    ((pmrcap >> PMRCAP_BIR_SHIFT)   & PMRCAP_BIR_MASK)
 +#define NVME_PMRCAP_PMRTU(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRTU_SHIFT)   & PMRCAP_PMRTU_MASK)
 +#define NVME_PMRCAP_PMRWBM(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRWBM_SHIFT)   & PMRCAP_PMRWBM_MASK)
 +#define NVME_PMRCAP_PMRTO(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRTO_SHIFT)   & PMRCAP_PMRTO_MASK)
 +#define NVME_PMRCAP_CMSS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_CMSS_SHIFT)   & PMRCAP_CMSS_MASK)
 +
 +#define NVME_PMRCAP_SET_RDS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_RDS_MASK) << PMRCAP_RDS_SHIFT)
 +#define NVME_PMRCAP_SET_WDS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_WDS_MASK) << PMRCAP_WDS_SHIFT)
 +#define NVME_PMRCAP_SET_BIR(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_BIR_MASK) << PMRCAP_BIR_SHIFT)
 +#define NVME_PMRCAP_SET_PMRTU(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTU_MASK) << PMRCAP_PMRTU_SHIFT)
 +#define NVME_PMRCAP_SET_PMRWBM(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRWBM_MASK) << PMRCAP_PMRWBM_SHIFT)
 +#define NVME_PMRCAP_SET_PMRTO(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTO_MASK) << PMRCAP_PMRTO_SHIFT)
 +#define NVME_PMRCAP_SET_CMSS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_CMSS_MASK) << PMRCAP_CMSS_SHIFT)
 +
 +enum NvmePmrctlShift {
 +    PMRCTL_EN_SHIFT   = 0,
 +};
 +
 +enum NvmePmrctlMask {
 +    PMRCTL_EN_MASK   = 0x1,
 +};
 +
 +#define NVME_PMRCTL_EN(pmrctl)  ((pmrctl >> PMRCTL_EN_SHIFT)   & PMRCTL_EN_MASK)
 +
 +#define NVME_PMRCTL_SET_EN(pmrctl, val)   \
 +    (pmrctl |= (uint64_t)(val & PMRCTL_EN_MASK) << PMRCTL_EN_SHIFT)
 +
 +enum NvmePmrstsShift {
 +    PMRSTS_ERR_SHIFT    = 0,
 +    PMRSTS_NRDY_SHIFT   = 8,
 +    PMRSTS_HSTS_SHIFT   = 9,
 +    PMRSTS_CBAI_SHIFT   = 12,
 +};
 +
 +enum NvmePmrstsMask {
 +    PMRSTS_ERR_MASK    = 0xff,
 +    PMRSTS_NRDY_MASK   = 0x1,
 +    PMRSTS_HSTS_MASK   = 0x7,
 +    PMRSTS_CBAI_MASK   = 0x1,
 +};
 +
 +#define NVME_PMRSTS_ERR(pmrsts)     \
 +    ((pmrsts >> PMRSTS_ERR_SHIFT)   & PMRSTS_ERR_MASK)
 +#define NVME_PMRSTS_NRDY(pmrsts)    \
 +    ((pmrsts >> PMRSTS_NRDY_SHIFT)   & PMRSTS_NRDY_MASK)
 +#define NVME_PMRSTS_HSTS(pmrsts)    \
 +    ((pmrsts >> PMRSTS_HSTS_SHIFT)   & PMRSTS_HSTS_MASK)
 +#define NVME_PMRSTS_CBAI(pmrsts)    \
 +    ((pmrsts >> PMRSTS_CBAI_SHIFT)   & PMRSTS_CBAI_MASK)
 +
 +#define NVME_PMRSTS_SET_ERR(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_ERR_MASK) << PMRSTS_ERR_SHIFT)
 +#define NVME_PMRSTS_SET_NRDY(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_NRDY_MASK) << PMRSTS_NRDY_SHIFT)
 +#define NVME_PMRSTS_SET_HSTS(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_HSTS_MASK) << PMRSTS_HSTS_SHIFT)
 +#define NVME_PMRSTS_SET_CBAI(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_CBAI_MASK) << PMRSTS_CBAI_SHIFT)
 +
 +enum NvmePmrebsShift {
 +    PMREBS_PMRSZU_SHIFT   = 0,
 +    PMREBS_RBB_SHIFT      = 4,
 +    PMREBS_PMRWBZ_SHIFT   = 8,
 +};
 +
 +enum NvmePmrebsMask {
 +    PMREBS_PMRSZU_MASK   = 0xf,
 +    PMREBS_RBB_MASK      = 0x1,
 +    PMREBS_PMRWBZ_MASK   = 0xffffff,
 +};
 +
 +#define NVME_PMREBS_PMRSZU(pmrebs)  \
 +    ((pmrebs >> PMREBS_PMRSZU_SHIFT)   & PMREBS_PMRSZU_MASK)
 +#define NVME_PMREBS_RBB(pmrebs)     \
 +    ((pmrebs >> PMREBS_RBB_SHIFT)   & PMREBS_RBB_MASK)
 +#define NVME_PMREBS_PMRWBZ(pmrebs)  \
 +    ((pmrebs >> PMREBS_PMRWBZ_SHIFT)   & PMREBS_PMRWBZ_MASK)
 +
 +#define NVME_PMREBS_SET_PMRSZU(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_PMRSZU_MASK) << PMREBS_PMRSZU_SHIFT)
 +#define NVME_PMREBS_SET_RBB(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_RBB_MASK) << PMREBS_RBB_SHIFT)
 +#define NVME_PMREBS_SET_PMRWBZ(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_PMRWBZ_MASK) << PMREBS_PMRWBZ_SHIFT)
 +
 +enum NvmePmrswtpShift {
 +    PMRSWTP_PMRSWTU_SHIFT   = 0,
 +    PMRSWTP_PMRSWTV_SHIFT   = 8,
 +};
 +
 +enum NvmePmrswtpMask {
 +    PMRSWTP_PMRSWTU_MASK   = 0xf,
 +    PMRSWTP_PMRSWTV_MASK   = 0xffffff,
 +};
 +
 +#define NVME_PMRSWTP_PMRSWTU(pmrswtp)   \
 +    ((pmrswtp >> PMRSWTP_PMRSWTU_SHIFT)   & PMRSWTP_PMRSWTU_MASK)
 +#define NVME_PMRSWTP_PMRSWTV(pmrswtp)   \
 +    ((pmrswtp >> PMRSWTP_PMRSWTV_SHIFT)   & PMRSWTP_PMRSWTV_MASK)
 +
 +#define NVME_PMRSWTP_SET_PMRSWTU(pmrswtp, val)   \
 +    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTU_MASK) << PMRSWTP_PMRSWTU_SHIFT)
 +#define NVME_PMRSWTP_SET_PMRSWTV(pmrswtp, val)   \
 +    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTV_MASK) << PMRSWTP_PMRSWTV_SHIFT)
 +
 +enum NvmePmrmscShift {
 +    PMRMSC_CMSE_SHIFT   = 1,
 +    PMRMSC_CBA_SHIFT    = 12,
 +};
 +
 +enum NvmePmrmscMask {
 +    PMRMSC_CMSE_MASK   = 0x1,
 +    PMRMSC_CBA_MASK    = 0xfffffffffffff,
 +};
 +
 +#define NVME_PMRMSC_CMSE(pmrmsc)    \
 +    ((pmrmsc >> PMRMSC_CMSE_SHIFT)   & PMRMSC_CMSE_MASK)
 +#define NVME_PMRMSC_CBA(pmrmsc)     \
 +    ((pmrmsc >> PMRMSC_CBA_SHIFT)   & PMRMSC_CBA_MASK)
 +
 +#define NVME_PMRMSC_SET_CMSE(pmrmsc, val)   \
 +    (pmrmsc |= (uint64_t)(val & PMRMSC_CMSE_MASK) << PMRMSC_CMSE_SHIFT)
 +#define NVME_PMRMSC_SET_CBA(pmrmsc, val)   \
 +    (pmrmsc |= (uint64_t)(val & PMRMSC_CBA_MASK) << PMRMSC_CBA_SHIFT)
 +
  typedef struct NvmeCmd {
      uint8_t     opcode;
      uint8_t     fuse;
 diff --git a/hw/block/nvme.c b/hw/block/nvme.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/nvme.c
 +++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@
   *      -drive file=<file>,if=none,id=<drive_id>
   *      -device nvme,drive=<drive_id>,serial=<serial>,id=<id[optional]>, \
   *              cmb_size_mb=<cmb_size_mb[optional]>, \
 + *              [pmrdev=<mem_backend_file_id>,] \
   *              num_queues=<N[optional]>
   *
   * Note cmb_size_mb denotes size of CMB in MB. CMB is assumed to be at
   * offset 0 in BAR2 and supports only WDS, RDS and SQS for now.
 + *
 + * cmb_size_mb= and pmrdev= options are mutually exclusive due to limitation
 + * in available BAR's. cmb_size_mb= will take precedence over pmrdev= when
 + * both provided.
 + * Enabling pmr emulation can be achieved by pointing to memory-backend-file.
 + * For example:
 + * -object memory-backend-file,id=<mem_id>,share=on,mem-path=<file_path>, \
 + *  size=<size> .... -device nvme,...,pmrdev=<mem_id>
   */
  #include "qemu/osdep.h"
@@ -XXX,XX +XXX,XX @@
  #include "sysemu/sysemu.h"
  #include "qapi/error.h"
  #include "qapi/visitor.h"
 +#include "sysemu/hostmem.h"
  #include "sysemu/block-backend.h"
 +#include "exec/ram_addr.h"
  #include "qemu/log.h"
  #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
          NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly,
                         "invalid write to read only CMBSZ, ignored");
          return;
 +    case 0xE00: /* PMRCAP */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrcap_readonly,
 +                       "invalid write to PMRCAP register, ignored");
 +        return;
 +    case 0xE04: /* TODO PMRCTL */
 +        break;
 +    case 0xE08: /* PMRSTS */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrsts_readonly,
 +                       "invalid write to PMRSTS register, ignored");
 +        return;
 +    case 0xE0C: /* PMREBS */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrebs_readonly,
 +                       "invalid write to PMREBS register, ignored");
 +        return;
 +    case 0xE10: /* PMRSWTP */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrswtp_readonly,
 +                       "invalid write to PMRSWTP register, ignored");
 +        return;
 +    case 0xE14: /* TODO PMRMSC */
 +         break;
      default:
          NVME_GUEST_ERR(nvme_ub_mmiowr_invalid,
                         "invalid MMIO write,"
@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size)
      }
      if (addr < sizeof(n->bar)) {
 +        /*
 +         * When PMRWBM bit 1 is set then read from
 +         * from PMRSTS should ensure prior writes
 +         * made it to persistent media
 +         */
 +        if (addr == 0xE08 &&
 +            (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) {
 +            qemu_ram_writeback(n->pmrdev->mr.ram_block,
 +                               0, n->pmrdev->size);
 +        }
          memcpy(&val, ptr + addr, size);
      } else {
          NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs,
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
          error_setg(errp, "serial property not set");
          return;
      }
 +
 +    if (!n->cmb_size_mb && n->pmrdev) {
 +        if (host_memory_backend_is_mapped(n->pmrdev)) {
 +            char *path = object_get_canonical_path_component(OBJECT(n->pmrdev));
 +            error_setg(errp, "can't use already busy memdev: %s", path);
 +            g_free(path);
 +            return;
 +        }
 +
 +        if (!is_power_of_2(n->pmrdev->size)) {
 +            error_setg(errp, "pmr backend size needs to be power of 2 in size");
 +            return;
 +        }
 +
 +        host_memory_backend_set_mapped(n->pmrdev, true);
 +    }
 +
      blkconf_blocksizes(&n->conf);
      if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),
                                         false, errp)) {
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
              PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
              PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem);
 +    } else if (n->pmrdev) {
 +        /* Controller Capabilities register */
 +        NVME_CAP_SET_PMRS(n->bar.cap, 1);
 +
 +        /* PMR Capabities register */
 +        n->bar.pmrcap = 0;
 +        NVME_PMRCAP_SET_RDS(n->bar.pmrcap, 0);
 +        NVME_PMRCAP_SET_WDS(n->bar.pmrcap, 0);
 +        NVME_PMRCAP_SET_BIR(n->bar.pmrcap, 2);
 +        NVME_PMRCAP_SET_PMRTU(n->bar.pmrcap, 0);
 +        /* Turn on bit 1 support */
 +        NVME_PMRCAP_SET_PMRWBM(n->bar.pmrcap, 0x02);
 +        NVME_PMRCAP_SET_PMRTO(n->bar.pmrcap, 0);
 +        NVME_PMRCAP_SET_CMSS(n->bar.pmrcap, 0);
 +
 +        /* PMR Control register */
 +        n->bar.pmrctl = 0;
 +        NVME_PMRCTL_SET_EN(n->bar.pmrctl, 0);
 +
 +        /* PMR Status register */
 +        n->bar.pmrsts = 0;
 +        NVME_PMRSTS_SET_ERR(n->bar.pmrsts, 0);
 +        NVME_PMRSTS_SET_NRDY(n->bar.pmrsts, 0);
 +        NVME_PMRSTS_SET_HSTS(n->bar.pmrsts, 0);
 +        NVME_PMRSTS_SET_CBAI(n->bar.pmrsts, 0);
 +
 +        /* PMR Elasticity Buffer Size register */
 +        n->bar.pmrebs = 0;
 +        NVME_PMREBS_SET_PMRSZU(n->bar.pmrebs, 0);
 +        NVME_PMREBS_SET_RBB(n->bar.pmrebs, 0);
 +        NVME_PMREBS_SET_PMRWBZ(n->bar.pmrebs, 0);
 +
 +        /* PMR Sustained Write Throughput register */
 +        n->bar.pmrswtp = 0;
 +        NVME_PMRSWTP_SET_PMRSWTU(n->bar.pmrswtp, 0);
 +        NVME_PMRSWTP_SET_PMRSWTV(n->bar.pmrswtp, 0);
 +
 +        /* PMR Memory Space Control register */
 +        n->bar.pmrmsc = 0;
 +        NVME_PMRMSC_SET_CMSE(n->bar.pmrmsc, 0);
 +        NVME_PMRMSC_SET_CBA(n->bar.pmrmsc, 0);
 +
 +        pci_register_bar(pci_dev, NVME_PMRCAP_BIR(n->bar.pmrcap),
 +            PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
 +            PCI_BASE_ADDRESS_MEM_PREFETCH, &n->pmrdev->mr);
      }
      for (i = 0; i < n->num_namespaces; i++) {
@@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev)
      if (n->cmb_size_mb) {
          g_free(n->cmbuf);
      }
 +
 +    if (n->pmrdev) {
 +        host_memory_backend_set_mapped(n->pmrdev, false);
 +    }
      msix_uninit_exclusive_bar(pci_dev);
  }
  static Property nvme_props[] = {
      DEFINE_BLOCK_PROPERTIES(NvmeCtrl, conf),
 +    DEFINE_PROP_LINK("pmrdev", NvmeCtrl, pmrdev, TYPE_MEMORY_BACKEND,
 +                     HostMemoryBackend *),
      DEFINE_PROP_STRING("serial", NvmeCtrl, serial),
      DEFINE_PROP_UINT32("cmb_size_mb", NvmeCtrl, cmb_size_mb, 0),
      DEFINE_PROP_UINT32("num_queues", NvmeCtrl, num_queues, 64),
 diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/Makefile.objs
 +++ b/hw/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o
  common-obj-$(CONFIG_XEN) += xen-block.o
  common-obj-$(CONFIG_ECC) += ecc.o
  common-obj-$(CONFIG_ONENAND) += onenand.o
 -common-obj-$(CONFIG_NVME_PCI) += nvme.o
  common-obj-$(CONFIG_SWIM) += swim.o
  common-obj-$(CONFIG_SH4) += tc58128.o
  obj-$(CONFIG_VIRTIO_BLK) += virtio-blk.o
  obj-$(CONFIG_VHOST_USER_BLK) += vhost-user-blk.o
 +obj-$(CONFIG_NVME_PCI) += nvme.o
  obj-y += dataplane/
 diff --git a/hw/block/trace-events b/hw/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/trace-events
 +++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@ nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CA
  nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)"
  nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored"
  nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored"
 +nvme_ub_mmiowr_pmrcap_readonly(void) "invalid write to read only PMRCAP, ignored"
 +nvme_ub_mmiowr_pmrsts_readonly(void) "invalid write to read only PMRSTS, ignored"
 +nvme_ub_mmiowr_pmrebs_readonly(void) "invalid write to read only PMREBS, ignored"
 +nvme_ub_mmiowr_pmrswtp_readonly(void) "invalid write to read only PMRSWTP, ignored"
  nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64""
  nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64""
  nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64""
 --
-.25.3
+.35.1

-[PULL 12/15] qcow2: Forward ZERO_WRITE flag for full preallocation
+[PULL 02/13] docs/vhost-user: Clarifications for VHOST_USER_ADD/REM_MEM_REG
-The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the
+The specification for VHOST_USER_ADD/REM_MEM_REG messages is unclear
-image is possibly preallocated and then the zero flag is added to all
+in several points, which has led to clients having incompatible
-clusters. This means that a copy-on-write operation may be needed when
+implementations. This changes the specification to be more explicit
-writing to these clusters, despite having used preallocation, negating
+about them:
 one of the major benefits of preallocation.
-Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver,
+* VHOST_USER_ADD_MEM_REG is not specified as receiving a file
-and if the protocol driver can ensure that the new area reads as zeros,
+  descriptor, though it obviously does need to do so. All
-we can skip setting the zero flag in the qcow2 layer.
+  implementations agree on this one, fix the specification.
-Unfortunately, the same approach doesn't work for metadata
+* VHOST_USER_REM_MEM_REG is not specified as receiving a file
-preallocation, so we'll still set the zero flag there.
+  descriptor either, and it also has no reason to do so. rust-vmm does
   not send file descriptors for removing a memory region (in agreement
   with the specification), libvhost-user and QEMU do (which is a bug),
   though libvhost-user doesn't actually make any use of it.
   Change the specification so that for compatibility QEMU's behaviour
   becomes legal, even if discouraged, but rust-vmm's behaviour becomes
   the explicitly recommended mode of operation.
 * VHOST_USER_ADD_MEM_REG doesn't have a documented return value, which
   is the desired behaviour in the non-postcopy case. It also implemented
   like this in QEMU and rust-vmm, though libvhost-user is buggy and
   sometimes sends an unexpected reply. This will be fixed in a separate
   patch.
   However, in postcopy mode it does reply like VHOST_USER_SET_MEM_TABLE.
   This behaviour is shared between libvhost-user and QEMU; rust-vmm
   doesn't implement postcopy mode yet. Mention it explicitly in the
   spec.
 * The specification doesn't mention how VHOST_USER_REM_MEM_REG
   identifies the memory region to be removed. Change it to describe the
   existing behaviour of libvhost-user (guest address, user address and
   size must match).
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Message-Id: <20220407133657.155281-2-kwolf@redhat.com>
-Message-Id: <20200424142701.67053-1-kwolf@redhat.com>
+Reviewed-by: Raphael Norwitz <raphael.norwitz@nutanix.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.c              | 22 +++++++++++++++++++---
+ docs/interop/vhost-user.rst | 17 +++++++++++++++++
- tests/qemu-iotests/274.out |  4 ++--
+file changed, 17 insertions(+)
 files changed, 21 insertions(+), 5 deletions(-)
-diff --git a/block/qcow2.c b/block/qcow2.c
+diff --git a/docs/interop/vhost-user.rst b/docs/interop/vhost-user.rst
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2.c
+--- a/docs/interop/vhost-user.rst
-+++ b/block/qcow2.c
++++ b/docs/interop/vhost-user.rst
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+@@ -XXX,XX +XXX,XX @@ replies. Here is a list of the ones that do:
-         /* Allocate the data area */
+ There are several messages that the master sends with file descriptors passed
-         new_file_size = allocation_start +
+ in the ancillary data:
-                         nb_new_data_clusters * s->cluster_size;
--        /* Image file grows, so @exact does not matter */
++* ``VHOST_USER_ADD_MEM_REG``
--        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
+ * ``VHOST_USER_SET_MEM_TABLE``
--                               errp);
+ * ``VHOST_USER_SET_LOG_BASE`` (if ``VHOST_USER_PROTOCOL_F_LOG_SHMFD``)
-+        /*
+ * ``VHOST_USER_SET_LOG_FD``
-+         * Image file grows, so @exact does not matter.
+@@ -XXX,XX +XXX,XX @@ Master message types
-+         *
+   ``VHOST_USER_REM_MEM_REG`` message, this message is used to set and
-+         * If we need to zero out the new area, try first whether the protocol
+   update the memory tables of the slave device.
-+         * driver can already take care of this.
-+         */
++  Exactly one file descriptor from which the memory is mapped is
-+        if (flags & BDRV_REQ_ZERO_WRITE) {
++  passed in the ancillary data.
-+            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
++
-+                                   BDRV_REQ_ZERO_WRITE, NULL);
++  In postcopy mode (see ``VHOST_USER_POSTCOPY_LISTEN``), the slave
-+            if (ret >= 0) {
++  replies with the bases of the memory mapped region to the master.
-+                flags &= ~BDRV_REQ_ZERO_WRITE;
++  For further details on postcopy, see ``VHOST_USER_SET_MEM_TABLE``.
-+            }
++  They apply to ``VHOST_USER_ADD_MEM_REG`` accordingly.
-+        } else {
++
-+            ret = -1;
+ ``VHOST_USER_REM_MEM_REG``
-+        }
+   :id: 38
-+        if (ret < 0) {
+   :equivalent ioctl: N/A
-+            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
+@@ -XXX,XX +XXX,XX @@ Master message types
-+                                   errp);
+   ``VHOST_USER_ADD_MEM_REG`` message, this message is used to set and
-+        }
+   update the memory tables of the slave device.
-         if (ret < 0) {
-             error_prepend(errp, "Failed to resize underlying file: ");
++  The memory region to be removed is identified by its guest address,
-             qcow2_free_clusters(bs, allocation_start,
++  user address and size. The mmap offset is ignored.
-diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
++
-index XXXXXXX..XXXXXXX 100644
++  No file descriptors SHOULD be passed in the ancillary data. For
---- a/tests/qemu-iotests/274.out
++  compatibility with existing incorrect implementations, the slave MAY
-+++ b/tests/qemu-iotests/274.out
++  accept messages with one file descriptor. If a file descriptor is
-@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184
++  passed, the slave MUST close it without using it otherwise.
-MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
++
+ ``VHOST_USER_SET_STATUS``
- [{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
+   :id: 39
--{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+   :equivalent ioctl: VHOST_VDPA_SET_STATUS
 +{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}]
  === preallocation=full ===
  Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336
 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
  [{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
 -{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}]
  === preallocation=off ===
  Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 --
-.25.3
+.35.1

-[PULL 15/15] qemu-storage-daemon: Fix non-string --object properties
+[PULL 03/13] libvhost-user: Fix extra vu_add/rem_mem_reg reply
-After processing the option string with the keyval parser, we get a
+Outside of postcopy mode, neither VHOST_USER_ADD_MEM_REG nor
-QDict that contains only strings. This QDict must be fed to a keyval
+VHOST_USER_REM_MEM_REG are supposed to send a reply unless explicitly
-visitor which converts the strings into the right data types.
+requested with the need_reply flag. Their current implementation always
 sends a reply, even if it isn't requested. This confuses the master
 because it will interpret the reply as a reply for the next message for
 which it actually expects a reply.
-qmp_object_add(), however, uses the normal QObject input visitor, which
+need_reply is already handled correctly by vu_dispatch(), so just don't
-expects a QDict where all properties already have the QType that matches
+send a reply in the non-postcopy part of the message handler for these
-the data type required by the QOM object type.
+two commands.
-Change the --object implementation in qemu-storage-daemon so that it
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-doesn't call qmp_object_add(), but calls user_creatable_add_dict()
+Message-Id: <20220407133657.155281-3-kwolf@redhat.com>
-directly instead and pass it a new keyval boolean that decides which
+Reviewed-by: Raphael Norwitz <raphael.norwitz@nutanix.com>
-visitor must be used.
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reported-by: Coiby Xu <coiby.xu@gmail.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/qom/object_interfaces.h | 6 +++++-
+ subprojects/libvhost-user/libvhost-user.c | 9 +++------
- qemu-storage-daemon.c           | 4 +---
+file changed, 3 insertions(+), 6 deletions(-)
  qom/object_interfaces.c         | 8 ++++++--
  qom/qom-qmp-cmds.c              | 2 +-
 files changed, 13 insertions(+), 7 deletions(-)
-diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
+diff --git a/subprojects/libvhost-user/libvhost-user.c b/subprojects/libvhost-user/libvhost-user.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qom/object_interfaces.h
+--- a/subprojects/libvhost-user/libvhost-user.c
-+++ b/include/qom/object_interfaces.h
++++ b/subprojects/libvhost-user/libvhost-user.c
-@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
+@@ -XXX,XX +XXX,XX @@ vu_add_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
- /**
-  * user_creatable_add_dict:
+         DPRINT("Successfully added new region\n");
-  * @qdict: the object definition
+         dev->nregions++;
-+ * @keyval: if true, use a keyval visitor for processing @qdict (i.e.
+-        vmsg_set_reply_u64(vmsg, 0);
-+ *          assume that all @qdict values are strings); otherwise, use
+-        return true;
-+ *          the normal QObject visitor (i.e. assume all @qdict values
++        return false;
-+ *          have the QType expected by the QOM object type)
+     }
   * @errp: if an error occurs, a pointer to an area to store the error
   *
   * Create an instance of the user creatable object that is defined by
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
   * ID from the key 'id'. The remaining entries in @qdict are used to
   * initialize the object properties.
   */
 -void user_creatable_add_dict(QDict *qdict, Error **errp);
 +void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp);
  /**
   * user_creatable_add_opts:
 diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-storage-daemon.c
 +++ b/qemu-storage-daemon.c
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                  QemuOpts *opts;
                  const char *type;
                  QDict *args;
 -                QObject *ret_data = NULL;
                  /* FIXME The keyval parser rejects 'help' arguments, so we must
                   * unconditionall try QemuOpts first. */
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                  qemu_opts_del(opts);
                  args = keyval_parse(optarg, "qom-type", &error_fatal);
 -                qmp_object_add(args, &ret_data, &error_fatal);
 +                user_creatable_add_dict(args, true, &error_fatal);
                  qobject_unref(args);
 -                qobject_unref(ret_data);
                  break;
              }
          default:
 diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/object_interfaces.c
 +++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@ out:
      return obj;
  }
--void user_creatable_add_dict(QDict *qdict, Error **errp)
+@@ -XXX,XX +XXX,XX @@ vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
-+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)
+         }
  {
      Visitor *v;
      Object *obj;
@@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp)
      }
-     qdict_del(qdict, "id");
+-    if (found) {
--    v = qobject_input_visitor_new(QOBJECT(qdict));
+-        vmsg_set_reply_u64(vmsg, 0);
-+    if (keyval) {
+-    } else {
-+        v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
++    if (!found) {
-+    } else {
+         vu_panic(dev, "Specified region not found\n");
 +        v = qobject_input_visitor_new(QOBJECT(qdict));
 +    }
      obj = user_creatable_add_type(type, id, qdict, v, errp);
      visit_free(v);
      object_unref(obj);
 diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/qom-qmp-cmds.c
 +++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
          qobject_unref(pdict);
      }
--    user_creatable_add_dict(qdict, errp);
+     close(vmsg->fds[0]);
-+    user_creatable_add_dict(qdict, false, errp);
 -    return true;
 +    return false;
  }
- void qmp_object_del(const char *id, Error **errp)
+ static bool
 --
-.25.3
+.35.1

-[PULL 03/15] block: Add flags to BlockDriver.bdrv_co_truncate()
+[PULL 04/13] vhost-user: Don't pass file descriptor for VHOST_USER_REM_MEM_REG
-This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate()
+The spec clarifies now that QEMU should not send a file descriptor in a
-driver callbacks, and a supported_truncate_flags field in
+request to remove a memory region. Change it accordingly.
 BlockDriverState that allows drivers to advertise support for request
 flags in the context of truncate.
-For now, we always pass 0 and no drivers declare support for any flag.
+For libvhost-user, this is a bug fix that makes it compatible with
 rust-vmm's implementation that doesn't send a file descriptor. Keep
 accepting, but ignoring a file descriptor for compatibility with older
 QEMU versions.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20220407133657.155281-4-kwolf@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+Reviewed-by: Raphael Norwitz <raphael.norwitz@nutanix.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-Id: <20200424125448.63318-2-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/block_int.h   | 10 +++++++++-
+ hw/virtio/vhost-user.c                    | 2 +-
- block/crypto.c              |  3 ++-
+ subprojects/libvhost-user/libvhost-user.c | 8 ++++----
- block/file-posix.c          |  2 +-
+files changed, 5 insertions(+), 5 deletions(-)
  block/file-win32.c          |  2 +-
  block/gluster.c             |  1 +
  block/io.c                  |  8 +++++++-
  block/iscsi.c               |  2 +-
  block/nfs.c                 |  3 ++-
  block/qcow2.c               |  2 +-
  block/qed.c                 |  1 +
  block/raw-format.c          |  2 +-
  block/rbd.c                 |  1 +
  block/sheepdog.c            |  4 ++--
  block/ssh.c                 |  2 +-
  tests/test-block-iothread.c |  3 ++-
 files changed, 33 insertions(+), 13 deletions(-)
-diff --git a/include/block/block_int.h b/include/block/block_int.h
+diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block_int.h
+--- a/hw/virtio/vhost-user.c
-+++ b/include/block/block_int.h
++++ b/hw/virtio/vhost-user.c
-@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
+@@ -XXX,XX +XXX,XX @@ static int send_remove_regions(struct vhost_dev *dev,
-      */
+             vhost_user_fill_msg_region(&region_buffer, shadow_reg, 0);
-     int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,
+             msg->payload.mem_reg.region = region_buffer;
-                                          bool exact, PreallocMode prealloc,
--                                         Error **errp);
+-            ret = vhost_user_write(dev, msg, &fd, 1);
-+                                         BdrvRequestFlags flags, Error **errp);
++            ret = vhost_user_write(dev, msg, NULL, 0);
+             if (ret < 0) {
-     int64_t (*bdrv_getlength)(BlockDriverState *bs);
+                 return ret;
-     bool has_variable_length;
+             }
-@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
+diff --git a/subprojects/libvhost-user/libvhost-user.c b/subprojects/libvhost-user/libvhost-user.c
      /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA,
       * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */
      unsigned int supported_zero_flags;
 +    /*
 +     * Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE).
 +     *
 +     * If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure
 +     * that any added space reads as all zeros. If this can't be guaranteed,
 +     * the operation must fail.
 +     */
 +    unsigned int supported_truncate_flags;
      /* the following member gives a name to every node on the bs graph. */
      char node_name[32];
 diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/crypto.c
+--- a/subprojects/libvhost-user/libvhost-user.c
-+++ b/block/crypto.c
++++ b/subprojects/libvhost-user/libvhost-user.c
-@@ -XXX,XX +XXX,XX @@ static int block_crypto_co_create_generic(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
+     int i;
- static int coroutine_fn
+     bool found = false;
- block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
--                         PreallocMode prealloc, Error **errp)
+-    if (vmsg->fd_num != 1) {
-+                         PreallocMode prealloc, BdrvRequestFlags flags,
++    if (vmsg->fd_num > 1) {
-+                         Error **errp)
+         vmsg_close_fds(vmsg);
- {
+-        vu_panic(dev, "VHOST_USER_REM_MEM_REG received %d fds - only 1 fd "
-     BlockCrypto *crypto = bs->opaque;
++        vu_panic(dev, "VHOST_USER_REM_MEM_REG received %d fds - at most 1 fd "
-     uint64_t payload_offset =
+                       "should be sent for this message type", vmsg->fd_num);
-diff --git a/block/file-posix.c b/block/file-posix.c
+         return false;
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-posix.c
 +++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
  static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
 -                                        Error **errp)
 +                                        BdrvRequestFlags flags, Error **errp)
  {
      BDRVRawState *s = bs->opaque;
      struct stat st;
 diff --git a/block/file-win32.c b/block/file-win32.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-win32.c
 +++ b/block/file-win32.c
@@ -XXX,XX +XXX,XX @@ static void raw_close(BlockDriverState *bs)
  static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
 -                                        Error **errp)
 +                                        BdrvRequestFlags flags, Error **errp)
  {
      BDRVRawState *s = bs->opaque;
      LONG low, high;
 diff --git a/block/gluster.c b/block/gluster.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/gluster.c
 +++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,
                                                   int64_t offset,
                                                   bool exact,
                                                   PreallocMode prealloc,
 +                                                 BdrvRequestFlags flags,
                                                   Error **errp)
  {
      BDRVGlusterState *s = bs->opaque;
 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 coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
      BlockDriverState *bs = child->bs;
      BlockDriver *drv = bs->drv;
      BdrvTrackedRequest req;
 +    BdrvRequestFlags flags = 0;
      int64_t old_size, new_bytes;
      int ret;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
      }
-     if (drv->bdrv_co_truncate) {
+     if (vmsg->size < VHOST_USER_MEM_REG_SIZE) {
--        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, errp);
+-        close(vmsg->fds[0]);
-+        if (flags & ~bs->supported_truncate_flags) {
++        vmsg_close_fds(vmsg);
-+            error_setg(errp, "Block driver does not support requested flags");
+         vu_panic(dev, "VHOST_USER_REM_MEM_REG requires a message size of at "
-+            ret = -ENOTSUP;
+                       "least %d bytes and only %d bytes were received",
-+            goto out;
+                       VHOST_USER_MEM_REG_SIZE, vmsg->size);
-+        }
+@@ -XXX,XX +XXX,XX @@ vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
-+        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
+         vu_panic(dev, "Specified region not found\n");
-     } else if (bs->file && drv->is_filter) {
+     }
-         ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
-     } else {
+-    close(vmsg->fds[0]);
-diff --git a/block/iscsi.c b/block/iscsi.c
++    vmsg_close_fds(vmsg);
-index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
+     return false;
 +++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void iscsi_reopen_commit(BDRVReopenState *reopen_state)
  static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
                                            bool exact, PreallocMode prealloc,
 -                                          Error **errp)
 +                                          BdrvRequestFlags flags, Error **errp)
  {
      IscsiLun *iscsilun = bs->opaque;
      int64_t cur_length;
 diff --git a/block/nfs.c b/block/nfs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nfs.c
 +++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
  static int coroutine_fn
  nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 -                     PreallocMode prealloc, Error **errp)
 +                     PreallocMode prealloc, BdrvRequestFlags flags,
 +                     Error **errp)
  {
      NFSClient *client = bs->opaque;
      int ret;
 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 @@ fail:
  static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
                                            bool exact, PreallocMode prealloc,
 -                                          Error **errp)
 +                                          BdrvRequestFlags flags, Error **errp)
  {
      BDRVQcow2State *s = bs->opaque;
      uint64_t old_length;
 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_truncate(BlockDriverState *bs,
                                               int64_t offset,
                                               bool exact,
                                               PreallocMode prealloc,
 +                                             BdrvRequestFlags flags,
                                               Error **errp)
  {
      BDRVQEDState *s = bs->opaque;
 diff --git a/block/raw-format.c b/block/raw-format.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/raw-format.c
 +++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
  static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
 -                                        Error **errp)
 +                                        BdrvRequestFlags flags, Error **errp)
  {
      BDRVRawState *s = bs->opaque;
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs,
                                               int64_t offset,
                                               bool exact,
                                               PreallocMode prealloc,
 +                                             BdrvRequestFlags flags,
                                               Error **errp)
  {
      int r;
 diff --git a/block/sheepdog.c b/block/sheepdog.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/sheepdog.c
 +++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static int64_t sd_getlength(BlockDriverState *bs)
  static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
 -                                       Error **errp)
 +                                       BdrvRequestFlags flags, Error **errp)
  {
      BDRVSheepdogState *s = bs->opaque;
      int ret, fd;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
      assert(!flags);
      if (offset > s->inode.vdi_size) {
 -        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, NULL);
 +        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, 0, NULL);
          if (ret < 0) {
              return ret;
          }
 diff --git a/block/ssh.c b/block/ssh.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/ssh.c
 +++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static int64_t ssh_getlength(BlockDriverState *bs)
  static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
 -                                        Error **errp)
 +                                        BdrvRequestFlags flags, Error **errp)
  {
      BDRVSSHState *s = bs->opaque;
 diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-block-iothread.c
 +++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
  static int coroutine_fn
  bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 -                      PreallocMode prealloc, Error **errp)
 +                      PreallocMode prealloc, BdrvRequestFlags flags,
 +                      Error **errp)
  {
      return 0;
  }
 --
-.25.3
+.35.1

-[PULL 05/15] block-backend: Add flags to blk_truncate()
+[PULL 05/13] block: Classify bdrv_get_flags() as I/O function
-Now that node level interface bdrv_truncate() supports passing request
+From: Hanna Reitz <hreitz@redhat.com>
 flags to the block driver, expose this on the BlockBackend level, too.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+This function is safe to call in an I/O context, and qcow2_do_open()
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+does so (invoked in an I/O context by qcow2_co_invalidate_cache()).
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20200424125448.63318-4-kwolf@redhat.com>
+Message-Id: <20220427114057.36651-2-hreitz@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/sysemu/block-backend.h | 2 +-
+ include/block/block-global-state.h | 1 -
- block.c                        | 3 ++-
+ include/block/block-io.h           | 1 +
- block/block-backend.c          | 4 ++--
+ block.c                            | 2 +-
- block/commit.c                 | 4 ++--
+files changed, 2 insertions(+), 2 deletions(-)
  block/crypto.c                 | 2 +-
  block/mirror.c                 | 2 +-
  block/qcow2.c                  | 4 ++--
  block/qed.c                    | 2 +-
  block/vdi.c                    | 2 +-
  block/vhdx.c                   | 4 ++--
  block/vmdk.c                   | 6 +++---
  block/vpc.c                    | 2 +-
  blockdev.c                     | 2 +-
  qemu-img.c                     | 2 +-
  qemu-io-cmds.c                 | 2 +-
 files changed, 22 insertions(+), 21 deletions(-)
-diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
+diff --git a/include/block/block-global-state.h b/include/block/block-global-state.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/sysemu/block-backend.h
+--- a/include/block/block-global-state.h
-+++ b/include/sysemu/block-backend.h
++++ b/include/block/block-global-state.h
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
+@@ -XXX,XX +XXX,XX @@ void bdrv_next_cleanup(BdrvNextIterator *it);
- int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
+ BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
-                           int bytes);
+ void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
- int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
+                          void *opaque, bool read_only);
--                 PreallocMode prealloc, Error **errp);
+-int bdrv_get_flags(BlockDriverState *bs);
-+                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
+ char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp);
- int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes);
+ char *bdrv_dirname(BlockDriverState *bs, Error **errp);
- int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
-                      int64_t pos, int size);
+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_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
  bool bdrv_is_read_only(BlockDriverState *bs);
  bool bdrv_is_writable(BlockDriverState *bs);
  bool bdrv_is_sg(BlockDriverState *bs);
 +int bdrv_get_flags(BlockDriverState *bs);
  bool bdrv_is_inserted(BlockDriverState *bs);
  void bdrv_lock_medium(BlockDriverState *bs, bool locked);
  void bdrv_eject(BlockDriverState *bs, bool eject_flag);
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
+@@ -XXX,XX +XXX,XX @@ const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
-     int64_t size;
-     int ret;
+ int bdrv_get_flags(BlockDriverState *bs)
+ {
--    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
+-    GLOBAL_STATE_CODE();
-+    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
++    IO_CODE();
-+                       &local_err);
+     return bs->open_flags;
      if (ret < 0 && ret != -ENOTSUP) {
          error_propagate(errp, local_err);
          return ret;
 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_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
  }
- int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
--                 PreallocMode prealloc, Error **errp)
-+                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
- {
-     if (!blk_is_available(blk)) {
-         error_setg(errp, "No medium inserted");
-         return -ENOMEDIUM;
-     }
--    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
-+    return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
- }
- int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
-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 @@ static int coroutine_fn commit_run(Job *job, Error **errp)
-     }
-     if (base_len < len) {
--        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, NULL);
-+        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL);
-         if (ret) {
-             goto out;
-         }
-@@ -XXX,XX +XXX,XX @@ int bdrv_commit(BlockDriverState *bs)
-      * grow the backing file image if possible.  If not possible,
-      * we must return an error */
-     if (length > backing_length) {
--        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF,
-+        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0,
-                            &local_err);
-         if (ret < 0) {
-             error_report_err(local_err);
-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_init_func(QCryptoBlock *block,
-      * which will be used by the crypto header
-      */
-     return blk_truncate(data->blk, data->size + headerlen, false,
--                        data->prealloc, errp);
-+                        data->prealloc, 0, errp);
- }
-diff --git a/block/mirror.c b/block/mirror.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/mirror.c
-+++ b/block/mirror.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
-         if (s->bdev_length > base_length) {
-             ret = blk_truncate(s->target, s->bdev_length, false,
--                               PREALLOC_MODE_OFF, NULL);
-+                               PREALLOC_MODE_OFF, 0, NULL);
-             if (ret < 0) {
-                 goto immediate_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)
-     /* Okay, now that we have a valid image, let's give it the right size */
-     ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
--                       errp);
-+                       0, errp);
-     if (ret < 0) {
-         error_prepend(errp, "Could not resize image: ");
-         goto out;
-@@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
-          * Amending image options should ensure that the image has
-          * exactly the given new values, so pass exact=true here.
-          */
--        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp);
-+        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
-         blk_unref(blk);
-         if (ret < 0) {
-             return ret;
-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,
-      * The QED format associates file length with allocation status,
-      * so a new file (which is empty) must have a length of 0.
-      */
--    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, errp);
-+    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, 0, errp);
-     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,
-     if (image_type == VDI_TYPE_STATIC) {
-         ret = blk_truncate(blk, offset + blocks * block_size, false,
--                           PREALLOC_MODE_OFF, errp);
-+                           PREALLOC_MODE_OFF, 0, errp);
-         if (ret < 0) {
-             error_prepend(errp, "Failed to statically allocate file");
-             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_bat(BlockBackend *blk, BDRVVHDXState *s,
-         /* All zeroes, so we can just extend the file - the end of the BAT
-          * is the furthest thing we have written yet */
-         ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
--                           errp);
-+                           0, errp);
-         if (ret < 0) {
-             goto exit;
-         }
-     } else if (type == VHDX_TYPE_FIXED) {
-         ret = blk_truncate(blk, data_file_offset + image_size, false,
--                           PREALLOC_MODE_OFF, errp);
-+                           PREALLOC_MODE_OFF, 0, errp);
-         if (ret < 0) {
-             goto 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,
-     int gd_buf_size;
-     if (flat) {
--        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, errp);
-+        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
-         goto exit;
-     }
-     magic = cpu_to_be32(VMDK4_MAGIC);
-@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
-     }
-     ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
--                       PREALLOC_MODE_OFF, errp);
-+                       PREALLOC_MODE_OFF, 0, errp);
-     if (ret < 0) {
-         goto exit;
-     }
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size,
-     /* bdrv_pwrite write padding zeros to align to sector, we don't need that
-      * for description file */
-     if (desc_offset == 0) {
--        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, errp);
-+        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, 0, errp);
-         if (ret < 0) {
-             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_fixed_disk(BlockBackend *blk, uint8_t *buf,
-     /* Add footer to total size */
-     total_size += HEADER_SIZE;
--    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, errp);
-+    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
-     if (ret < 0) {
-         return ret;
-     }
-diff --git a/blockdev.c b/blockdev.c
-index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
-+++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
-     }
-     bdrv_drained_begin(bs);
--    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp);
-+    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp);
-     bdrv_drained_end(bs);
- out:
-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_resize(int argc, char **argv)
-      * resizing, so pass @exact=true.  It is of no use to report
-      * success when the image has not actually been resized.
-      */
--    ret = blk_truncate(blk, total_size, true, prealloc, &err);
-+    ret = blk_truncate(blk, total_size, true, prealloc, 0, &err);
-     if (!ret) {
-         qprintf(quiet, "Image resized.\n");
-     } else {
-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 truncate_f(BlockBackend *blk, int argc, char **argv)
-      * exact=true.  It is better to err on the "emit more errors" side
-      * than to be overly permissive.
-      */
--    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, &local_err);
-+    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, 0, &local_err);
-     if (ret < 0) {
-         error_report_err(local_err);
-         return ret;
 --
-.25.3
+.35.1

-[PULL 06/15] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
+[PULL 06/13] qcow2: Do not reopen data_file in invalidate_cache
-If BDRV_REQ_ZERO_WRITE is set and we're extending the image, calling
+From: Hanna Reitz <hreitz@redhat.com>
-qcow2_cluster_zeroize() with flags=0 does the right thing: It doesn't
-undo any previous preallocation, but just adds the zero flag to all
+qcow2_co_invalidate_cache() closes and opens the qcow2 file, by calling
-relevant L2 entries. If an external data file is in use, a write_zeroes
+qcow2_close() and qcow2_do_open().  These two functions must thus be
-request to the data file is made instead.
+usable from both a global-state and an I/O context.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+As they are, they are not safe to call in an I/O context, because they
-Message-Id: <20200424125448.63318-5-kwolf@redhat.com>
+use bdrv_unref_child() and bdrv_open_child() to close/open the data_file
 child, respectively, both of which are global-state functions.  When
 used from qcow2_co_invalidate_cache(), we do not need to close/open the
 data_file child, though (we do not do this for bs->file or bs->backing
 either), and so we should skip it in the qcow2_co_invalidate_cache()
 path.
 To do so, add a parameter to qcow2_do_open() and qcow2_close() to make
 them skip handling s->data_file, and have qcow2_co_invalidate_cache()
 exempt it from the memset() on the BDRVQcow2State.
 (Note that the QED driver similarly closes/opens the QED image by
 invoking bdrv_qed_close()+bdrv_qed_do_open(), but both functions seem
 safe to use in an I/O context.)
 Fixes: https://gitlab.com/qemu-project/qemu/-/issues/945
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20220427114057.36651-3-hreitz@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2-cluster.c |  2 +-
+ block/qcow2.c | 104 ++++++++++++++++++++++++++++++--------------------
- block/qcow2.c         | 34 ++++++++++++++++++++++++++++++++++
+file changed, 62 insertions(+), 42 deletions(-)
-files changed, 35 insertions(+), 1 deletion(-)
 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_cluster_zeroize(BlockDriverState *bs, uint64_t offset,
      /* Caller must pass aligned values, except at image end */
      assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
      assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
 -           end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
 +           end_offset >= bs->total_sectors << BDRV_SECTOR_BITS);
      /* The zero flag is only supported by version 3 and newer */
      if (s->qcow_version < 3) {
 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 validate_compression_type(BDRVQcow2State *s, Error **errp)
+ /* Called with s->lock held.  */
+ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+-                                      int flags, Error **errp)
++                                      int flags, bool open_data_file,
++                                      Error **errp)
+ {
+     ERRP_GUARD();
+     BDRVQcow2State *s = bs->opaque;
 @@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+         goto fail;
-     bs->supported_zero_flags = header.version >= 3 ?
+     }
-                                BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
-+    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
+-    /* Open external data file */
+-    s->data_file = bdrv_open_child(NULL, options, "data-file", bs,
-     /* Repair image if dirty */
+-                                   &child_of_bds, BDRV_CHILD_DATA,
-     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
+-                                   true, errp);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+-    if (*errp) {
-         g_assert_not_reached();
+-        ret = -EINVAL;
-     }
+-        goto fail;
+-    }
-+    if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
++    if (open_data_file) {
-+        uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
++        /* Open external data file */
-+
++        s->data_file = bdrv_open_child(NULL, options, "data-file", bs,
-+        /*
++                                       &child_of_bds, BDRV_CHILD_DATA,
-+         * Use zero clusters as much as we can. qcow2_cluster_zeroize()
++                                       true, errp);
-+         * requires a cluster-aligned start. The end may be unaligned if it is
++        if (*errp) {
-+         * at the end of the image (which it is here).
++            ret = -EINVAL;
 +         */
 +        ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
 +        if (ret < 0) {
 +            error_setg_errno(errp, -ret, "Failed to zero out new clusters");
 +            goto fail;
 +        }
-+
-+        /* Write explicit zeros for the unaligned head */
+-    if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
-+        if (zero_start > old_length) {
+-        if (!s->data_file && s->image_data_file) {
-+            uint64_t len = zero_start - old_length;
+-            s->data_file = bdrv_open_child(s->image_data_file, options,
-+            uint8_t *buf = qemu_blockalign0(bs, len);
+-                                           "data-file", bs, &child_of_bds,
-+            QEMUIOVector qiov;
+-                                           BDRV_CHILD_DATA, false, errp);
-+            qemu_iovec_init_buf(&qiov, buf, len);
++        if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
-+
++            if (!s->data_file && s->image_data_file) {
-+            qemu_co_mutex_unlock(&s->lock);
++                s->data_file = bdrv_open_child(s->image_data_file, options,
-+            ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
++                                               "data-file", bs, &child_of_bds,
-+            qemu_co_mutex_lock(&s->lock);
++                                               BDRV_CHILD_DATA, false, errp);
-+
++                if (!s->data_file) {
-+            qemu_vfree(buf);
++                    ret = -EINVAL;
-+            if (ret < 0) {
++                    goto fail;
-+                error_setg_errno(errp, -ret, "Failed to zero out the new area");
++                }
 +            }
              if (!s->data_file) {
 +                error_setg(errp, "'data-file' is required for this image");
                  ret = -EINVAL;
                  goto fail;
              }
 -        }
 -        if (!s->data_file) {
 -            error_setg(errp, "'data-file' is required for this image");
 -            ret = -EINVAL;
 -            goto fail;
 -        }
 -        /* No data here */
 -        bs->file->role &= ~BDRV_CHILD_DATA;
 +            /* No data here */
 +            bs->file->role &= ~BDRV_CHILD_DATA;
 -        /* Must succeed because we have given up permissions if anything */
 -        bdrv_child_refresh_perms(bs, bs->file, &error_abort);
 -    } else {
 -        if (s->data_file) {
 -            error_setg(errp, "'data-file' can only be set for images with an "
 -                             "external data file");
 -            ret = -EINVAL;
 -            goto fail;
 -        }
 +            /* Must succeed because we have given up permissions if anything */
 +            bdrv_child_refresh_perms(bs, bs->file, &error_abort);
 +        } else {
 +            if (s->data_file) {
 +                error_setg(errp, "'data-file' can only be set for images with "
 +                                 "an external data file");
 +                ret = -EINVAL;
 +                goto fail;
 +            }
-+        }
-+    }
+-        s->data_file = bs->file;
 +            s->data_file = bs->file;
 -        if (data_file_is_raw(bs)) {
 -            error_setg(errp, "data-file-raw requires a data file");
 -            ret = -EINVAL;
 -            goto fail;
 +            if (data_file_is_raw(bs)) {
 +                error_setg(errp, "data-file-raw requires a data file");
 +                ret = -EINVAL;
 +                goto fail;
 +            }
          }
      }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
   fail:
      g_free(s->image_data_file);
 -    if (has_data_file(bs)) {
 +    if (open_data_file && has_data_file(bs)) {
          bdrv_unref_child(bs, s->data_file);
          s->data_file = NULL;
      }
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qcow2_open_entry(void *opaque)
      BDRVQcow2State *s = qoc->bs->opaque;
      qemu_co_mutex_lock(&s->lock);
 -    qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, qoc->errp);
 +    qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, true,
 +                             qoc->errp);
      qemu_co_mutex_unlock(&s->lock);
  }
@@ -XXX,XX +XXX,XX @@ static int qcow2_inactivate(BlockDriverState *bs)
      return result;
  }
 -static void qcow2_close(BlockDriverState *bs)
 +static void qcow2_do_close(BlockDriverState *bs, bool close_data_file)
  {
      BDRVQcow2State *s = bs->opaque;
      qemu_vfree(s->l1_table);
@@ -XXX,XX +XXX,XX @@ static void qcow2_close(BlockDriverState *bs)
      g_free(s->image_backing_file);
      g_free(s->image_backing_format);
 -    if (has_data_file(bs)) {
 +    if (close_data_file && has_data_file(bs)) {
          bdrv_unref_child(bs, s->data_file);
          s->data_file = NULL;
      }
@@ -XXX,XX +XXX,XX @@ static void qcow2_close(BlockDriverState *bs)
      qcow2_free_snapshots(bs);
  }
 +static void qcow2_close(BlockDriverState *bs)
 +{
 +    qcow2_do_close(bs, true);
 +}
 +
-     if (prealloc != PREALLOC_MODE_OFF) {
+ static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
-         /* Flush metadata before actually changing the image size */
+                                                    Error **errp)
-         ret = qcow2_write_caches(bs);
+ {
      ERRP_GUARD();
      BDRVQcow2State *s = bs->opaque;
 +    BdrvChild *data_file;
      int flags = s->flags;
      QCryptoBlock *crypto = NULL;
      QDict *options;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
      crypto = s->crypto;
      s->crypto = NULL;
 -    qcow2_close(bs);
 +    /*
 +     * Do not reopen s->data_file (i.e., have qcow2_do_close() not close it,
 +     * and then prevent qcow2_do_open() from opening it), because this function
 +     * runs in the I/O path and as such we must not invoke global-state
 +     * functions like bdrv_unref_child() and bdrv_open_child().
 +     */
 +    qcow2_do_close(bs, false);
 +
 +    data_file = s->data_file;
      memset(s, 0, sizeof(BDRVQcow2State));
 +    s->data_file = data_file;
 +
      options = qdict_clone_shallow(bs->options);
      flags &= ~BDRV_O_INACTIVE;
      qemu_co_mutex_lock(&s->lock);
 -    ret = qcow2_do_open(bs, options, flags, errp);
 +    ret = qcow2_do_open(bs, options, flags, false, errp);
      qemu_co_mutex_unlock(&s->lock);
      qobject_unref(options);
      if (ret < 0) {
 --
-.25.3
+.35.1

-[PULL 01/15] qcow2: Add incompatibility note between backing files and raw external data files
+[PULL 07/13] Revert "main-loop: Disable GLOBAL_STATE_CODE() assertions"
-From: Alberto Garcia <berto@igalia.com>
+From: Hanna Reitz <hreitz@redhat.com>
-Backing files and raw external data files are mutually exclusive.
+This reverts commit b1c073490553f80594b903ceedfc7c1aef6b1b19.  (We
-The documentation of the raw external data bit (in autoclear_features)
+wanted to do so once the 7.1 tree opens, which has happened.  The issue
-already indicates that, but we should also mention it on the other
+reported in https://gitlab.com/qemu-project/qemu/-/issues/945 should be
-side.
+fixed by the preceding patches.)
-Suggested-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Message-Id: <20220427114057.36651-4-hreitz@redhat.com>
 Message-Id: <20200410121816.8334-1-berto@igalia.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- docs/interop/qcow2.txt | 3 +++
+ include/qemu/main-loop.h | 3 +--
-file changed, 3 insertions(+)
+file changed, 1 insertion(+), 2 deletions(-)
-diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
+diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
 index XXXXXXX..XXXXXXX 100644
---- a/docs/interop/qcow2.txt
+--- a/include/qemu/main-loop.h
-+++ b/docs/interop/qcow2.txt
++++ b/include/qemu/main-loop.h
-@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
+@@ -XXX,XX +XXX,XX @@ bool qemu_in_main_thread(void);
-                     is stored (NB: The string is not null terminated). 0 if the
+ #else
-                     image doesn't have a backing file.
+ #define GLOBAL_STATE_CODE()                                         \
+     do {                                                            \
-+                    Note: backing files are incompatible with raw external data
+-        /* FIXME: Re-enable after 7.0 release */                    \
-+                    files (auto-clear feature bit 1).
+-        /* assert(qemu_in_main_thread()); */                        \
-+
++        assert(qemu_in_main_thread());                              \
-- 19:   backing_file_size
+     } while (0)
-                     Length of the backing file name in bytes. Must not be
+ #endif /* CONFIG_COCOA */
-                     longer than 1023 bytes. Undefined if the image doesn't have
 --
-.25.3
+.35.1

-[PULL 02/15] qemu-iotests: allow qcow2 external discarded clusters to contain stale data
+Deleted patch
-From: Paolo Bonzini <pbonzini@redhat.com>
-Test 244 checks the expected behavior of qcow2 external data files
-with respect to zero and discarded clusters.  Filesystems however
-are free to ignore discard requests, and this seems to be the
-case for overlayfs.  Relax the tests to skip checks on the
-external data file for discarded areas, which implies not using
-qemu-img compare in the data_file_raw=on case.
-This fixes docker tests on RHEL8.
-Cc: Kevin Wolf <kwolf@redhat.com>
-Cc: qemu-block@nongnu.org
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Message-Id: <20200409191006.24429-1-pbonzini@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/244     | 10 ++++++++--
- tests/qemu-iotests/244.out |  9 ++++++---
-files changed, 14 insertions(+), 5 deletions(-)
-diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/244
-+++ b/tests/qemu-iotests/244
-@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
- echo
- $QEMU_IO -c 'read -P 0 0 1M' \
-          -c 'read -P 0x11 1M 1M' \
--         -c 'read -P 0 2M 2M' \
-          -c 'read -P 0x11 4M 1M' \
-          -c 'read -P 0 5M 1M' \
-          -f raw "$TEST_IMG.data" |
-@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
-          -f $IMGFMT "$TEST_IMG" |
-          _filter_qemu_io
-+# Discarded clusters are only marked as such in the qcow2 metadata, but
-+# they can contain stale data in the external data file.  Instead, zero
-+# clusters must be zeroed in the external data file too.
- echo
--$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG.data"
-+$QEMU_IO -c 'read -P 0 0 1M' \
-+         -c 'read -P 0x11 1M 1M' \
-+         -c 'read -P 0 3M 3M' \
-+         -f raw "$TEST_IMG".data |
-+         _filter_qemu_io
- echo -n "qcow2 file size after I/O: "
- du -b $TEST_IMG | cut -f1
-diff --git a/tests/qemu-iotests/244.out b/tests/qemu-iotests/244.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/244.out
-+++ b/tests/qemu-iotests/244.out
-@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
-MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- read 1048576/1048576 bytes at offset 1048576
-MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--read 2097152/2097152 bytes at offset 2097152
--2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- read 1048576/1048576 bytes at offset 4194304
-MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- read 1048576/1048576 bytes at offset 5242880
-@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 1048576
- read 4194304/4194304 bytes at offset 2097152
-MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--Images are identical.
-+read 1048576/1048576 bytes at offset 0
-+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+read 1048576/1048576 bytes at offset 1048576
-+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+read 3145728/3145728 bytes at offset 3145728
-+3 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- qcow2 file size after I/O: 327680
- === bdrv_co_block_status test for file and offset=0 ===
---
-.25.3

-[PULL 10/15] iotests: Filter testfiles out in filter_img_info()
+[PULL 08/13] iotests: Add regression test for issue 945
-We want to keep TEST_IMG for the full path of the main test image, but
+From: Hanna Reitz <hreitz@redhat.com>
 filter_testfiles() must be called for other test images before replacing
 other things like the image format because the test directory path could
 contain the format as a substring.
-Insert a filter_testfiles() call between both.
+Create a VM with a BDS in an iothread, add -incoming defer to the
 command line, and then export this BDS via NBD.  Doing so should not
 fail an assertion.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Message-Id: <20220427114057.36651-5-hreitz@redhat.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
-Message-Id: <20200424125448.63318-9-kwolf@redhat.com>
+Tested-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 5 +++--
+ .../tests/export-incoming-iothread            | 81 +++++++++++++++++++
-file changed, 3 insertions(+), 2 deletions(-)
+ .../tests/export-incoming-iothread.out        |  5 ++
 files changed, 86 insertions(+)
  create mode 100755 tests/qemu-iotests/tests/export-incoming-iothread
  create mode 100644 tests/qemu-iotests/tests/export-incoming-iothread.out
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
+diff --git a/tests/qemu-iotests/tests/export-incoming-iothread b/tests/qemu-iotests/tests/export-incoming-iothread
-index XXXXXXX..XXXXXXX 100644
+new file mode 100755
---- a/tests/qemu-iotests/iotests.py
+index XXXXXXX..XXXXXXX
-+++ b/tests/qemu-iotests/iotests.py
+--- /dev/null
-@@ -XXX,XX +XXX,XX @@ def filter_img_info(output, filename):
++++ b/tests/qemu-iotests/tests/export-incoming-iothread
-     for line in output.split('\n'):
+@@ -XXX,XX +XXX,XX @@
-         if 'disk size' in line or 'actual-size' in line:
++#!/usr/bin/env python3
-             continue
++# group: rw quick migration
--        line = line.replace(filename, 'TEST_IMG') \
++#
--                   .replace(imgfmt, 'IMGFMT')
++# Regression test for issue 945:
-+        line = line.replace(filename, 'TEST_IMG')
++# https://gitlab.com/qemu-project/qemu/-/issues/945
-+        line = filter_testfiles(line)
++# Test adding an export on top of an iothread-ed block device while in
-+        line = line.replace(imgfmt, 'IMGFMT')
++# -incoming defer.
-         line = re.sub('iters: [0-9]+', 'iters: XXX', line)
++#
-         line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
++# Copyright (C) 2022 Red Hat, Inc.
-         line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line)
++#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 +#
 +# This program is distributed in the hope that it will be useful,
 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
 +
 +import os
 +import iotests
 +from iotests import qemu_img_create
 +
 +
 +image_size = 1 * 1024 * 1024
 +test_img = os.path.join(iotests.test_dir, 'test.img')
 +node_name = 'node0'
 +iothread_id = 'iothr0'
 +
 +nbd_sock = os.path.join(iotests.sock_dir, 'nbd.sock')
 +
 +
 +class TestExportIncomingIothread(iotests.QMPTestCase):
 +    def setUp(self) -> None:
 +        qemu_img_create('-f', iotests.imgfmt, test_img, str(image_size))
 +
 +        self.vm = iotests.VM()
 +        self.vm.add_object(f'iothread,id={iothread_id}')
 +        self.vm.add_blockdev((
 +            f'driver={iotests.imgfmt}',
 +            f'node-name={node_name}',
 +            'file.driver=file',
 +            f'file.filename={test_img}'
 +        ))
 +        self.vm.add_incoming('defer')
 +        self.vm.launch()
 +
 +    def tearDown(self):
 +        self.vm.shutdown()
 +        os.remove(test_img)
 +
 +    def test_export_add(self):
 +        result = self.vm.qmp('nbd-server-start', {
 +            'addr': {
 +                'type': 'unix',
 +                'data': {
 +                    'path': nbd_sock
 +                }
 +            }
 +        })
 +        self.assert_qmp(result, 'return', {})
 +
 +        # Regression test for issue 945: This should not fail an assertion
 +        result = self.vm.qmp('block-export-add', {
 +            'type': 'nbd',
 +            'id': 'exp0',
 +            'node-name': node_name,
 +            'iothread': iothread_id
 +        })
 +        self.assert_qmp(result, 'return', {})
 +
 +
 +if __name__ == '__main__':
 +    iotests.main(supported_fmts=['generic'],
 +                 unsupported_fmts=['luks'], # Would need a secret
 +                 supported_protocols=['file'])
 diff --git a/tests/qemu-iotests/tests/export-incoming-iothread.out b/tests/qemu-iotests/tests/export-incoming-iothread.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/tests/export-incoming-iothread.out
@@ -XXX,XX +XXX,XX @@
 +.
 +----------------------------------------------------------------------
 +Ran 1 tests
 +
 +OK
 --
-.25.3
+.35.1

-[PULL 09/15] block: truncate: Don't make backing file data visible
+[PULL 09/13] block/vmdk: Fix reopening bs->file
-When extending the size of an image that has a backing file larger than
+From: Hanna Reitz <hreitz@redhat.com>
 its old size, make sure that the backing file data doesn't become
 visible in the guest, but the added area is properly zeroed out.
-Consider the following scenario where the overlay is shorter than its
+VMDK disk data is stored in extents, which may or may not be separate
-backing file:
+from bs->file.  VmdkExtent.file points to where they are stored.  Each
 that is stored in bs->file will simply reuse the exact pointer value of
 bs->file.
-    base.qcow2:     AAAAAAAA
+(That is why vmdk_free_extents() will unref VmdkExtent.file (e->file)
-    overlay.qcow2:  BBBB
+only if e->file != bs->file.)
-When resizing (extending) overlay.qcow2, the new blocks should not stay
+Reopen operations can change bs->file (they will replace the whole
-unallocated and make the additional As from base.qcow2 visible like
+BdrvChild object, not just the BDS stored in that BdrvChild), and then
-before this patch, but zeros should be read.
+we will need to change all .file pointers of all such VmdkExtents to
 point to the new BdrvChild.
-A similar case happens with the various variants of a commit job when an
+In vmdk_reopen_prepare(), we have to check which VmdkExtents are
-intermediate file is short (- for unallocated):
+affected, and in vmdk_reopen_commit(), we can modify them.  We have to
 split this because:
 - The new BdrvChild is created only after prepare, so we can change
   VmdkExtent.file only in commit
 - In commit, there no longer is any (valid) reference to the old
   BdrvChild object, so there would be nothing to compare VmdkExtent.file
   against to see whether it was equal to bs->file before reopening
   (There is BDRVReopenState.old_file_bs, but the old bs->file
   BdrvChild's .bs pointer will be NULL-ed when the new BdrvChild is
   created, and so we cannot compare VmdkExtent.file->bs against
   BDRVReopenState.old_file_bs)
-    base.qcow2:     A-A-AAAA
+Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-    mid.qcow2:      BB-B
+Message-Id: <20220314162719.65384-2-hreitz@redhat.com>
     top.qcow2:      C--C--C-
 After commit top.qcow2 to mid.qcow2, the following happens:
     mid.qcow2:      CB-C00C0 (correct result)
     mid.qcow2:      CB-C--C- (before this fix)
 Without the fix, blocks that previously read as zeros on top.qcow2
 suddenly turn into A.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Message-Id: <20200424125448.63318-8-kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/io.c | 25 +++++++++++++++++++++++++
+ block/vmdk.c | 56 +++++++++++++++++++++++++++++++++++++++++++++++++++-
-file changed, 25 insertions(+)
+file changed, 55 insertions(+), 1 deletion(-)
-diff --git a/block/io.c b/block/io.c
+diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/io.c
+--- a/block/vmdk.c
-+++ b/block/io.c
++++ b/block/vmdk.c
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
+@@ -XXX,XX +XXX,XX @@ typedef struct BDRVVmdkState {
-         goto out;
+     char *create_type;
-     }
+ } BDRVVmdkState;
 +typedef struct BDRVVmdkReopenState {
 +    bool *extents_using_bs_file;
 +} BDRVVmdkReopenState;
 +
  typedef struct VmdkMetaData {
      unsigned int l1_index;
      unsigned int l2_index;
@@ -XXX,XX +XXX,XX @@ static int vmdk_is_cid_valid(BlockDriverState *bs)
      return 1;
  }
 -/* We have nothing to do for VMDK reopen, stubs just return success */
  static int vmdk_reopen_prepare(BDRVReopenState *state,
                                 BlockReopenQueue *queue, Error **errp)
  {
 +    BDRVVmdkState *s;
 +    BDRVVmdkReopenState *rs;
 +    int i;
 +
      assert(state != NULL);
      assert(state->bs != NULL);
 +    assert(state->opaque == NULL);
 +
 +    s = state->bs->opaque;
 +
 +    rs = g_new0(BDRVVmdkReopenState, 1);
 +    state->opaque = rs;
 +
 +    /*
-+     * If the image has a backing file that is large enough that it would
++     * Check whether there are any extents stored in bs->file; if bs->file
-+     * provide data for the new area, we cannot leave it unallocated because
++     * changes, we will need to update their .file pointers to follow suit
 +     * then the backing file content would become visible. Instead, zero-fill
 +     * the new area.
 +     *
 +     * Note that if the image has a backing file, but was opened without the
 +     * backing file, taking care of keeping things consistent with that backing
 +     * file is the user's responsibility.
 +     */
-+    if (new_bytes && bs->backing) {
++    rs->extents_using_bs_file = g_new(bool, s->num_extents);
-+        int64_t backing_len;
++    for (i = 0; i < s->num_extents; i++) {
 +        rs->extents_using_bs_file[i] = s->extents[i].file == state->bs->file;
 +    }
 +
-+        backing_len = bdrv_getlength(backing_bs(bs));
+     return 0;
-+        if (backing_len < 0) {
+ }
-+            ret = backing_len;
-+            error_setg_errno(errp, -ret, "Could not get backing file size");
++static void vmdk_reopen_clean(BDRVReopenState *state)
-+            goto out;
++{
-+        }
++    BDRVVmdkReopenState *rs = state->opaque;
 +
-+        if (backing_len > old_size) {
++    g_free(rs->extents_using_bs_file);
-+            flags |= BDRV_REQ_ZERO_WRITE;
++    g_free(rs);
 +    state->opaque = NULL;
 +}
 +
 +static void vmdk_reopen_commit(BDRVReopenState *state)
 +{
 +    BDRVVmdkState *s = state->bs->opaque;
 +    BDRVVmdkReopenState *rs = state->opaque;
 +    int i;
 +
 +    for (i = 0; i < s->num_extents; i++) {
 +        if (rs->extents_using_bs_file[i]) {
 +            s->extents[i].file = state->bs->file;
 +        }
 +    }
 +
-     if (drv->bdrv_co_truncate) {
++    vmdk_reopen_clean(state);
-         if (flags & ~bs->supported_truncate_flags) {
++}
-             error_setg(errp, "Block driver does not support requested flags");
++
 +static void vmdk_reopen_abort(BDRVReopenState *state)
 +{
 +    vmdk_reopen_clean(state);
 +}
 +
  static int vmdk_parent_open(BlockDriverState *bs)
  {
      char *p_name;
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vmdk = {
      .bdrv_open                    = vmdk_open,
      .bdrv_co_check                = vmdk_co_check,
      .bdrv_reopen_prepare          = vmdk_reopen_prepare,
 +    .bdrv_reopen_commit           = vmdk_reopen_commit,
 +    .bdrv_reopen_abort            = vmdk_reopen_abort,
      .bdrv_child_perm              = bdrv_default_perms,
      .bdrv_co_preadv               = vmdk_co_preadv,
      .bdrv_co_pwritev              = vmdk_co_pwritev,
 --
-.25.3
+.35.1

-[PULL 11/15] iotests: Test committing to short backing file
+[PULL 10/13] iotests/reopen-file: Test reopening file child
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+From: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20200424125448.63318-10-kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+This should work for all format drivers that support reopening, so test
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+it.
 (This serves as a regression test for HEAD^: This test used to fail for
 VMDK before HEAD^.)
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20220314162719.65384-3-hreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/274     | 155 +++++++++++++++++++++
+ tests/qemu-iotests/tests/reopen-file     | 89 ++++++++++++++++++++++++
- tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/tests/reopen-file.out |  5 ++
- tests/qemu-iotests/group   |   1 +
+files changed, 94 insertions(+)
-files changed, 424 insertions(+)
+ create mode 100755 tests/qemu-iotests/tests/reopen-file
- create mode 100755 tests/qemu-iotests/274
+ create mode 100644 tests/qemu-iotests/tests/reopen-file.out
  create mode 100644 tests/qemu-iotests/274.out
-diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
+diff --git a/tests/qemu-iotests/tests/reopen-file b/tests/qemu-iotests/tests/reopen-file
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/274
++++ b/tests/qemu-iotests/tests/reopen-file
 @@ -XXX,XX +XXX,XX @@
 +#!/usr/bin/env python3
++# group: rw quick
 +#
-+# Copyright (C) 2019 Red Hat, Inc.
++# Test reopening a format driver's file child
 +#
 +# Copyright (C) 2022 Red Hat, Inc.
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 ...
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
-+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
-+#
-+# Some tests for short backing files and short overlays
 +
++import os
 +import iotests
-+
++from iotests import imgfmt, qemu_img_create, QMPTestCase
 +iotests.verify_image_format(supported_fmts=['qcow2'])
 +iotests.verify_platform(['linux'])
 +
 +size_short = 1 * 1024 * 1024
 +size_long = 2 * 1024 * 1024
 +size_diff = size_long - size_short
 +
 +def create_chain() -> None:
 +    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base,
 +                         str(size_long))
 +    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid,
 +                         str(size_short))
 +    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top,
 +                         str(size_long))
 +
 +    iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base)
 +
 +def create_vm() -> iotests.VM:
 +    vm = iotests.VM()
 +    vm.add_blockdev('file,filename=%s,node-name=base-file' % base)
 +    vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt)
 +    vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid)
 +    vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base'
 +                    % iotests.imgfmt)
 +    vm.add_drive(top, 'backing=mid,node-name=top')
 +    return vm
 +
 +with iotests.FilePath('base') as base, \
 +     iotests.FilePath('mid') as mid, \
 +     iotests.FilePath('top') as top:
 +
 +    iotests.log('== Commit tests ==')
 +
 +    create_chain()
 +
 +    iotests.log('=== Check visible data ===')
 +
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top)
 +
 +    iotests.log('=== Checking allocation status ===')
 +
 +    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
 +                        '-c', 'alloc %d %d' % (size_short, size_diff),
 +                        base)
 +
 +    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
 +                        '-c', 'alloc %d %d' % (size_short, size_diff),
 +                        mid)
 +
 +    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
 +                        '-c', 'alloc %d %d' % (size_short, size_diff),
 +                        top)
 +
 +    iotests.log('=== Checking map ===')
 +
 +    iotests.qemu_img_log('map', '--output=json', base)
 +    iotests.qemu_img_log('map', '--output=human', base)
 +    iotests.qemu_img_log('map', '--output=json', mid)
 +    iotests.qemu_img_log('map', '--output=human', mid)
 +    iotests.qemu_img_log('map', '--output=json', top)
 +    iotests.qemu_img_log('map', '--output=human', top)
 +
 +    iotests.log('=== Testing qemu-img commit (top -> mid) ===')
 +
 +    iotests.qemu_img_log('commit', top)
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +    iotests.log('=== Testing HMP commit (top -> mid) ===')
 +
 +    create_chain()
 +    with create_vm() as vm:
 +        vm.launch()
 +        vm.qmp_log('human-monitor-command', command_line='commit drive0')
 +
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +    iotests.log('=== Testing QMP active commit (top -> mid) ===')
 +
 +    create_chain()
 +    with create_vm() as vm:
 +        vm.launch()
 +        vm.qmp_log('block-commit', device='top', base_node='mid',
 +                   job_id='job0', auto_dismiss=False)
 +        vm.run_job('job0', wait=5)
 +
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +
-+    iotests.log('== Resize tests ==')
++image_size = 1 * 1024 * 1024
 +test_img = os.path.join(iotests.test_dir, 'test.img')
 +
-+    # Use different sizes for different allocation modes:
-+    #
-+    # We want to have at least one test where 32 bit truncation in the size of
-+    # the overlapping area becomes visible. This is covered by the
-+    # prealloc='off' case (1G to 6G is an overlap of 5G).
-+    #
-+    # However, we can only do this for modes that don't preallocate data
-+    # because otherwise we might run out of space on the test host.
-+    #
-+    # We also want to test some unaligned combinations.
-+    for (prealloc, base_size, top_size_old, top_size_new, off) in [
-+            ('off',       '6G',    '1G',   '8G',   '5G'),
-+            ('metadata', '32G',   '30G',  '33G',  '31G'),
-+            ('falloc',   '10M',    '5M',  '15M',   '9M'),
-+            ('full',     '16M',    '8M',  '12M',  '11M'),
-+            ('off',      '384k', '253k', '512k', '253k'),
-+            ('off',      '400k', '256k', '512k', '336k'),
-+            ('off',      '512k', '256k', '500k', '436k')]:
 +
-+        iotests.log('=== preallocation=%s ===' % prealloc)
++class TestReopenFile(QMPTestCase):
-+        iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size)
++    def setUp(self) -> None:
-+        iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top,
++        res = qemu_img_create('-f', imgfmt, test_img, str(image_size))
-+                             top_size_old)
++        assert res.returncode == 0
 +        iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base)
 +
-+        # After this, top_size_old to base_size should be allocated/zeroed.
++        # Add format driver node ('format') on top of the file ('file'), then
-+        #
++        # add another raw node ('raw') on top of 'file' so for the reopen we
-+        # In theory, leaving base_size to top_size_new unallocated would be
++        # can just switch from 'file' to 'raw'
-+        # correct, but in practice, if we zero out anything, we zero out
++        self.vm = iotests.VM()
-+        # everything up to top_size_new.
++        self.vm.add_blockdev(self.vm.qmp_to_opts({
-+        iotests.qemu_img_log('resize', '-f', iotests.imgfmt,
++            'driver': imgfmt,
-+                             '--preallocation', prealloc, top, top_size_new)
++            'node-name': 'format',
-+        iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top)
++            'file': {
-+        iotests.qemu_io_log('-c', 'map', top)
++                'driver': 'file',
-+        iotests.qemu_img_log('map', '--output=json', top)
++                'node-name': 'file',
-diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
++                'filename': test_img
 +            }
 +        }))
 +        self.vm.add_blockdev(self.vm.qmp_to_opts({
 +            'driver': 'raw',
 +            'node-name': 'raw',
 +            'file': 'file'
 +        }))
 +        self.vm.launch()
 +
 +    def tearDown(self) -> None:
 +        self.vm.shutdown()
 +        os.remove(test_img)
 +
 +        # Check if there was any qemu-io run that failed
 +        if 'Pattern verification failed' in self.vm.get_log():
 +            print('ERROR: Pattern verification failed:')
 +            print(self.vm.get_log())
 +            self.fail('qemu-io pattern verification failed')
 +
 +    def test_reopen_file(self) -> None:
 +        result = self.vm.qmp('blockdev-reopen', options=[{
 +            'driver': imgfmt,
 +            'node-name': 'format',
 +            'file': 'raw'
 +        }])
 +        self.assert_qmp(result, 'return', {})
 +
 +        # Do some I/O to the image to see whether it still works
 +        # (Pattern verification will be checked by tearDown())
 +        result = self.vm.qmp('human-monitor-command',
 +                             command_line='qemu-io format "write -P 42 0 64k"')
 +        self.assert_qmp(result, 'return', '')
 +
 +        result = self.vm.qmp('human-monitor-command',
 +                             command_line='qemu-io format "read -P 42 0 64k"')
 +        self.assert_qmp(result, 'return', '')
 +
 +
 +if __name__ == '__main__':
 +    # Must support creating images and reopen
 +    iotests.main(supported_fmts=['qcow', 'qcow2', 'qed', 'raw', 'vdi', 'vhdx',
 +                                 'vmdk', 'vpc'],
 +                 supported_protocols=['file'])
 diff --git a/tests/qemu-iotests/tests/reopen-file.out b/tests/qemu-iotests/tests/reopen-file.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/274.out
++++ b/tests/qemu-iotests/tests/reopen-file.out
 @@ -XXX,XX +XXX,XX @@
-+== Commit tests ==
++.
-+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++----------------------------------------------------------------------
 +Ran 1 tests
 +
-+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++OK
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 2097152/2097152 bytes at offset 0
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +=== Check visible data ===
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +=== Checking allocation status ===
 +1048576/1048576 bytes allocated at offset 0 bytes
 +1048576/1048576 bytes allocated at offset 1 MiB
 +
 +0/1048576 bytes allocated at offset 0 bytes
 +0/0 bytes allocated at offset 1 MiB
 +
 +0/1048576 bytes allocated at offset 0 bytes
 +0/1048576 bytes allocated at offset 1 MiB
 +
 +=== Checking map ===
 +[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": 327680}]
 +
 +Offset          Length          Mapped to       File
 +0               0x200000        0x50000         TEST_DIR/PID-base
 +
 +[{ "start": 0, "length": 1048576, "depth": 1, "zero": false, "data": true, "offset": 327680}]
 +
 +Offset          Length          Mapped to       File
 +0               0x100000        0x50000         TEST_DIR/PID-base
 +
 +[{ "start": 0, "length": 1048576, "depth": 2, "zero": false, "data": true, "offset": 327680},
 +{ "start": 1048576, "length": 1048576, "depth": 0, "zero": true, "data": false}]
 +
 +Offset          Length          Mapped to       File
 +0               0x100000        0x50000         TEST_DIR/PID-base
 +
 +=== Testing qemu-img commit (top -> mid) ===
 +Image committed.
 +
 +image: TEST_IMG
 +file format: IMGFMT
 +virtual size: 2 MiB (2097152 bytes)
 +cluster_size: 65536
 +backing file: TEST_DIR/PID-base
 +Format specific information:
 +    compat: 1.1
 +    lazy refcounts: false
 +    refcount bits: 16
 +    corrupt: false
 +
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +=== Testing HMP commit (top -> mid) ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 2097152/2097152 bytes at offset 0
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +{"execute": "human-monitor-command", "arguments": {"command-line": "commit drive0"}}
 +{"return": ""}
 +image: TEST_IMG
 +file format: IMGFMT
 +virtual size: 2 MiB (2097152 bytes)
 +cluster_size: 65536
 +backing file: TEST_DIR/PID-base
 +Format specific information:
 +    compat: 1.1
 +    lazy refcounts: false
 +    refcount bits: 16
 +    corrupt: false
 +
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +=== Testing QMP active commit (top -> mid) ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 2097152/2097152 bytes at offset 0
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "mid", "device": "top", "job-id": "job0"}}
 +{"return": {}}
 +{"execute": "job-complete", "arguments": {"id": "job0"}}
 +{"return": {}}
 +{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"execute": "job-dismiss", "arguments": {"id": "job0"}}
 +{"return": {}}
 +image: TEST_IMG
 +file format: IMGFMT
 +virtual size: 2 MiB (2097152 bytes)
 +cluster_size: 65536
 +backing file: TEST_DIR/PID-base
 +Format specific information:
 +    compat: 1.1
 +    lazy refcounts: false
 +    refcount bits: 16
 +    corrupt: false
 +
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +== Resize tests ==
 +=== preallocation=off ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=6442450944 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=1073741824 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 5368709120
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 5368709120
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +1 GiB (0x40000000) bytes not allocated at offset 0 bytes (0x0)
 +7 GiB (0x1c0000000) bytes     allocated at offset 1 GiB (0x40000000)
 +
 +[{ "start": 0, "length": 1073741824, "depth": 1, "zero": true, "data": false},
 +{ "start": 1073741824, "length": 7516192768, "depth": 0, "zero": true, "data": false}]
 +
 +=== preallocation=metadata ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=34359738368 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=32212254720 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 33285996544
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 33285996544
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +30 GiB (0x780000000) bytes not allocated at offset 0 bytes (0x0)
 +3 GiB (0xc0000000) bytes     allocated at offset 30 GiB (0x780000000)
 +
 +[{ "start": 0, "length": 32212254720, "depth": 1, "zero": true, "data": false},
 +{ "start": 32212254720, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 327680},
 +{ "start": 32749125632, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 537264128},
 +{ "start": 33285996544, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1074200576},
 +{ "start": 33822867456, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1611137024},
 +{ "start": 34359738368, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2148139008},
 +{ "start": 34896609280, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2685075456}]
 +
 +=== preallocation=falloc ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=10485760 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=5242880 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 9437184
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 9437184
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +5 MiB (0x500000) bytes not allocated at offset 0 bytes (0x0)
 +10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
 +
 +[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
 +{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +
 +=== preallocation=full ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=8388608 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 11534336
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 11534336
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +8 MiB (0x800000) bytes not allocated at offset 0 bytes (0x0)
 +4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
 +
 +[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
 +{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +
 +=== preallocation=off ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=259072 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 259072
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 259072
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +192 KiB (0x30000) bytes not allocated at offset 0 bytes (0x0)
 +320 KiB (0x50000) bytes     allocated at offset 192 KiB (0x30000)
 +
 +[{ "start": 0, "length": 196608, "depth": 1, "zero": true, "data": false},
 +{ "start": 196608, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": 327680},
 +{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
 +
 +=== preallocation=off ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=409600 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 344064
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 344064
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
 +256 KiB (0x40000) bytes     allocated at offset 256 KiB (0x40000)
 +
 +[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
 +{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
 +
 +=== preallocation=off ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=524288 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 65536/65536 bytes at offset 446464
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Image resized.
 +
 +read 65536/65536 bytes at offset 446464
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
 +244 KiB (0x3d000) bytes     allocated at offset 256 KiB (0x40000)
 +
 +[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
 +{ "start": 262144, "length": 249856, "depth": 0, "zero": true, "data": false}]
 +
 diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/group
 +++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 rw backing quick
 rw
 backing quick
 +274 rw backing
 rw quick
 rw backing quick
 rw migration quick
 --
-.25.3
+.35.1

-[PULL 14/15] qom: Factor out user_creatable_add_dict()
+[PULL 11/13] coroutine-ucontext: use QEMU_DEFINE_STATIC_CO_TLS()
-The QMP handler qmp_object_add() and the implementation of --object in
+From: Stefan Hajnoczi <stefanha@redhat.com>
 qemu-storage-daemon can share most of the code. Currently,
 qemu-storage-daemon calls qmp_object_add(), but this is not correct
 because different visitors need to be used.
-As a first step towards a fix, make qmp_object_add() a wrapper around a
+Thread-Local Storage variables cannot be used directly from coroutine
-new function user_creatable_add_dict() that can get an additional
+code because the compiler may optimize TLS variable accesses across
-parameter. The handling of "props" is only required for compatibility
+qemu_coroutine_yield() calls. When the coroutine is re-entered from
-and not required for the qemu-storage-daemon command line, so it stays
+another thread the TLS variables from the old thread must no longer be
-in qmp_object_add().
+used.
+Use QEMU_DEFINE_STATIC_CO_TLS() for the current and leader variables.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20220307153853.602859-2-stefanha@redhat.com>
+Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/qom/object_interfaces.h | 12 ++++++++++++
+ util/coroutine-ucontext.c | 38 ++++++++++++++++++++++++--------------
- qom/object_interfaces.c         | 27 +++++++++++++++++++++++++++
+file changed, 24 insertions(+), 14 deletions(-)
  qom/qom-qmp-cmds.c              | 24 +-----------------------
 files changed, 40 insertions(+), 23 deletions(-)
-diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
+diff --git a/util/coroutine-ucontext.c b/util/coroutine-ucontext.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qom/object_interfaces.h
+--- a/util/coroutine-ucontext.c
-+++ b/include/qom/object_interfaces.h
++++ b/util/coroutine-ucontext.c
-@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
+@@ -XXX,XX +XXX,XX @@
-                                 const QDict *qdict,
+ #include "qemu/osdep.h"
-                                 Visitor *v, Error **errp);
+ #include <ucontext.h>
+ #include "qemu/coroutine_int.h"
-+/**
++#include "qemu/coroutine-tls.h"
-+ * user_creatable_add_dict:
-+ * @qdict: the object definition
+ #ifdef CONFIG_VALGRIND_H
-+ * @errp: if an error occurs, a pointer to an area to store the error
+ #include <valgrind/valgrind.h>
-+ *
+@@ -XXX,XX +XXX,XX @@ typedef struct {
-+ * Create an instance of the user creatable object that is defined by
+ /**
-+ * @qdict.  The object type is taken from the QDict key 'qom-type', its
+  * Per-thread coroutine bookkeeping
-+ * ID from the key 'id'. The remaining entries in @qdict are used to
+  */
-+ * initialize the object properties.
+-static __thread CoroutineUContext leader;
-+ */
+-static __thread Coroutine *current;
-+void user_creatable_add_dict(QDict *qdict, Error **errp);
++QEMU_DEFINE_STATIC_CO_TLS(Coroutine *, current);
 +QEMU_DEFINE_STATIC_CO_TLS(CoroutineUContext, leader);
  /*
   * va_args to makecontext() must be type 'int', so passing
@@ -XXX,XX +XXX,XX @@ static inline __attribute__((always_inline))
  void finish_switch_fiber(void *fake_stack_save)
  {
  #ifdef CONFIG_ASAN
 +    CoroutineUContext *leaderp = get_ptr_leader();
      const void *bottom_old;
      size_t size_old;
      __sanitizer_finish_switch_fiber(fake_stack_save, &bottom_old, &size_old);
 -    if (!leader.stack) {
 -        leader.stack = (void *)bottom_old;
 -        leader.stack_size = size_old;
 +    if (!leaderp->stack) {
 +        leaderp->stack = (void *)bottom_old;
 +        leaderp->stack_size = size_old;
      }
  #endif
  #ifdef CONFIG_TSAN
@@ -XXX,XX +XXX,XX @@ static void coroutine_trampoline(int i0, int i1)
      /* Initialize longjmp environment and switch back the caller */
      if (!sigsetjmp(self->env, 0)) {
 -        start_switch_fiber_asan(COROUTINE_YIELD, &fake_stack_save, leader.stack,
 -                                leader.stack_size);
 +        CoroutineUContext *leaderp = get_ptr_leader();
 +
- /**
++        start_switch_fiber_asan(COROUTINE_YIELD, &fake_stack_save,
-  * user_creatable_add_opts:
++                                leaderp->stack, leaderp->stack_size);
-  * @opts: the object definition
+         start_switch_fiber_tsan(&fake_stack_save, self, true); /* true=caller */
-diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
+         siglongjmp(*(sigjmp_buf *)co->entry_arg, 1);
-index XXXXXXX..XXXXXXX 100644
+     }
---- a/qom/object_interfaces.c
+@@ -XXX,XX +XXX,XX @@ qemu_coroutine_switch(Coroutine *from_, Coroutine *to_,
-+++ b/qom/object_interfaces.c
+     int ret;
-@@ -XXX,XX +XXX,XX @@
+     void *fake_stack_save = NULL;
- #include "qapi/qmp/qerror.h"
- #include "qapi/qmp/qjson.h"
+-    current = to_;
- #include "qapi/qmp/qstring.h"
++    set_current(to_);
-+#include "qapi/qobject-input-visitor.h"
- #include "qom/object_interfaces.h"
+     ret = sigsetjmp(from->env, 0);
- #include "qemu/help_option.h"
+     if (ret == 0) {
- #include "qemu/module.h"
+@@ -XXX,XX +XXX,XX @@ qemu_coroutine_switch(Coroutine *from_, Coroutine *to_,
-@@ -XXX,XX +XXX,XX @@ out:
-     return obj;
+ Coroutine *qemu_coroutine_self(void)
  {
 -    if (!current) {
 -        current = &leader.base;
 +    Coroutine *self = get_current();
 +    CoroutineUContext *leaderp = get_ptr_leader();
 +
 +    if (!self) {
 +        self = &leaderp->base;
 +        set_current(self);
      }
  #ifdef CONFIG_TSAN
 -    if (!leader.tsan_co_fiber) {
 -        leader.tsan_co_fiber = __tsan_get_current_fiber();
 +    if (!leaderp->tsan_co_fiber) {
 +        leaderp->tsan_co_fiber = __tsan_get_current_fiber();
      }
  #endif
 -    return current;
 +    return self;
  }
-+void user_creatable_add_dict(QDict *qdict, Error **errp)
+ bool qemu_in_coroutine(void)
-+{
+ {
-+    Visitor *v;
+-    return current && current->caller;
-+    Object *obj;
++    Coroutine *self = get_current();
 +    g_autofree char *type = NULL;
 +    g_autofree char *id = NULL;
 +
-+    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
++    return self && self->caller;
 +    if (!type) {
 +        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
 +        return;
 +    }
 +    qdict_del(qdict, "qom-type");
 +
 +    id = g_strdup(qdict_get_try_str(qdict, "id"));
 +    if (!id) {
 +        error_setg(errp, QERR_MISSING_PARAMETER, "id");
 +        return;
 +    }
 +    qdict_del(qdict, "id");
 +
 +    v = qobject_input_visitor_new(QOBJECT(qdict));
 +    obj = user_creatable_add_type(type, id, qdict, v, errp);
 +    visit_free(v);
 +    object_unref(obj);
 +}
  Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
  {
 diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/qom-qmp-cmds.c
 +++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/qapi-commands-qom.h"
  #include "qapi/qmp/qdict.h"
  #include "qapi/qmp/qerror.h"
 -#include "qapi/qobject-input-visitor.h"
  #include "qemu/cutils.h"
  #include "qom/object_interfaces.h"
  #include "qom/qom-qobject.h"
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
  {
      QObject *props;
      QDict *pdict;
 -    Visitor *v;
 -    Object *obj;
 -    g_autofree char *type = NULL;
 -    g_autofree char *id = NULL;
 -
 -    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
 -    if (!type) {
 -        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
 -        return;
 -    }
 -    qdict_del(qdict, "qom-type");
 -
 -    id = g_strdup(qdict_get_try_str(qdict, "id"));
 -    if (!id) {
 -        error_setg(errp, QERR_MISSING_PARAMETER, "id");
 -        return;
 -    }
 -    qdict_del(qdict, "id");
      props = qdict_get(qdict, "props");
      if (props) {
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
          qobject_unref(pdict);
      }
 -    v = qobject_input_visitor_new(QOBJECT(qdict));
 -    obj = user_creatable_add_type(type, id, qdict, v, errp);
 -    visit_free(v);
 -    object_unref(obj);
 +    user_creatable_add_dict(qdict, errp);
  }
- void qmp_object_del(const char *id, Error **errp)
 --
-.25.3
+.35.1

-[PULL 04/15] block: Add flags to bdrv(_co)_truncate()
+[PULL 12/13] coroutine: use QEMU_DEFINE_STATIC_CO_TLS()
-Now that block drivers can support flags for .bdrv_co_truncate, expose
+From: Stefan Hajnoczi <stefanha@redhat.com>
 the parameter in the node level interfaces bdrv_co_truncate() and
 bdrv_truncate().
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Thread-Local Storage variables cannot be used directly from coroutine
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+code because the compiler may optimize TLS variable accesses across
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+qemu_coroutine_yield() calls. When the coroutine is re-entered from
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+another thread the TLS variables from the old thread must no longer be
-Message-Id: <20200424125448.63318-3-kwolf@redhat.com>
+used.
 Use QEMU_DEFINE_STATIC_CO_TLS() for the current and leader variables.
 The alloc_pool QSLIST needs a typedef so the return value of
 get_ptr_alloc_pool() can be stored in a local variable.
 One example of why this code is necessary: a coroutine that yields
 before calling qemu_coroutine_create() to create another coroutine is
 affected by the TLS issue.
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-Id: <20220307153853.602859-3-stefanha@redhat.com>
 Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/block.h       |  5 +++--
+ util/qemu-coroutine.c | 41 ++++++++++++++++++++++++-----------------
- block/block-backend.c       |  2 +-
+file changed, 24 insertions(+), 17 deletions(-)
  block/crypto.c              |  2 +-
  block/io.c                  | 12 +++++++-----
  block/parallels.c           |  6 +++---
  block/qcow.c                |  4 ++--
  block/qcow2-refcount.c      |  2 +-
  block/qcow2.c               | 15 +++++++++------
  block/raw-format.c          |  2 +-
  block/vhdx-log.c            |  2 +-
  block/vhdx.c                |  2 +-
  block/vmdk.c                |  2 +-
  tests/test-block-iothread.c |  6 +++---
 files changed, 34 insertions(+), 28 deletions(-)
-diff --git a/include/block/block.h b/include/block/block.h
+diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block.h
+--- a/util/qemu-coroutine.c
-+++ b/include/block/block.h
++++ b/util/qemu-coroutine.c
-@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@
- void bdrv_refresh_filename(BlockDriverState *bs);
+ #include "qemu/atomic.h"
+ #include "qemu/coroutine.h"
- int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
+ #include "qemu/coroutine_int.h"
--                                  PreallocMode prealloc, Error **errp);
++#include "qemu/coroutine-tls.h"
-+                                  PreallocMode prealloc, BdrvRequestFlags flags,
+ #include "block/aio.h"
-+                                  Error **errp);
- int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
+ /** Initial batch size is 64, and is increased on demand */
--                  PreallocMode prealloc, Error **errp);
+@@ -XXX,XX +XXX,XX @@ enum {
-+                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
+ static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool);
+ static unsigned int pool_batch_size = POOL_INITIAL_BATCH_SIZE;
- int64_t bdrv_nb_sectors(BlockDriverState *bs);
+ static unsigned int release_pool_size;
- int64_t bdrv_getlength(BlockDriverState *bs);
+-static __thread QSLIST_HEAD(, Coroutine) alloc_pool = QSLIST_HEAD_INITIALIZER(pool);
-diff --git a/block/block-backend.c b/block/block-backend.c
+-static __thread unsigned int alloc_pool_size;
-index XXXXXXX..XXXXXXX 100644
+-static __thread Notifier coroutine_pool_cleanup_notifier;
---- a/block/block-backend.c
++
-+++ b/block/block-backend.c
++typedef QSLIST_HEAD(, Coroutine) CoroutineQSList;
-@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
++QEMU_DEFINE_STATIC_CO_TLS(CoroutineQSList, alloc_pool);
-         return -ENOMEDIUM;
++QEMU_DEFINE_STATIC_CO_TLS(unsigned int, alloc_pool_size);
-     }
++QEMU_DEFINE_STATIC_CO_TLS(Notifier, coroutine_pool_cleanup_notifier);
--    return bdrv_truncate(blk->root, offset, exact, prealloc, errp);
+ static void coroutine_pool_cleanup(Notifier *n, void *value)
 +    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
  }
  int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
 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 @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
      offset += payload_offset;
 -    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
 +    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
  }
  static void block_crypto_close(BlockDriverState *bs)
 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 void bdrv_parent_cb_resize(BlockDriverState *bs)
   * 'offset' bytes in length.
   */
  int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
 -                                  PreallocMode prealloc, Error **errp)
 +                                  PreallocMode prealloc, BdrvRequestFlags flags,
 +                                  Error **errp)
  {
      BlockDriverState *bs = child->bs;
      BlockDriver *drv = bs->drv;
      BdrvTrackedRequest req;
 -    BdrvRequestFlags flags = 0;
      int64_t old_size, new_bytes;
      int ret;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
          }
          ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
      } else if (bs->file && drv->is_filter) {
 -        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
 +        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
      } else {
          error_setg(errp, "Image format driver does not support resize");
          ret = -ENOTSUP;
@@ -XXX,XX +XXX,XX @@ typedef struct TruncateCo {
      int64_t offset;
      bool exact;
      PreallocMode prealloc;
 +    BdrvRequestFlags flags;
      Error **errp;
      int ret;
  } TruncateCo;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque)
  {
      TruncateCo *tco = opaque;
      tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->exact,
 -                                tco->prealloc, tco->errp);
 +                                tco->prealloc, tco->flags, tco->errp);
      aio_wait_kick();
  }
  int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
 -                  PreallocMode prealloc, Error **errp)
 +                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
  {
      Coroutine *co;
-     TruncateCo tco = {
+     Coroutine *tmp;
-@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
++    CoroutineQSList *alloc_pool = get_ptr_alloc_pool();
-         .offset     = offset,
-         .exact      = exact,
+-    QSLIST_FOREACH_SAFE(co, &alloc_pool, pool_next, tmp) {
-         .prealloc   = prealloc,
+-        QSLIST_REMOVE_HEAD(&alloc_pool, pool_next);
-+        .flags      = flags,
++    QSLIST_FOREACH_SAFE(co, alloc_pool, pool_next, tmp) {
-         .errp       = errp,
++        QSLIST_REMOVE_HEAD(alloc_pool, pool_next);
-         .ret        = NOT_DONE,
+         qemu_coroutine_delete(co);
-     };
+     }
-diff --git a/block/parallels.c b/block/parallels.c
+ }
-index XXXXXXX..XXXXXXX 100644
+@@ -XXX,XX +XXX,XX @@ Coroutine *qemu_coroutine_create(CoroutineEntry *entry, void *opaque)
---- a/block/parallels.c
+     Coroutine *co = NULL;
-+++ b/block/parallels.c
-@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
+     if (CONFIG_COROUTINE_POOL) {
-         } else {
+-        co = QSLIST_FIRST(&alloc_pool);
-             ret = bdrv_truncate(bs->file,
++        CoroutineQSList *alloc_pool = get_ptr_alloc_pool();
-                                 (s->data_end + space) << BDRV_SECTOR_BITS,
++
--                                false, PREALLOC_MODE_OFF, NULL);
++        co = QSLIST_FIRST(alloc_pool);
-+                                false, PREALLOC_MODE_OFF, 0, NULL);
+         if (!co) {
              if (release_pool_size > qatomic_read(&pool_batch_size)) {
                  /* Slow path; a good place to register the destructor, too.  */
 -                if (!coroutine_pool_cleanup_notifier.notify) {
 -                    coroutine_pool_cleanup_notifier.notify = coroutine_pool_cleanup;
 -                    qemu_thread_atexit_add(&coroutine_pool_cleanup_notifier);
 +                Notifier *notifier = get_ptr_coroutine_pool_cleanup_notifier();
 +                if (!notifier->notify) {
 +                    notifier->notify = coroutine_pool_cleanup;
 +                    qemu_thread_atexit_add(notifier);
                  }
                  /* This is not exact; there could be a little skew between
                   * release_pool_size and the actual size of release_pool.  But
                   * it is just a heuristic, it does not need to be perfect.
                   */
 -                alloc_pool_size = qatomic_xchg(&release_pool_size, 0);
 -                QSLIST_MOVE_ATOMIC(&alloc_pool, &release_pool);
 -                co = QSLIST_FIRST(&alloc_pool);
 +                set_alloc_pool_size(qatomic_xchg(&release_pool_size, 0));
 +                QSLIST_MOVE_ATOMIC(alloc_pool, &release_pool);
 +                co = QSLIST_FIRST(alloc_pool);
              }
          }
-         if (ret < 0) {
+         if (co) {
-             return ret;
+-            QSLIST_REMOVE_HEAD(&alloc_pool, pool_next);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
+-            alloc_pool_size--;
-              * That means we have to pass exact=true.
++            QSLIST_REMOVE_HEAD(alloc_pool, pool_next);
-              */
++            set_alloc_pool_size(get_alloc_pool_size() - 1);
-             ret = bdrv_truncate(bs->file, res->image_end_offset, true,
+         }
 -                                PREALLOC_MODE_OFF, &local_err);
 +                                PREALLOC_MODE_OFF, 0, &local_err);
              if (ret < 0) {
                  error_report_err(local_err);
                  res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
          /* errors are ignored, so we might as well pass exact=true */
          bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS, true,
 -                      PREALLOC_MODE_OFF, NULL);
 +                      PREALLOC_MODE_OFF, 0, NULL);
      }
-     g_free(s->bat_dirty_bmap);
+@@ -XXX,XX +XXX,XX @@ static void coroutine_delete(Coroutine *co)
-diff --git a/block/qcow.c b/block/qcow.c
+             qatomic_inc(&release_pool_size);
-index XXXXXXX..XXXXXXX 100644
+             return;
 --- a/block/qcow.c
 +++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
                      return -E2BIG;
                  }
                  ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size,
 -                                    false, PREALLOC_MODE_OFF, NULL);
 +                                    false, PREALLOC_MODE_OFF, 0, NULL);
                  if (ret < 0) {
                      return ret;
                  }
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
              l1_length) < 0)
          return -1;
      ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
 -                        PREALLOC_MODE_OFF, NULL);
 +                        PREALLOC_MODE_OFF, 0, NULL);
      if (ret < 0)
          return ret;
 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 @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                  }
                  ret = bdrv_truncate(bs->file, offset + s->cluster_size, false,
 -                                    PREALLOC_MODE_OFF, &local_err);
 +                                    PREALLOC_MODE_OFF, 0, &local_err);
                  if (ret < 0) {
                      error_report_err(local_err);
                      goto resize_fail;
 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 preallocate_co(BlockDriverState *bs, uint64_t offset,
              mode = PREALLOC_MODE_OFF;
          }
-         ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
+-        if (alloc_pool_size < qatomic_read(&pool_batch_size)) {
--                               mode, errp);
+-            QSLIST_INSERT_HEAD(&alloc_pool, co, pool_next);
-+                               mode, 0, errp);
+-            alloc_pool_size++;
-         if (ret < 0) {
++        if (get_alloc_pool_size() < qatomic_read(&pool_batch_size)) {
-             return ret;
++            QSLIST_INSERT_HEAD(get_ptr_alloc_pool(), co, pool_next);
 +            set_alloc_pool_size(get_alloc_pool_size() + 1);
              return;
          }
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
-              * always fulfilled, so there is no need to pass it on.)
-              */
-             bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
--                             false, PREALLOC_MODE_OFF, &local_err);
-+                             false, PREALLOC_MODE_OFF, 0, &local_err);
-             if (local_err) {
-                 warn_reportf_err(local_err,
-                                  "Failed to truncate the tail of the image: ");
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
-              * file should be resized to the exact target size, too,
-              * so we pass @exact here.
-              */
--            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, errp);
-+            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
-+                                   errp);
-             if (ret < 0) {
-                 goto fail;
-             }
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
-         new_file_size = allocation_start +
-                         nb_new_data_clusters * s->cluster_size;
-         /* Image file grows, so @exact does not matter */
--        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, errp);
-+        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-+                               errp);
-         if (ret < 0) {
-             error_prepend(errp, "Failed to resize underlying file: ");
-             qcow2_free_clusters(bs, allocation_start,
-@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
-         if (len < 0) {
-             return len;
-         }
--        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL);
-+        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
-+                                NULL);
      }
-     if (offset_into_cluster(s, offset)) {
-@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
-     }
-     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
--                        PREALLOC_MODE_OFF, &local_err);
-+                        PREALLOC_MODE_OFF, 0, &local_err);
-     if (ret < 0) {
-         error_report_err(local_err);
-         goto fail;
-diff --git a/block/raw-format.c b/block/raw-format.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/raw-format.c
-+++ b/block/raw-format.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
-     s->size = offset;
-     offset += s->offset;
--    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
-+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
- }
- static void raw_eject(BlockDriverState *bs, bool eject_flag)
-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_flush(BlockDriverState *bs, BDRVVHDXState *s,
-                     goto exit;
-                 }
-                 ret = bdrv_truncate(bs->file, new_file_size, false,
--                                    PREALLOC_MODE_OFF, NULL);
-+                                    PREALLOC_MODE_OFF, 0, NULL);
-                 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_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
-     }
-     return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
--                         PREALLOC_MODE_OFF, NULL);
-+                         PREALLOC_MODE_OFF, 0, NULL);
- }
- /*
-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 @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
-             }
-             length = QEMU_ALIGN_UP(length, BDRV_SECTOR_SIZE);
-             ret = bdrv_truncate(s->extents[i].file, length, false,
--                                PREALLOC_MODE_OFF, NULL);
-+                                PREALLOC_MODE_OFF, 0, NULL);
-             if (ret < 0) {
-                 return ret;
-             }
-diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/test-block-iothread.c
-+++ b/tests/test-block-iothread.c
-@@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c)
-     int ret;
-     /* Normal success path */
--    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
-+    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
-     g_assert_cmpint(ret, ==, 0);
-     /* Early error: Negative offset */
--    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, NULL);
-+    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
-     g_assert_cmpint(ret, ==, -EINVAL);
-     /* Error: Read-only image */
-     c->bs->read_only = true;
-     c->bs->open_flags &= ~BDRV_O_RDWR;
--    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
-+    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
-     g_assert_cmpint(ret, ==, -EACCES);
-     c->bs->read_only = false;
 --
-.25.3
+.35.1

-[PULL 07/15] raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
+[PULL 13/13] coroutine-win32: use QEMU_DEFINE_STATIC_CO_TLS()
-The raw format driver can simply forward the flag and let its bs->file
+From: Stefan Hajnoczi <stefanha@redhat.com>
 child take care of actually providing the zeros.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Thread-Local Storage variables cannot be used directly from coroutine
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+code because the compiler may optimize TLS variable accesses across
-Reviewed-by: Eric Blake <eblake@redhat.com>
+qemu_coroutine_yield() calls. When the coroutine is re-entered from
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+another thread the TLS variables from the old thread must no longer be
-Message-Id: <20200424125448.63318-6-kwolf@redhat.com>
+used.
 Use QEMU_DEFINE_STATIC_CO_TLS() for the current and leader variables.
 I think coroutine-win32.c could get away with __thread because the
 variables are only used in situations where either the stale value is
 correct (current) or outside coroutine context (loading leader when
 current is NULL). Due to the difficulty of being sure that this is
 really safe in all scenarios it seems worth converting it anyway.
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-Id: <20220307153853.602859-4-stefanha@redhat.com>
 Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/raw-format.c | 4 +++-
+ util/coroutine-win32.c | 18 +++++++++++++-----
-file changed, 3 insertions(+), 1 deletion(-)
+file changed, 13 insertions(+), 5 deletions(-)
-diff --git a/block/raw-format.c b/block/raw-format.c
+diff --git a/util/coroutine-win32.c b/util/coroutine-win32.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/raw-format.c
+--- a/util/coroutine-win32.c
-+++ b/block/raw-format.c
++++ b/util/coroutine-win32.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
+@@ -XXX,XX +XXX,XX @@
-     s->size = offset;
+ #include "qemu/osdep.h"
-     offset += s->offset;
+ #include "qemu/coroutine_int.h"
--    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
++#include "qemu/coroutine-tls.h"
-+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
  typedef struct
  {
@@ -XXX,XX +XXX,XX @@ typedef struct
      CoroutineAction action;
  } CoroutineWin32;
 -static __thread CoroutineWin32 leader;
 -static __thread Coroutine *current;
 +QEMU_DEFINE_STATIC_CO_TLS(CoroutineWin32, leader);
 +QEMU_DEFINE_STATIC_CO_TLS(Coroutine *, current);
  /* This function is marked noinline to prevent GCC from inlining it
   * into coroutine_trampoline(). If we allow it to do that then it
@@ -XXX,XX +XXX,XX @@ qemu_coroutine_switch(Coroutine *from_, Coroutine *to_,
      CoroutineWin32 *from = DO_UPCAST(CoroutineWin32, base, from_);
      CoroutineWin32 *to = DO_UPCAST(CoroutineWin32, base, to_);
 -    current = to_;
 +    set_current(to_);
      to->action = action;
      SwitchToFiber(to->fiber);
@@ -XXX,XX +XXX,XX @@ void qemu_coroutine_delete(Coroutine *co_)
  Coroutine *qemu_coroutine_self(void)
  {
 +    Coroutine *current = get_current();
 +
      if (!current) {
 -        current = &leader.base;
 -        leader.fiber = ConvertThreadToFiber(NULL);
 +        CoroutineWin32 *leader = get_ptr_leader();
 +
 +        current = &leader->base;
 +        set_current(current);
 +        leader->fiber = ConvertThreadToFiber(NULL);
      }
      return current;
  }
- static void raw_eject(BlockDriverState *bs, bool eject_flag)
+ bool qemu_in_coroutine(void)
-@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
+ {
-     bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
++    Coroutine *current = get_current();
-         ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
++
-             bs->file->bs->supported_zero_flags);
+     return current && current->caller;
-+    bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
+ }
 +                                   BDRV_REQ_ZERO_WRITE;
      if (bs->probed && !bdrv_is_read_only(bs)) {
          bdrv_refresh_filename(bs->file->bs);
 --
-.25.3
+.35.1

-[PULL 08/15] file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
+Deleted patch
-For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the
-OS, so we can advertise the flag and just ignore it.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
-Message-Id: <20200424125448.63318-7-kwolf@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- block/file-posix.c | 4 ++++
-file changed, 4 insertions(+)
-diff --git a/block/file-posix.c b/block/file-posix.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
-+++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
- #endif
-     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
-+    if (S_ISREG(st.st_mode)) {
-+        /* When extending regular files, we get zeros from the OS */
-+        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
-+    }
-     ret = 0;
- fail:
-     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
---
-.25.3

The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e:

Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100)

are available in the Git repository at:

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

for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809:

qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200)

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

- Fix resize (extending) of short overlays
- nvme: introduce PMR support from NVMe 1.4 spec
- qemu-storage-daemon: Fix non-string --object properties

----------------------------------------------------------------
Alberto Garcia (1):
      qcow2: Add incompatibility note between backing files and raw external data files

Andrzej Jakowski (1):
      nvme: introduce PMR support from NVMe 1.4 spec

Kevin Wolf (12):
      block: Add flags to BlockDriver.bdrv_co_truncate()
      block: Add flags to bdrv(_co)_truncate()
      block-backend: Add flags to blk_truncate()
      qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
      raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
      file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
      block: truncate: Don't make backing file data visible
      iotests: Filter testfiles out in filter_img_info()
      iotests: Test committing to short backing file
      qcow2: Forward ZERO_WRITE flag for full preallocation
      qom: Factor out user_creatable_add_dict()
      qemu-storage-daemon: Fix non-string --object properties

Paolo Bonzini (1):
      qemu-iotests: allow qcow2 external discarded clusters to contain stale data

From: Alberto Garcia <berto@igalia.com>

Backing files and raw external data files are mutually exclusive.
The documentation of the raw external data bit (in autoclear_features)
already indicates that, but we should also mention it on the other
side.

Suggested-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-Id: <20200410121816.8334-1-berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 docs/interop/qcow2.txt | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/qcow2.txt
+++ b/docs/interop/qcow2.txt
@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
                     is stored (NB: The string is not null terminated). 0 if the
                     image doesn't have a backing file.
 
+                    Note: backing files are incompatible with raw external data
+                    files (auto-clear feature bit 1).
+
          16 - 19:   backing_file_size
                     Length of the backing file name in bytes. Must not be
                     longer than 1023 bytes. Undefined if the image doesn't have
-- 
2.25.3

From: Paolo Bonzini <pbonzini@redhat.com>

Test 244 checks the expected behavior of qcow2 external data files
with respect to zero and discarded clusters.  Filesystems however
are free to ignore discard requests, and this seems to be the
case for overlayfs.  Relax the tests to skip checks on the
external data file for discarded areas, which implies not using
qemu-img compare in the data_file_raw=on case.

This fixes docker tests on RHEL8.

Cc: Kevin Wolf <kwolf@redhat.com>
Cc: qemu-block@nongnu.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200409191006.24429-1-pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/244     | 10 ++++++++--
 tests/qemu-iotests/244.out |  9 ++++++---
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/244
+++ b/tests/qemu-iotests/244
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
 echo
 $QEMU_IO -c 'read -P 0 0 1M' \
          -c 'read -P 0x11 1M 1M' \
-         -c 'read -P 0 2M 2M' \
          -c 'read -P 0x11 4M 1M' \
          -c 'read -P 0 5M 1M' \
          -f raw "$TEST_IMG.data" |
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
          -f $IMGFMT "$TEST_IMG" |
          _filter_qemu_io
 
+# Discarded clusters are only marked as such in the qcow2 metadata, but
+# they can contain stale data in the external data file.  Instead, zero
+# clusters must be zeroed in the external data file too.
 echo
-$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG.data"
+$QEMU_IO -c 'read -P 0 0 1M' \
+         -c 'read -P 0x11 1M 1M' \
+         -c 'read -P 0 3M 3M' \
+         -f raw "$TEST_IMG".data |
+         _filter_qemu_io
 
 echo -n "qcow2 file size after I/O: "
 du -b $TEST_IMG | cut -f1
diff --git a/tests/qemu-iotests/244.out b/tests/qemu-iotests/244.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/244.out
+++ b/tests/qemu-iotests/244.out
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 1048576
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-read 2097152/2097152 bytes at offset 2097152
-2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 4194304
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 5242880
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 1048576
 read 4194304/4194304 bytes at offset 2097152
 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
-Images are identical.
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 3145728/3145728 bytes at offset 3145728
+3 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 qcow2 file size after I/O: 327680
 
 === bdrv_co_block_status test for file and offset=0 ===
-- 
2.25.3

This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate()
driver callbacks, and a supported_truncate_flags field in
BlockDriverState that allows drivers to advertise support for request
flags in the context of truncate.

For now, we always pass 0 and no drivers declare support for any flag.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-2-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block_int.h   | 10 +++++++++-
 block/crypto.c              |  3 ++-
 block/file-posix.c          |  2 +-
 block/file-win32.c          |  2 +-
 block/gluster.c             |  1 +
 block/io.c                  |  8 +++++++-
 block/iscsi.c               |  2 +-
 block/nfs.c                 |  3 ++-
 block/qcow2.c               |  2 +-
 block/qed.c                 |  1 +
 block/raw-format.c          |  2 +-
 block/rbd.c                 |  1 +
 block/sheepdog.c            |  4 ++--
 block/ssh.c                 |  2 +-
 tests/test-block-iothread.c |  3 ++-
 15 files changed, 33 insertions(+), 13 deletions(-)

diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      */
     int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
-                                         Error **errp);
+                                         BdrvRequestFlags flags, Error **errp);
 
     int64_t (*bdrv_getlength)(BlockDriverState *bs);
     bool has_variable_length;
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA,
      * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */
     unsigned int supported_zero_flags;
+    /*
+     * Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE).
+     *
+     * If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure
+     * that any added space reads as all zeros. If this can't be guaranteed,
+     * the operation must fail.
+     */
+    unsigned int supported_truncate_flags;
 
     /* the following member gives a name to every node on the bs graph. */
     char node_name[32];
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_co_create_generic(BlockDriverState *bs,
 
 static int coroutine_fn
 block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                         PreallocMode prealloc, Error **errp)
+                         PreallocMode prealloc, BdrvRequestFlags flags,
+                         Error **errp)
 {
     BlockCrypto *crypto = bs->opaque;
     uint64_t payload_offset =
diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
     struct stat st;
diff --git a/block/file-win32.c b/block/file-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-win32.c
+++ b/block/file-win32.c
@@ -XXX,XX +XXX,XX @@ static void raw_close(BlockDriverState *bs)
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
     LONG low, high;
diff --git a/block/gluster.c b/block/gluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,
                                                  int64_t offset,
                                                  bool exact,
                                                  PreallocMode prealloc,
+                                                 BdrvRequestFlags flags,
                                                  Error **errp)
 {
     BDRVGlusterState *s = bs->opaque;
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 coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
     BlockDriverState *bs = child->bs;
     BlockDriver *drv = bs->drv;
     BdrvTrackedRequest req;
+    BdrvRequestFlags flags = 0;
     int64_t old_size, new_bytes;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
     }
 
     if (drv->bdrv_co_truncate) {
-        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, errp);
+        if (flags & ~bs->supported_truncate_flags) {
+            error_setg(errp, "Block driver does not support requested flags");
+            ret = -ENOTSUP;
+            goto out;
+        }
+        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
     } else if (bs->file && drv->is_filter) {
         ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
     } else {
diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void iscsi_reopen_commit(BDRVReopenState *reopen_state)
 
 static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
                                           bool exact, PreallocMode prealloc,
-                                          Error **errp)
+                                          BdrvRequestFlags flags, Error **errp)
 {
     IscsiLun *iscsilun = bs->opaque;
     int64_t cur_length;
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
 
 static int coroutine_fn
 nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                     PreallocMode prealloc, Error **errp)
+                     PreallocMode prealloc, BdrvRequestFlags flags,
+                     Error **errp)
 {
     NFSClient *client = bs->opaque;
     int ret;
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 @@ fail:
 
 static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
                                           bool exact, PreallocMode prealloc,
-                                          Error **errp)
+                                          BdrvRequestFlags flags, Error **errp)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t old_length;
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_truncate(BlockDriverState *bs,
                                              int64_t offset,
                                              bool exact,
                                              PreallocMode prealloc,
+                                             BdrvRequestFlags flags,
                                              Error **errp)
 {
     BDRVQEDState *s = bs->opaque;
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
 
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs,
                                              int64_t offset,
                                              bool exact,
                                              PreallocMode prealloc,
+                                             BdrvRequestFlags flags,
                                              Error **errp)
 {
     int r;
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static int64_t sd_getlength(BlockDriverState *bs)
 
 static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset,
                                        bool exact, PreallocMode prealloc,
-                                       Error **errp)
+                                       BdrvRequestFlags flags, Error **errp)
 {
     BDRVSheepdogState *s = bs->opaque;
     int ret, fd;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
 
     assert(!flags);
     if (offset > s->inode.vdi_size) {
-        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, NULL);
+        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, 0, NULL);
         if (ret < 0) {
             return ret;
         }
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static int64_t ssh_getlength(BlockDriverState *bs)
 
 static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVSSHState *s = bs->opaque;
 
diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-block-iothread.c
+++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
 
 static int coroutine_fn
 bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                      PreallocMode prealloc, Error **errp)
+                      PreallocMode prealloc, BdrvRequestFlags flags,
+                      Error **errp)
 {
     return 0;
 }
-- 
2.25.3

Now that block drivers can support flags for .bdrv_co_truncate, expose
the parameter in the node level interfaces bdrv_co_truncate() and
bdrv_truncate().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-3-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block.h       |  5 +++--
 block/block-backend.c       |  2 +-
 block/crypto.c              |  2 +-
 block/io.c                  | 12 +++++++-----
 block/parallels.c           |  6 +++---
 block/qcow.c                |  4 ++--
 block/qcow2-refcount.c      |  2 +-
 block/qcow2.c               | 15 +++++++++------
 block/raw-format.c          |  2 +-
 block/vhdx-log.c            |  2 +-
 block/vhdx.c                |  2 +-
 block/vmdk.c                |  2 +-
 tests/test-block-iothread.c |  6 +++---
 13 files changed, 34 insertions(+), 28 deletions(-)

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
 void bdrv_refresh_filename(BlockDriverState *bs);
 
 int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
-                                  PreallocMode prealloc, Error **errp);
+                                  PreallocMode prealloc, BdrvRequestFlags flags,
+                                  Error **errp);
 int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
-                  PreallocMode prealloc, Error **errp);
+                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
 
 int64_t bdrv_nb_sectors(BlockDriverState *bs);
 int64_t bdrv_getlength(BlockDriverState *bs);
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_truncate(BlockBackend *blk, int64_t offset, bool exact,
         return -ENOMEDIUM;
     }
 
-    return bdrv_truncate(blk->root, offset, exact, prealloc, errp);
+    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
 }
 
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
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 @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 
     offset += payload_offset;
 
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
 }
 
 static void block_crypto_close(BlockDriverState *bs)
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 void bdrv_parent_cb_resize(BlockDriverState *bs)
  * 'offset' bytes in length.
  */
 int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
-                                  PreallocMode prealloc, Error **errp)
+                                  PreallocMode prealloc, BdrvRequestFlags flags,
+                                  Error **errp)
 {
     BlockDriverState *bs = child->bs;
     BlockDriver *drv = bs->drv;
     BdrvTrackedRequest req;
-    BdrvRequestFlags flags = 0;
     int64_t old_size, new_bytes;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
         }
         ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
     } else if (bs->file && drv->is_filter) {
-        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
     } else {
         error_setg(errp, "Image format driver does not support resize");
         ret = -ENOTSUP;
@@ -XXX,XX +XXX,XX @@ typedef struct TruncateCo {
     int64_t offset;
     bool exact;
     PreallocMode prealloc;
+    BdrvRequestFlags flags;
     Error **errp;
     int ret;
 } TruncateCo;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque)
 {
     TruncateCo *tco = opaque;
     tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->exact,
-                                tco->prealloc, tco->errp);
+                                tco->prealloc, tco->flags, tco->errp);
     aio_wait_kick();
 }
 
 int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
-                  PreallocMode prealloc, Error **errp)
+                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
 {
     Coroutine *co;
     TruncateCo tco = {
@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
         .offset     = offset,
         .exact      = exact,
         .prealloc   = prealloc,
+        .flags      = flags,
         .errp       = errp,
         .ret        = NOT_DONE,
     };
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 int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
         } else {
             ret = bdrv_truncate(bs->file,
                                 (s->data_end + space) << BDRV_SECTOR_BITS,
-                                false, PREALLOC_MODE_OFF, NULL);
+                                false, PREALLOC_MODE_OFF, 0, NULL);
         }
         if (ret < 0) {
             return ret;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
              * That means we have to pass exact=true.
              */
             ret = bdrv_truncate(bs->file, res->image_end_offset, true,
-                                PREALLOC_MODE_OFF, &local_err);
+                                PREALLOC_MODE_OFF, 0, &local_err);
             if (ret < 0) {
                 error_report_err(local_err);
                 res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
 
         /* errors are ignored, so we might as well pass exact=true */
         bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS, true,
-                      PREALLOC_MODE_OFF, NULL);
+                      PREALLOC_MODE_OFF, 0, NULL);
     }
 
     g_free(s->bat_dirty_bmap);
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 get_cluster_offset(BlockDriverState *bs,
                     return -E2BIG;
                 }
                 ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size,
-                                    false, PREALLOC_MODE_OFF, NULL);
+                                    false, PREALLOC_MODE_OFF, 0, NULL);
                 if (ret < 0) {
                     return ret;
                 }
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
             l1_length) < 0)
         return -1;
     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
-                        PREALLOC_MODE_OFF, NULL);
+                        PREALLOC_MODE_OFF, 0, NULL);
     if (ret < 0)
         return ret;
 
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 @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                 }
 
                 ret = bdrv_truncate(bs->file, offset + s->cluster_size, false,
-                                    PREALLOC_MODE_OFF, &local_err);
+                                    PREALLOC_MODE_OFF, 0, &local_err);
                 if (ret < 0) {
                     error_report_err(local_err);
                     goto resize_fail;
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 preallocate_co(BlockDriverState *bs, uint64_t offset,
             mode = PREALLOC_MODE_OFF;
         }
         ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
-                               mode, errp);
+                               mode, 0, errp);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
              * always fulfilled, so there is no need to pass it on.)
              */
             bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
-                             false, PREALLOC_MODE_OFF, &local_err);
+                             false, PREALLOC_MODE_OFF, 0, &local_err);
             if (local_err) {
                 warn_reportf_err(local_err,
                                  "Failed to truncate the tail of the image: ");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
              * file should be resized to the exact target size, too,
              * so we pass @exact here.
              */
-            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, errp);
+            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
+                                   errp);
             if (ret < 0) {
                 goto fail;
             }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         new_file_size = allocation_start +
                         nb_new_data_clusters * s->cluster_size;
         /* Image file grows, so @exact does not matter */
-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, errp);
+        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
+                               errp);
         if (ret < 0) {
             error_prepend(errp, "Failed to resize underlying file: ");
             qcow2_free_clusters(bs, allocation_start,
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
         if (len < 0) {
             return len;
         }
-        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL);
+        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
+                                NULL);
     }
 
     if (offset_into_cluster(s, offset)) {
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
     }
 
     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
-                        PREALLOC_MODE_OFF, &local_err);
+                        PREALLOC_MODE_OFF, 0, &local_err);
     if (ret < 0) {
         error_report_err(local_err);
         goto fail;
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
 
     s->size = offset;
     offset += s->offset;
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
 }
 
 static void raw_eject(BlockDriverState *bs, bool eject_flag)
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_flush(BlockDriverState *bs, BDRVVHDXState *s,
                     goto exit;
                 }
                 ret = bdrv_truncate(bs->file, new_file_size, false,
-                                    PREALLOC_MODE_OFF, NULL);
+                                    PREALLOC_MODE_OFF, 0, NULL);
                 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_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
     }
 
     return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
-                         PREALLOC_MODE_OFF, NULL);
+                         PREALLOC_MODE_OFF, 0, NULL);
 }
 
 /*
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 @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
             }
             length = QEMU_ALIGN_UP(length, BDRV_SECTOR_SIZE);
             ret = bdrv_truncate(s->extents[i].file, length, false,
-                                PREALLOC_MODE_OFF, NULL);
+                                PREALLOC_MODE_OFF, 0, NULL);
             if (ret < 0) {
                 return ret;
             }
diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-block-iothread.c
+++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c)
     int ret;
 
     /* Normal success path */
-    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
-    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, -EINVAL);
 
     /* Error: Read-only image */
     c->bs->read_only = true;
     c->bs->open_flags &= ~BDRV_O_RDWR;
 
-    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, -EACCES);
 
     c->bs->read_only = false;
-- 
2.25.3

Now that node level interface bdrv_truncate() supports passing request
flags to the block driver, expose this on the BlockBackend level, too.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-4-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/sysemu/block-backend.h | 2 +-
 block.c                        | 3 ++-
 block/block-backend.c          | 4 ++--
 block/commit.c                 | 4 ++--
 block/crypto.c                 | 2 +-
 block/mirror.c                 | 2 +-
 block/qcow2.c                  | 4 ++--
 block/qed.c                    | 2 +-
 block/vdi.c                    | 2 +-
 block/vhdx.c                   | 4 ++--
 block/vmdk.c                   | 6 +++---
 block/vpc.c                    | 2 +-
 blockdev.c                     | 2 +-
 qemu-img.c                     | 2 +-
 qemu-io-cmds.c                 | 2 +-
 15 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend.h
+++ b/include/sysemu/block-backend.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
                           int bytes);
 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-                 PreallocMode prealloc, Error **errp);
+                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
 int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes);
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
                      int64_t pos, int size);
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
     int64_t size;
     int ret;
 
-    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
+    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
+                       &local_err);
     if (ret < 0 && ret != -ENOTSUP) {
         error_propagate(errp, local_err);
         return ret;
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_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
 }
 
 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-                 PreallocMode prealloc, Error **errp)
+                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
 {
     if (!blk_is_available(blk)) {
         error_setg(errp, "No medium inserted");
         return -ENOMEDIUM;
     }
 
-    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
+    return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
 }
 
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
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 @@ static int coroutine_fn commit_run(Job *job, Error **errp)
     }
 
     if (base_len < len) {
-        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, NULL);
+        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL);
         if (ret) {
             goto out;
         }
@@ -XXX,XX +XXX,XX @@ int bdrv_commit(BlockDriverState *bs)
      * grow the backing file image if possible.  If not possible,
      * we must return an error */
     if (length > backing_length) {
-        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF,
+        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0,
                            &local_err);
         if (ret < 0) {
             error_report_err(local_err);
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_init_func(QCryptoBlock *block,
      * which will be used by the crypto header
      */
     return blk_truncate(data->blk, data->size + headerlen, false,
-                        data->prealloc, errp);
+                        data->prealloc, 0, errp);
 }
 
 
diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
 
         if (s->bdev_length > base_length) {
             ret = blk_truncate(s->target, s->bdev_length, false,
-                               PREALLOC_MODE_OFF, NULL);
+                               PREALLOC_MODE_OFF, 0, NULL);
             if (ret < 0) {
                 goto immediate_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)
 
     /* Okay, now that we have a valid image, let's give it the right size */
     ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
-                       errp);
+                       0, errp);
     if (ret < 0) {
         error_prepend(errp, "Could not resize image: ");
         goto out;
@@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
          * Amending image options should ensure that the image has
          * exactly the given new values, so pass exact=true here.
          */
-        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
         blk_unref(blk);
         if (ret < 0) {
             return ret;
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,
      * The QED format associates file length with allocation status,
      * so a new file (which is empty) must have a length of 0.
      */
-    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, 0, errp);
     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,
 
     if (image_type == VDI_TYPE_STATIC) {
         ret = blk_truncate(blk, offset + blocks * block_size, false,
-                           PREALLOC_MODE_OFF, errp);
+                           PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             error_prepend(errp, "Failed to statically allocate file");
             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_bat(BlockBackend *blk, BDRVVHDXState *s,
         /* All zeroes, so we can just extend the file - the end of the BAT
          * is the furthest thing we have written yet */
         ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
-                           errp);
+                           0, errp);
         if (ret < 0) {
             goto exit;
         }
     } else if (type == VHDX_TYPE_FIXED) {
         ret = blk_truncate(blk, data_file_offset + image_size, false,
-                           PREALLOC_MODE_OFF, errp);
+                           PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             goto 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,
     int gd_buf_size;
 
     if (flat) {
-        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
         goto exit;
     }
     magic = cpu_to_be32(VMDK4_MAGIC);
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
     }
 
     ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
-                       PREALLOC_MODE_OFF, errp);
+                       PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size,
     /* bdrv_pwrite write padding zeros to align to sector, we don't need that
      * for description file */
     if (desc_offset == 0) {
-        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             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_fixed_disk(BlockBackend *blk, uint8_t *buf,
     /* Add footer to total size */
     total_size += HEADER_SIZE;
 
-    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         return ret;
     }
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
     }
 
     bdrv_drained_begin(bs);
-    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp);
     bdrv_drained_end(bs);
 
 out:
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_resize(int argc, char **argv)
      * resizing, so pass @exact=true.  It is of no use to report
      * success when the image has not actually been resized.
      */
-    ret = blk_truncate(blk, total_size, true, prealloc, &err);
+    ret = blk_truncate(blk, total_size, true, prealloc, 0, &err);
     if (!ret) {
         qprintf(quiet, "Image resized.\n");
     } else {
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 truncate_f(BlockBackend *blk, int argc, char **argv)
      * exact=true.  It is better to err on the "emit more errors" side
      * than to be overly permissive.
      */
-    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, &local_err);
+    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, 0, &local_err);
     if (ret < 0) {
         error_report_err(local_err);
         return ret;
-- 
2.25.3

If BDRV_REQ_ZERO_WRITE is set and we're extending the image, calling
qcow2_cluster_zeroize() with flags=0 does the right thing: It doesn't
undo any previous preallocation, but just adds the zero flag to all
relevant L2 entries. If an external data file is in use, a write_zeroes
request to the data file is made instead.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200424125448.63318-5-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2-cluster.c |  2 +-
 block/qcow2.c         | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 1 deletion(-)

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_cluster_zeroize(BlockDriverState *bs, uint64_t offset,
     /* Caller must pass aligned values, except at image end */
     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
     assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
-           end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
+           end_offset >= bs->total_sectors << BDRV_SECTOR_BITS);
 
     /* The zero flag is only supported by version 3 and newer */
     if (s->qcow_version < 3) {
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_do_open(BlockDriverState *bs, QDict *options,
 
     bs->supported_zero_flags = header.version >= 3 ?
                                BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
+    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
 
     /* Repair image if dirty */
     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         g_assert_not_reached();
     }
 
+    if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
+        uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
+
+        /*
+         * Use zero clusters as much as we can. qcow2_cluster_zeroize()
+         * requires a cluster-aligned start. The end may be unaligned if it is
+         * at the end of the image (which it is here).
+         */
+        ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "Failed to zero out new clusters");
+            goto fail;
+        }
+
+        /* Write explicit zeros for the unaligned head */
+        if (zero_start > old_length) {
+            uint64_t len = zero_start - old_length;
+            uint8_t *buf = qemu_blockalign0(bs, len);
+            QEMUIOVector qiov;
+            qemu_iovec_init_buf(&qiov, buf, len);
+
+            qemu_co_mutex_unlock(&s->lock);
+            ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
+            qemu_co_mutex_lock(&s->lock);
+
+            qemu_vfree(buf);
+            if (ret < 0) {
+                error_setg_errno(errp, -ret, "Failed to zero out the new area");
+                goto fail;
+            }
+        }
+    }
+
     if (prealloc != PREALLOC_MODE_OFF) {
         /* Flush metadata before actually changing the image size */
         ret = qcow2_write_caches(bs);
-- 
2.25.3

The raw format driver can simply forward the flag and let its bs->file
child take care of actually providing the zeros.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-6-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/raw-format.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
 
     s->size = offset;
     offset += s->offset;
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
 }
 
 static void raw_eject(BlockDriverState *bs, bool eject_flag)
@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
     bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
         ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
             bs->file->bs->supported_zero_flags);
+    bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
+                                   BDRV_REQ_ZERO_WRITE;
 
     if (bs->probed && !bdrv_is_read_only(bs)) {
         bdrv_refresh_filename(bs->file->bs);
-- 
2.25.3

For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the
OS, so we can advertise the flag and just ignore it.

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
 #endif
 
     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
+    if (S_ISREG(st.st_mode)) {
+        /* When extending regular files, we get zeros from the OS */
+        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
+    }
     ret = 0;
 fail:
     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
-- 
2.25.3

When extending the size of an image that has a backing file larger than
its old size, make sure that the backing file data doesn't become
visible in the guest, but the added area is properly zeroed out.

Consider the following scenario where the overlay is shorter than its
backing file:

base.qcow2:     AAAAAAAA
    overlay.qcow2:  BBBB

When resizing (extending) overlay.qcow2, the new blocks should not stay
unallocated and make the additional As from base.qcow2 visible like
before this patch, but zeros should be read.

A similar case happens with the various variants of a commit job when an
intermediate file is short (- for unallocated):

base.qcow2:     A-A-AAAA
    mid.qcow2:      BB-B
    top.qcow2:      C--C--C-

After commit top.qcow2 to mid.qcow2, the following happens:

mid.qcow2:      CB-C00C0 (correct result)
    mid.qcow2:      CB-C--C- (before this fix)

Without the fix, blocks that previously read as zeros on top.qcow2
suddenly turn into A.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-8-kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/io.c | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

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 coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
         goto out;
     }
 
+    /*
+     * If the image has a backing file that is large enough that it would
+     * provide data for the new area, we cannot leave it unallocated because
+     * then the backing file content would become visible. Instead, zero-fill
+     * the new area.
+     *
+     * Note that if the image has a backing file, but was opened without the
+     * backing file, taking care of keeping things consistent with that backing
+     * file is the user's responsibility.
+     */
+    if (new_bytes && bs->backing) {
+        int64_t backing_len;
+
+        backing_len = bdrv_getlength(backing_bs(bs));
+        if (backing_len < 0) {
+            ret = backing_len;
+            error_setg_errno(errp, -ret, "Could not get backing file size");
+            goto out;
+        }
+
+        if (backing_len > old_size) {
+            flags |= BDRV_REQ_ZERO_WRITE;
+        }
+    }
+
     if (drv->bdrv_co_truncate) {
         if (flags & ~bs->supported_truncate_flags) {
             error_setg(errp, "Block driver does not support requested flags");
-- 
2.25.3

We want to keep TEST_IMG for the full path of the main test image, but
filter_testfiles() must be called for other test images before replacing
other things like the image format because the test directory path could
contain the format as a substring.

Insert a filter_testfiles() call between both.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-9-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/iotests.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ def filter_img_info(output, filename):
     for line in output.split('\n'):
         if 'disk size' in line or 'actual-size' in line:
             continue
-        line = line.replace(filename, 'TEST_IMG') \
-                   .replace(imgfmt, 'IMGFMT')
+        line = line.replace(filename, 'TEST_IMG')
+        line = filter_testfiles(line)
+        line = line.replace(imgfmt, 'IMGFMT')
         line = re.sub('iters: [0-9]+', 'iters: XXX', line)
         line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
         line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line)
-- 
2.25.3

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200424125448.63318-10-kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/274     | 155 +++++++++++++++++++++
 tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/group   |   1 +
 3 files changed, 424 insertions(+)
 create mode 100755 tests/qemu-iotests/274
 create mode 100644 tests/qemu-iotests/274.out

diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/274
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+#
+# Copyright (C) 2019 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+#
+# Some tests for short backing files and short overlays
+
+import iotests
+
+iotests.verify_image_format(supported_fmts=['qcow2'])
+iotests.verify_platform(['linux'])
+
+size_short = 1 * 1024 * 1024
+size_long = 2 * 1024 * 1024
+size_diff = size_long - size_short
+
+def create_chain() -> None:
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base,
+                         str(size_long))
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid,
+                         str(size_short))
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top,
+                         str(size_long))
+
+    iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base)
+
+def create_vm() -> iotests.VM:
+    vm = iotests.VM()
+    vm.add_blockdev('file,filename=%s,node-name=base-file' % base)
+    vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt)
+    vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid)
+    vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base'
+                    % iotests.imgfmt)
+    vm.add_drive(top, 'backing=mid,node-name=top')
+    return vm
+
+with iotests.FilePath('base') as base, \
+     iotests.FilePath('mid') as mid, \
+     iotests.FilePath('top') as top:
+
+    iotests.log('== Commit tests ==')
+
+    create_chain()
+
+    iotests.log('=== Check visible data ===')
+
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top)
+
+    iotests.log('=== Checking allocation status ===')
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        base)
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        mid)
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        top)
+
+    iotests.log('=== Checking map ===')
+
+    iotests.qemu_img_log('map', '--output=json', base)
+    iotests.qemu_img_log('map', '--output=human', base)
+    iotests.qemu_img_log('map', '--output=json', mid)
+    iotests.qemu_img_log('map', '--output=human', mid)
+    iotests.qemu_img_log('map', '--output=json', top)
+    iotests.qemu_img_log('map', '--output=human', top)
+
+    iotests.log('=== Testing qemu-img commit (top -> mid) ===')
+
+    iotests.qemu_img_log('commit', top)
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+    iotests.log('=== Testing HMP commit (top -> mid) ===')
+
+    create_chain()
+    with create_vm() as vm:
+        vm.launch()
+        vm.qmp_log('human-monitor-command', command_line='commit drive0')
+
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+    iotests.log('=== Testing QMP active commit (top -> mid) ===')
+
+    create_chain()
+    with create_vm() as vm:
+        vm.launch()
+        vm.qmp_log('block-commit', device='top', base_node='mid',
+                   job_id='job0', auto_dismiss=False)
+        vm.run_job('job0', wait=5)
+
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+
+    iotests.log('== Resize tests ==')
+
+    # Use different sizes for different allocation modes:
+    #
+    # We want to have at least one test where 32 bit truncation in the size of
+    # the overlapping area becomes visible. This is covered by the
+    # prealloc='off' case (1G to 6G is an overlap of 5G).
+    #
+    # However, we can only do this for modes that don't preallocate data
+    # because otherwise we might run out of space on the test host.
+    #
+    # We also want to test some unaligned combinations.
+    for (prealloc, base_size, top_size_old, top_size_new, off) in [
+            ('off',       '6G',    '1G',   '8G',   '5G'),
+            ('metadata', '32G',   '30G',  '33G',  '31G'),
+            ('falloc',   '10M',    '5M',  '15M',   '9M'),
+            ('full',     '16M',    '8M',  '12M',  '11M'),
+            ('off',      '384k', '253k', '512k', '253k'),
+            ('off',      '400k', '256k', '512k', '336k'),
+            ('off',      '512k', '256k', '500k', '436k')]:
+
+        iotests.log('=== preallocation=%s ===' % prealloc)
+        iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size)
+        iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top,
+                             top_size_old)
+        iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base)
+
+        # After this, top_size_old to base_size should be allocated/zeroed.
+        #
+        # In theory, leaving base_size to top_size_new unallocated would be
+        # correct, but in practice, if we zero out anything, we zero out
+        # everything up to top_size_new.
+        iotests.qemu_img_log('resize', '-f', iotests.imgfmt,
+                             '--preallocation', prealloc, top, top_size_new)
+        iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top)
+        iotests.qemu_io_log('-c', 'map', top)
+        iotests.qemu_img_log('map', '--output=json', top)
diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@
+== Commit tests ==
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Check visible data ===
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Checking allocation status ===
+1048576/1048576 bytes allocated at offset 0 bytes
+1048576/1048576 bytes allocated at offset 1 MiB
+
+0/1048576 bytes allocated at offset 0 bytes
+0/0 bytes allocated at offset 1 MiB
+
+0/1048576 bytes allocated at offset 0 bytes
+0/1048576 bytes allocated at offset 1 MiB
+
+=== Checking map ===
+[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": 327680}]
+
+Offset          Length          Mapped to       File
+0               0x200000        0x50000         TEST_DIR/PID-base
+
+[{ "start": 0, "length": 1048576, "depth": 1, "zero": false, "data": true, "offset": 327680}]
+
+Offset          Length          Mapped to       File
+0               0x100000        0x50000         TEST_DIR/PID-base
+
+[{ "start": 0, "length": 1048576, "depth": 2, "zero": false, "data": true, "offset": 327680},
+{ "start": 1048576, "length": 1048576, "depth": 0, "zero": true, "data": false}]
+
+Offset          Length          Mapped to       File
+0               0x100000        0x50000         TEST_DIR/PID-base
+
+=== Testing qemu-img commit (top -> mid) ===
+Image committed.
+
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Testing HMP commit (top -> mid) ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+{"execute": "human-monitor-command", "arguments": {"command-line": "commit drive0"}}
+{"return": ""}
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Testing QMP active commit (top -> mid) ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "mid", "device": "top", "job-id": "job0"}}
+{"return": {}}
+{"execute": "job-complete", "arguments": {"id": "job0"}}
+{"return": {}}
+{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== Resize tests ==
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=6442450944 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=1073741824 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 5368709120
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 5368709120
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+1 GiB (0x40000000) bytes not allocated at offset 0 bytes (0x0)
+7 GiB (0x1c0000000) bytes     allocated at offset 1 GiB (0x40000000)
+
+[{ "start": 0, "length": 1073741824, "depth": 1, "zero": true, "data": false},
+{ "start": 1073741824, "length": 7516192768, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=metadata ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=34359738368 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=32212254720 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 33285996544
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 33285996544
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+30 GiB (0x780000000) bytes not allocated at offset 0 bytes (0x0)
+3 GiB (0xc0000000) bytes     allocated at offset 30 GiB (0x780000000)
+
+[{ "start": 0, "length": 32212254720, "depth": 1, "zero": true, "data": false},
+{ "start": 32212254720, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 327680},
+{ "start": 32749125632, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 537264128},
+{ "start": 33285996544, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1074200576},
+{ "start": 33822867456, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1611137024},
+{ "start": 34359738368, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2148139008},
+{ "start": 34896609280, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2685075456}]
+
+=== preallocation=falloc ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=10485760 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=5242880 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 9437184
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 9437184
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+5 MiB (0x500000) bytes not allocated at offset 0 bytes (0x0)
+10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
+
+[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
+{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+
+=== preallocation=full ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=8388608 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 11534336
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 11534336
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+8 MiB (0x800000) bytes not allocated at offset 0 bytes (0x0)
+4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
+
+[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
+{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=259072 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 259072
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 259072
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+192 KiB (0x30000) bytes not allocated at offset 0 bytes (0x0)
+320 KiB (0x50000) bytes     allocated at offset 192 KiB (0x30000)
+
+[{ "start": 0, "length": 196608, "depth": 1, "zero": true, "data": false},
+{ "start": 196608, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": 327680},
+{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=409600 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 344064
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 344064
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
+256 KiB (0x40000) bytes     allocated at offset 256 KiB (0x40000)
+
+[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
+{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=524288 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 446464
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 446464
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
+244 KiB (0x3d000) bytes     allocated at offset 256 KiB (0x40000)
+
+[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
+{ "start": 262144, "length": 249856, "depth": 0, "zero": true, "data": false}]
+
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 270 rw backing quick
 272 rw
 273 backing quick
+274 rw backing
 277 rw quick
 279 rw backing quick
 280 rw migration quick
-- 
2.25.3

The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the
image is possibly preallocated and then the zero flag is added to all
clusters. This means that a copy-on-write operation may be needed when
writing to these clusters, despite having used preallocation, negating
one of the major benefits of preallocation.

Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver,
and if the protocol driver can ensure that the new area reads as zeros,
we can skip setting the zero flag in the qcow2 layer.

Unfortunately, the same approach doesn't work for metadata
preallocation, so we'll still set the zero flag there.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424142701.67053-1-kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c              | 22 +++++++++++++++++++---
 tests/qemu-iotests/274.out |  4 ++--
 2 files changed, 21 insertions(+), 5 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 @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         /* Allocate the data area */
         new_file_size = allocation_start +
                         nb_new_data_clusters * s->cluster_size;
-        /* Image file grows, so @exact does not matter */
-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-                               errp);
+        /*
+         * Image file grows, so @exact does not matter.
+         *
+         * If we need to zero out the new area, try first whether the protocol
+         * driver can already take care of this.
+         */
+        if (flags & BDRV_REQ_ZERO_WRITE) {
+            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
+                                   BDRV_REQ_ZERO_WRITE, NULL);
+            if (ret >= 0) {
+                flags &= ~BDRV_REQ_ZERO_WRITE;
+            }
+        } else {
+            ret = -1;
+        }
+        if (ret < 0) {
+            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
+                                   errp);
+        }
         if (ret < 0) {
             error_prepend(errp, "Failed to resize underlying file: ");
             qcow2_free_clusters(bs, allocation_start,
diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/274.out
+++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184
 10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
 
 [{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
-{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}]
 
 === preallocation=full ===
 Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336
 4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
 
 [{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
-{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}]
 
 === preallocation=off ===
 Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
-- 
2.25.3

From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>

This patch introduces support for PMR that has been defined as part of NVMe 1.4
spec. User can now specify a pmrdev option that should point to HostMemoryBackend.
pmrdev memory region will subsequently be exposed as PCI BAR 2 in emulated NVMe
device. Guest OS can perform mmio read and writes to the PMR region that will stay
persistent across system reboot.

Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20200330164656.9348-1-andrzej.jakowski@linux.intel.com>
Reviewed-by: Keith Busch <kbusch@kernel.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/block/nvme.h        |   2 +
 include/block/nvme.h   | 172 +++++++++++++++++++++++++++++++++++++++++
 hw/block/nvme.c        | 109 ++++++++++++++++++++++++++
 hw/block/Makefile.objs |   2 +-
 hw/block/trace-events  |   4 +
 5 files changed, 288 insertions(+), 1 deletion(-)

diff --git a/hw/block/nvme.h b/hw/block/nvme.h
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.h
+++ b/hw/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl {
     uint64_t    timestamp_set_qemu_clock_ms;    /* QEMU clock time */
 
     char            *serial;
+    HostMemoryBackend *pmrdev;
+
     NvmeNamespace   *namespaces;
     NvmeSQueue      **sq;
     NvmeCQueue      **cq;
diff --git a/include/block/nvme.h b/include/block/nvme.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/nvme.h
+++ b/include/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeBar {
     uint64_t    acq;
     uint32_t    cmbloc;
     uint32_t    cmbsz;
+    uint8_t     padding[3520]; /* not used by QEMU */
+    uint32_t    pmrcap;
+    uint32_t    pmrctl;
+    uint32_t    pmrsts;
+    uint32_t    pmrebs;
+    uint32_t    pmrswtp;
+    uint32_t    pmrmsc;
 } NvmeBar;
 
 enum NvmeCapShift {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapShift {
     CAP_CSS_SHIFT      = 37,
     CAP_MPSMIN_SHIFT   = 48,
     CAP_MPSMAX_SHIFT   = 52,
+    CAP_PMR_SHIFT      = 56,
 };
 
 enum NvmeCapMask {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
     CAP_CSS_MASK       = 0xff,
     CAP_MPSMIN_MASK    = 0xf,
     CAP_MPSMAX_MASK    = 0xf,
+    CAP_PMR_MASK       = 0x1,
 };
 
 #define NVME_CAP_MQES(cap)  (((cap) >> CAP_MQES_SHIFT)   & CAP_MQES_MASK)
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
                                                            << CAP_MPSMIN_SHIFT)
 #define NVME_CAP_SET_MPSMAX(cap, val) (cap |= (uint64_t)(val & CAP_MPSMAX_MASK)\
                                                             << CAP_MPSMAX_SHIFT)
+#define NVME_CAP_SET_PMRS(cap, val) (cap |= (uint64_t)(val & CAP_PMR_MASK)\
+                                                            << CAP_PMR_SHIFT)
 
 enum NvmeCcShift {
     CC_EN_SHIFT     = 0,
@@ -XXX,XX +XXX,XX @@ enum NvmeCmbszMask {
 #define NVME_CMBSZ_GETSIZE(cmbsz) \
     (NVME_CMBSZ_SZ(cmbsz) * (1 << (12 + 4 * NVME_CMBSZ_SZU(cmbsz))))
 
+enum NvmePmrcapShift {
+    PMRCAP_RDS_SHIFT      = 3,
+    PMRCAP_WDS_SHIFT      = 4,
+    PMRCAP_BIR_SHIFT      = 5,
+    PMRCAP_PMRTU_SHIFT    = 8,
+    PMRCAP_PMRWBM_SHIFT   = 10,
+    PMRCAP_PMRTO_SHIFT    = 16,
+    PMRCAP_CMSS_SHIFT     = 24,
+};
+
+enum NvmePmrcapMask {
+    PMRCAP_RDS_MASK      = 0x1,
+    PMRCAP_WDS_MASK      = 0x1,
+    PMRCAP_BIR_MASK      = 0x7,
+    PMRCAP_PMRTU_MASK    = 0x3,
+    PMRCAP_PMRWBM_MASK   = 0xf,
+    PMRCAP_PMRTO_MASK    = 0xff,
+    PMRCAP_CMSS_MASK     = 0x1,
+};
+
+#define NVME_PMRCAP_RDS(pmrcap)    \
+    ((pmrcap >> PMRCAP_RDS_SHIFT)   & PMRCAP_RDS_MASK)
+#define NVME_PMRCAP_WDS(pmrcap)    \
+    ((pmrcap >> PMRCAP_WDS_SHIFT)   & PMRCAP_WDS_MASK)
+#define NVME_PMRCAP_BIR(pmrcap)    \
+    ((pmrcap >> PMRCAP_BIR_SHIFT)   & PMRCAP_BIR_MASK)
+#define NVME_PMRCAP_PMRTU(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRTU_SHIFT)   & PMRCAP_PMRTU_MASK)
+#define NVME_PMRCAP_PMRWBM(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRWBM_SHIFT)   & PMRCAP_PMRWBM_MASK)
+#define NVME_PMRCAP_PMRTO(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRTO_SHIFT)   & PMRCAP_PMRTO_MASK)
+#define NVME_PMRCAP_CMSS(pmrcap)    \
+    ((pmrcap >> PMRCAP_CMSS_SHIFT)   & PMRCAP_CMSS_MASK)
+
+#define NVME_PMRCAP_SET_RDS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_RDS_MASK) << PMRCAP_RDS_SHIFT)
+#define NVME_PMRCAP_SET_WDS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_WDS_MASK) << PMRCAP_WDS_SHIFT)
+#define NVME_PMRCAP_SET_BIR(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_BIR_MASK) << PMRCAP_BIR_SHIFT)
+#define NVME_PMRCAP_SET_PMRTU(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTU_MASK) << PMRCAP_PMRTU_SHIFT)
+#define NVME_PMRCAP_SET_PMRWBM(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRWBM_MASK) << PMRCAP_PMRWBM_SHIFT)
+#define NVME_PMRCAP_SET_PMRTO(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTO_MASK) << PMRCAP_PMRTO_SHIFT)
+#define NVME_PMRCAP_SET_CMSS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_CMSS_MASK) << PMRCAP_CMSS_SHIFT)
+
+enum NvmePmrctlShift {
+    PMRCTL_EN_SHIFT   = 0,
+};
+
+enum NvmePmrctlMask {
+    PMRCTL_EN_MASK   = 0x1,
+};
+
+#define NVME_PMRCTL_EN(pmrctl)  ((pmrctl >> PMRCTL_EN_SHIFT)   & PMRCTL_EN_MASK)
+
+#define NVME_PMRCTL_SET_EN(pmrctl, val)   \
+    (pmrctl |= (uint64_t)(val & PMRCTL_EN_MASK) << PMRCTL_EN_SHIFT)
+
+enum NvmePmrstsShift {
+    PMRSTS_ERR_SHIFT    = 0,
+    PMRSTS_NRDY_SHIFT   = 8,
+    PMRSTS_HSTS_SHIFT   = 9,
+    PMRSTS_CBAI_SHIFT   = 12,
+};
+
+enum NvmePmrstsMask {
+    PMRSTS_ERR_MASK    = 0xff,
+    PMRSTS_NRDY_MASK   = 0x1,
+    PMRSTS_HSTS_MASK   = 0x7,
+    PMRSTS_CBAI_MASK   = 0x1,
+};
+
+#define NVME_PMRSTS_ERR(pmrsts)     \
+    ((pmrsts >> PMRSTS_ERR_SHIFT)   & PMRSTS_ERR_MASK)
+#define NVME_PMRSTS_NRDY(pmrsts)    \
+    ((pmrsts >> PMRSTS_NRDY_SHIFT)   & PMRSTS_NRDY_MASK)
+#define NVME_PMRSTS_HSTS(pmrsts)    \
+    ((pmrsts >> PMRSTS_HSTS_SHIFT)   & PMRSTS_HSTS_MASK)
+#define NVME_PMRSTS_CBAI(pmrsts)    \
+    ((pmrsts >> PMRSTS_CBAI_SHIFT)   & PMRSTS_CBAI_MASK)
+
+#define NVME_PMRSTS_SET_ERR(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_ERR_MASK) << PMRSTS_ERR_SHIFT)
+#define NVME_PMRSTS_SET_NRDY(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_NRDY_MASK) << PMRSTS_NRDY_SHIFT)
+#define NVME_PMRSTS_SET_HSTS(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_HSTS_MASK) << PMRSTS_HSTS_SHIFT)
+#define NVME_PMRSTS_SET_CBAI(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_CBAI_MASK) << PMRSTS_CBAI_SHIFT)
+
+enum NvmePmrebsShift {
+    PMREBS_PMRSZU_SHIFT   = 0,
+    PMREBS_RBB_SHIFT      = 4,
+    PMREBS_PMRWBZ_SHIFT   = 8,
+};
+
+enum NvmePmrebsMask {
+    PMREBS_PMRSZU_MASK   = 0xf,
+    PMREBS_RBB_MASK      = 0x1,
+    PMREBS_PMRWBZ_MASK   = 0xffffff,
+};
+
+#define NVME_PMREBS_PMRSZU(pmrebs)  \
+    ((pmrebs >> PMREBS_PMRSZU_SHIFT)   & PMREBS_PMRSZU_MASK)
+#define NVME_PMREBS_RBB(pmrebs)     \
+    ((pmrebs >> PMREBS_RBB_SHIFT)   & PMREBS_RBB_MASK)
+#define NVME_PMREBS_PMRWBZ(pmrebs)  \
+    ((pmrebs >> PMREBS_PMRWBZ_SHIFT)   & PMREBS_PMRWBZ_MASK)
+
+#define NVME_PMREBS_SET_PMRSZU(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_PMRSZU_MASK) << PMREBS_PMRSZU_SHIFT)
+#define NVME_PMREBS_SET_RBB(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_RBB_MASK) << PMREBS_RBB_SHIFT)
+#define NVME_PMREBS_SET_PMRWBZ(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_PMRWBZ_MASK) << PMREBS_PMRWBZ_SHIFT)
+
+enum NvmePmrswtpShift {
+    PMRSWTP_PMRSWTU_SHIFT   = 0,
+    PMRSWTP_PMRSWTV_SHIFT   = 8,
+};
+
+enum NvmePmrswtpMask {
+    PMRSWTP_PMRSWTU_MASK   = 0xf,
+    PMRSWTP_PMRSWTV_MASK   = 0xffffff,
+};
+
+#define NVME_PMRSWTP_PMRSWTU(pmrswtp)   \
+    ((pmrswtp >> PMRSWTP_PMRSWTU_SHIFT)   & PMRSWTP_PMRSWTU_MASK)
+#define NVME_PMRSWTP_PMRSWTV(pmrswtp)   \
+    ((pmrswtp >> PMRSWTP_PMRSWTV_SHIFT)   & PMRSWTP_PMRSWTV_MASK)
+
+#define NVME_PMRSWTP_SET_PMRSWTU(pmrswtp, val)   \
+    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTU_MASK) << PMRSWTP_PMRSWTU_SHIFT)
+#define NVME_PMRSWTP_SET_PMRSWTV(pmrswtp, val)   \
+    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTV_MASK) << PMRSWTP_PMRSWTV_SHIFT)
+
+enum NvmePmrmscShift {
+    PMRMSC_CMSE_SHIFT   = 1,
+    PMRMSC_CBA_SHIFT    = 12,
+};
+
+enum NvmePmrmscMask {
+    PMRMSC_CMSE_MASK   = 0x1,
+    PMRMSC_CBA_MASK    = 0xfffffffffffff,
+};
+
+#define NVME_PMRMSC_CMSE(pmrmsc)    \
+    ((pmrmsc >> PMRMSC_CMSE_SHIFT)   & PMRMSC_CMSE_MASK)
+#define NVME_PMRMSC_CBA(pmrmsc)     \
+    ((pmrmsc >> PMRMSC_CBA_SHIFT)   & PMRMSC_CBA_MASK)
+
+#define NVME_PMRMSC_SET_CMSE(pmrmsc, val)   \
+    (pmrmsc |= (uint64_t)(val & PMRMSC_CMSE_MASK) << PMRMSC_CMSE_SHIFT)
+#define NVME_PMRMSC_SET_CBA(pmrmsc, val)   \
+    (pmrmsc |= (uint64_t)(val & PMRMSC_CBA_MASK) << PMRMSC_CBA_SHIFT)
+
 typedef struct NvmeCmd {
     uint8_t     opcode;
     uint8_t     fuse;
diff --git a/hw/block/nvme.c b/hw/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.c
+++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@
  *      -drive file=<file>,if=none,id=<drive_id>
  *      -device nvme,drive=<drive_id>,serial=<serial>,id=<id[optional]>, \
  *              cmb_size_mb=<cmb_size_mb[optional]>, \
+ *              [pmrdev=<mem_backend_file_id>,] \
  *              num_queues=<N[optional]>
  *
  * Note cmb_size_mb denotes size of CMB in MB. CMB is assumed to be at
  * offset 0 in BAR2 and supports only WDS, RDS and SQS for now.
+ *
+ * cmb_size_mb= and pmrdev= options are mutually exclusive due to limitation
+ * in available BAR's. cmb_size_mb= will take precedence over pmrdev= when
+ * both provided.
+ * Enabling pmr emulation can be achieved by pointing to memory-backend-file.
+ * For example:
+ * -object memory-backend-file,id=<mem_id>,share=on,mem-path=<file_path>, \
+ *  size=<size> .... -device nvme,...,pmrdev=<mem_id>
  */
 
 #include "qemu/osdep.h"
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/sysemu.h"
 #include "qapi/error.h"
 #include "qapi/visitor.h"
+#include "sysemu/hostmem.h"
 #include "sysemu/block-backend.h"
+#include "exec/ram_addr.h"
 
 #include "qemu/log.h"
 #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
         NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly,
                        "invalid write to read only CMBSZ, ignored");
         return;
+    case 0xE00: /* PMRCAP */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrcap_readonly,
+                       "invalid write to PMRCAP register, ignored");
+        return;
+    case 0xE04: /* TODO PMRCTL */
+        break;
+    case 0xE08: /* PMRSTS */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrsts_readonly,
+                       "invalid write to PMRSTS register, ignored");
+        return;
+    case 0xE0C: /* PMREBS */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrebs_readonly,
+                       "invalid write to PMREBS register, ignored");
+        return;
+    case 0xE10: /* PMRSWTP */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrswtp_readonly,
+                       "invalid write to PMRSWTP register, ignored");
+        return;
+    case 0xE14: /* TODO PMRMSC */
+         break;
     default:
         NVME_GUEST_ERR(nvme_ub_mmiowr_invalid,
                        "invalid MMIO write,"
@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size)
     }
 
     if (addr < sizeof(n->bar)) {
+        /*
+         * When PMRWBM bit 1 is set then read from
+         * from PMRSTS should ensure prior writes
+         * made it to persistent media
+         */
+        if (addr == 0xE08 &&
+            (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) {
+            qemu_ram_writeback(n->pmrdev->mr.ram_block,
+                               0, n->pmrdev->size);
+        }
         memcpy(&val, ptr + addr, size);
     } else {
         NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs,
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
         error_setg(errp, "serial property not set");
         return;
     }
+
+    if (!n->cmb_size_mb && n->pmrdev) {
+        if (host_memory_backend_is_mapped(n->pmrdev)) {
+            char *path = object_get_canonical_path_component(OBJECT(n->pmrdev));
+            error_setg(errp, "can't use already busy memdev: %s", path);
+            g_free(path);
+            return;
+        }
+
+        if (!is_power_of_2(n->pmrdev->size)) {
+            error_setg(errp, "pmr backend size needs to be power of 2 in size");
+            return;
+        }
+
+        host_memory_backend_set_mapped(n->pmrdev, true);
+    }
+
     blkconf_blocksizes(&n->conf);
     if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),
                                        false, errp)) {
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
             PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
             PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem);
 
+    } else if (n->pmrdev) {
+        /* Controller Capabilities register */
+        NVME_CAP_SET_PMRS(n->bar.cap, 1);
+
+        /* PMR Capabities register */
+        n->bar.pmrcap = 0;
+        NVME_PMRCAP_SET_RDS(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_WDS(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_BIR(n->bar.pmrcap, 2);
+        NVME_PMRCAP_SET_PMRTU(n->bar.pmrcap, 0);
+        /* Turn on bit 1 support */
+        NVME_PMRCAP_SET_PMRWBM(n->bar.pmrcap, 0x02);
+        NVME_PMRCAP_SET_PMRTO(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_CMSS(n->bar.pmrcap, 0);
+
+        /* PMR Control register */
+        n->bar.pmrctl = 0;
+        NVME_PMRCTL_SET_EN(n->bar.pmrctl, 0);
+
+        /* PMR Status register */
+        n->bar.pmrsts = 0;
+        NVME_PMRSTS_SET_ERR(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_NRDY(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_HSTS(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_CBAI(n->bar.pmrsts, 0);
+
+        /* PMR Elasticity Buffer Size register */
+        n->bar.pmrebs = 0;
+        NVME_PMREBS_SET_PMRSZU(n->bar.pmrebs, 0);
+        NVME_PMREBS_SET_RBB(n->bar.pmrebs, 0);
+        NVME_PMREBS_SET_PMRWBZ(n->bar.pmrebs, 0);
+
+        /* PMR Sustained Write Throughput register */
+        n->bar.pmrswtp = 0;
+        NVME_PMRSWTP_SET_PMRSWTU(n->bar.pmrswtp, 0);
+        NVME_PMRSWTP_SET_PMRSWTV(n->bar.pmrswtp, 0);
+
+        /* PMR Memory Space Control register */
+        n->bar.pmrmsc = 0;
+        NVME_PMRMSC_SET_CMSE(n->bar.pmrmsc, 0);
+        NVME_PMRMSC_SET_CBA(n->bar.pmrmsc, 0);
+
+        pci_register_bar(pci_dev, NVME_PMRCAP_BIR(n->bar.pmrcap),
+            PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
+            PCI_BASE_ADDRESS_MEM_PREFETCH, &n->pmrdev->mr);
     }
 
     for (i = 0; i < n->num_namespaces; i++) {
@@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev)
     if (n->cmb_size_mb) {
         g_free(n->cmbuf);
     }
+
+    if (n->pmrdev) {
+        host_memory_backend_set_mapped(n->pmrdev, false);
+    }
     msix_uninit_exclusive_bar(pci_dev);
 }
 
 static Property nvme_props[] = {
     DEFINE_BLOCK_PROPERTIES(NvmeCtrl, conf),
+    DEFINE_PROP_LINK("pmrdev", NvmeCtrl, pmrdev, TYPE_MEMORY_BACKEND,
+                     HostMemoryBackend *),
     DEFINE_PROP_STRING("serial", NvmeCtrl, serial),
     DEFINE_PROP_UINT32("cmb_size_mb", NvmeCtrl, cmb_size_mb, 0),
     DEFINE_PROP_UINT32("num_queues", NvmeCtrl, num_queues, 64),
diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/Makefile.objs
+++ b/hw/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o
 common-obj-$(CONFIG_XEN) += xen-block.o
 common-obj-$(CONFIG_ECC) += ecc.o
 common-obj-$(CONFIG_ONENAND) += onenand.o
-common-obj-$(CONFIG_NVME_PCI) += nvme.o
 common-obj-$(CONFIG_SWIM) += swim.o
 
 common-obj-$(CONFIG_SH4) += tc58128.o
 
 obj-$(CONFIG_VIRTIO_BLK) += virtio-blk.o
 obj-$(CONFIG_VHOST_USER_BLK) += vhost-user-blk.o
+obj-$(CONFIG_NVME_PCI) += nvme.o
 
 obj-y += dataplane/
diff --git a/hw/block/trace-events b/hw/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/trace-events
+++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@ nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CA
 nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)"
 nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored"
 nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored"
+nvme_ub_mmiowr_pmrcap_readonly(void) "invalid write to read only PMRCAP, ignored"
+nvme_ub_mmiowr_pmrsts_readonly(void) "invalid write to read only PMRSTS, ignored"
+nvme_ub_mmiowr_pmrebs_readonly(void) "invalid write to read only PMREBS, ignored"
+nvme_ub_mmiowr_pmrswtp_readonly(void) "invalid write to read only PMRSWTP, ignored"
 nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64""
 nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64""
 nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64""
-- 
2.25.3

The QMP handler qmp_object_add() and the implementation of --object in
qemu-storage-daemon can share most of the code. Currently,
qemu-storage-daemon calls qmp_object_add(), but this is not correct
because different visitors need to be used.

As a first step towards a fix, make qmp_object_add() a wrapper around a
new function user_creatable_add_dict() that can get an additional
parameter. The handling of "props" is only required for compatibility
and not required for the qemu-storage-daemon command line, so it stays
in qmp_object_add().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qom/object_interfaces.h | 12 ++++++++++++
 qom/object_interfaces.c         | 27 +++++++++++++++++++++++++++
 qom/qom-qmp-cmds.c              | 24 +-----------------------
 3 files changed, 40 insertions(+), 23 deletions(-)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qom/object_interfaces.h
+++ b/include/qom/object_interfaces.h
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
                                 const QDict *qdict,
                                 Visitor *v, Error **errp);
 
+/**
+ * user_creatable_add_dict:
+ * @qdict: the object definition
+ * @errp: if an error occurs, a pointer to an area to store the error
+ *
+ * Create an instance of the user creatable object that is defined by
+ * @qdict.  The object type is taken from the QDict key 'qom-type', its
+ * ID from the key 'id'. The remaining entries in @qdict are used to
+ * initialize the object properties.
+ */
+void user_creatable_add_dict(QDict *qdict, Error **errp);
+
 /**
  * user_creatable_add_opts:
  * @opts: the object definition
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qmp/qerror.h"
 #include "qapi/qmp/qjson.h"
 #include "qapi/qmp/qstring.h"
+#include "qapi/qobject-input-visitor.h"
 #include "qom/object_interfaces.h"
 #include "qemu/help_option.h"
 #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ out:
     return obj;
 }
 
+void user_creatable_add_dict(QDict *qdict, Error **errp)
+{
+    Visitor *v;
+    Object *obj;
+    g_autofree char *type = NULL;
+    g_autofree char *id = NULL;
+
+    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
+    if (!type) {
+        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
+        return;
+    }
+    qdict_del(qdict, "qom-type");
+
+    id = g_strdup(qdict_get_try_str(qdict, "id"));
+    if (!id) {
+        error_setg(errp, QERR_MISSING_PARAMETER, "id");
+        return;
+    }
+    qdict_del(qdict, "id");
+
+    v = qobject_input_visitor_new(QOBJECT(qdict));
+    obj = user_creatable_add_type(type, id, qdict, v, errp);
+    visit_free(v);
+    object_unref(obj);
+}
 
 Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
 {
diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/qom-qmp-cmds.c
+++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qapi-commands-qom.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qerror.h"
-#include "qapi/qobject-input-visitor.h"
 #include "qemu/cutils.h"
 #include "qom/object_interfaces.h"
 #include "qom/qom-qobject.h"
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
 {
     QObject *props;
     QDict *pdict;
-    Visitor *v;
-    Object *obj;
-    g_autofree char *type = NULL;
-    g_autofree char *id = NULL;
-
-    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
-    if (!type) {
-        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
-        return;
-    }
-    qdict_del(qdict, "qom-type");
-
-    id = g_strdup(qdict_get_try_str(qdict, "id"));
-    if (!id) {
-        error_setg(errp, QERR_MISSING_PARAMETER, "id");
-        return;
-    }
-    qdict_del(qdict, "id");
 
     props = qdict_get(qdict, "props");
     if (props) {
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
         qobject_unref(pdict);
     }
 
-    v = qobject_input_visitor_new(QOBJECT(qdict));
-    obj = user_creatable_add_type(type, id, qdict, v, errp);
-    visit_free(v);
-    object_unref(obj);
+    user_creatable_add_dict(qdict, errp);
 }
 
 void qmp_object_del(const char *id, Error **errp)
-- 
2.25.3

After processing the option string with the keyval parser, we get a
QDict that contains only strings. This QDict must be fed to a keyval
visitor which converts the strings into the right data types.

qmp_object_add(), however, uses the normal QObject input visitor, which
expects a QDict where all properties already have the QType that matches
the data type required by the QOM object type.

Change the --object implementation in qemu-storage-daemon so that it
doesn't call qmp_object_add(), but calls user_creatable_add_dict()
directly instead and pass it a new keyval boolean that decides which
visitor must be used.

Reported-by: Coiby Xu <coiby.xu@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qom/object_interfaces.h | 6 +++++-
 qemu-storage-daemon.c           | 4 +---
 qom/object_interfaces.c         | 8 ++++++--
 qom/qom-qmp-cmds.c              | 2 +-
 4 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qom/object_interfaces.h
+++ b/include/qom/object_interfaces.h
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
 /**
  * user_creatable_add_dict:
  * @qdict: the object definition
+ * @keyval: if true, use a keyval visitor for processing @qdict (i.e.
+ *          assume that all @qdict values are strings); otherwise, use
+ *          the normal QObject visitor (i.e. assume all @qdict values
+ *          have the QType expected by the QOM object type)
  * @errp: if an error occurs, a pointer to an area to store the error
  *
  * Create an instance of the user creatable object that is defined by
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
  * ID from the key 'id'. The remaining entries in @qdict are used to
  * initialize the object properties.
  */
-void user_creatable_add_dict(QDict *qdict, Error **errp);
+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp);
 
 /**
  * user_creatable_add_opts:
diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-storage-daemon.c
+++ b/qemu-storage-daemon.c
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                 QemuOpts *opts;
                 const char *type;
                 QDict *args;
-                QObject *ret_data = NULL;
 
                 /* FIXME The keyval parser rejects 'help' arguments, so we must
                  * unconditionall try QemuOpts first. */
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                 qemu_opts_del(opts);
 
                 args = keyval_parse(optarg, "qom-type", &error_fatal);
-                qmp_object_add(args, &ret_data, &error_fatal);
+                user_creatable_add_dict(args, true, &error_fatal);
                 qobject_unref(args);
-                qobject_unref(ret_data);
                 break;
             }
         default:
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@ out:
     return obj;
 }
 
-void user_creatable_add_dict(QDict *qdict, Error **errp)
+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)
 {
     Visitor *v;
     Object *obj;
@@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp)
     }
     qdict_del(qdict, "id");
 
-    v = qobject_input_visitor_new(QOBJECT(qdict));
+    if (keyval) {
+        v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    } else {
+        v = qobject_input_visitor_new(QOBJECT(qdict));
+    }
     obj = user_creatable_add_type(type, id, qdict, v, errp);
     visit_free(v);
     object_unref(obj);
diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/qom-qmp-cmds.c
+++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
         qobject_unref(pdict);
     }
 
-    user_creatable_add_dict(qdict, errp);
+    user_creatable_add_dict(qdict, false, errp);
 }
 
 void qmp_object_del(const char *id, Error **errp)
-- 
2.25.3

The following changes since commit 2e3408b3cc7de4e87a9adafc8c19bfce3abec947:

Merge tag 'misc-pull-request' of gitlab.com:marcandre.lureau/qemu into staging (2022-05-03 09:13:17 -0700)

are available in the Git repository at:

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

for you to fetch changes up to c1fe694357a328c807ae3cc6961c19e923448fcc:

coroutine-win32: use QEMU_DEFINE_STATIC_CO_TLS() (2022-05-04 15:55:23 +0200)

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

- Fix and re-enable GLOBAL_STATE_CODE assertions
- vhost-user: Fixes for VHOST_USER_ADD/REM_MEM_REG
- vmdk: Fix reopening bs->file
- coroutine: use QEMU_DEFINE_STATIC_CO_TLS()
- docs/qemu-img: Fix list of formats which implement check

----------------------------------------------------------------
Denis V. Lunev (1):
      qemu-img: properly list formats which have consistency check implemented

Hanna Reitz (6):
      block: Classify bdrv_get_flags() as I/O function
      qcow2: Do not reopen data_file in invalidate_cache
      Revert "main-loop: Disable GLOBAL_STATE_CODE() assertions"
      iotests: Add regression test for issue 945
      block/vmdk: Fix reopening bs->file
      iotests/reopen-file: Test reopening file child

Kevin Wolf (3):
      docs/vhost-user: Clarifications for VHOST_USER_ADD/REM_MEM_REG
      libvhost-user: Fix extra vu_add/rem_mem_reg reply
      vhost-user: Don't pass file descriptor for VHOST_USER_REM_MEM_REG

Stefan Hajnoczi (3):
      coroutine-ucontext: use QEMU_DEFINE_STATIC_CO_TLS()
      coroutine: use QEMU_DEFINE_STATIC_CO_TLS()
      coroutine-win32: use QEMU_DEFINE_STATIC_CO_TLS()

docs/interop/vhost-user.rst                        |  17 ++++
 docs/tools/qemu-img.rst                            |   4 +-
 include/block/block-global-state.h                 |   1 -
 include/block/block-io.h                           |   1 +
 include/qemu/main-loop.h                           |   3 +-
 block.c                                            |   2 +-
 block/qcow2.c                                      | 104 ++++++++++++---------
 block/vmdk.c                                       |  56 ++++++++++-
 hw/virtio/vhost-user.c                             |   2 +-
 subprojects/libvhost-user/libvhost-user.c          |  17 ++--
 util/coroutine-ucontext.c                          |  38 +++++---
 util/coroutine-win32.c                             |  18 +++-
 util/qemu-coroutine.c                              |  41 ++++----
 tests/qemu-iotests/tests/export-incoming-iothread  |  81 ++++++++++++++++
 .../tests/export-incoming-iothread.out             |   5 +
 tests/qemu-iotests/tests/reopen-file               |  89 ++++++++++++++++++
 tests/qemu-iotests/tests/reopen-file.out           |   5 +
 17 files changed, 388 insertions(+), 96 deletions(-)
 create mode 100755 tests/qemu-iotests/tests/export-incoming-iothread
 create mode 100644 tests/qemu-iotests/tests/export-incoming-iothread.out
 create mode 100755 tests/qemu-iotests/tests/reopen-file
 create mode 100644 tests/qemu-iotests/tests/reopen-file.out

From: "Denis V. Lunev" <den@openvz.org>

Simple grep for the .bdrv_co_check callback presence gives the following
list of block drivers
* QED
* VDI
* VHDX
* VMDK
* Parallels
which have this callback. The presense of the callback means that
consistency check is supported.

The patch updates documentation accordingly.

Signed-off-by: Denis V. Lunev <den@openvz.org>
CC: Kevin Wolf <kwolf@redhat.com>
CC: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220407083932.531965-1-den@openvz.org>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 docs/tools/qemu-img.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/tools/qemu-img.rst b/docs/tools/qemu-img.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/tools/qemu-img.rst
+++ b/docs/tools/qemu-img.rst
@@ -XXX,XX +XXX,XX @@ Command description:
   ``-r all`` fixes all kinds of errors, with a higher risk of choosing the
   wrong fix or hiding corruption that has already occurred.
 
-  Only the formats ``qcow2``, ``qed`` and ``vdi`` support
-  consistency checks.
+  Only the formats ``qcow2``, ``qed``, ``parallels``, ``vhdx``, ``vmdk`` and
+  ``vdi`` support consistency checks.
 
   In case the image does not have any inconsistencies, check exits with ``0``.
   Other exit codes indicate the kind of inconsistency found or if another error
-- 
2.35.1

The specification for VHOST_USER_ADD/REM_MEM_REG messages is unclear
in several points, which has led to clients having incompatible
implementations. This changes the specification to be more explicit
about them:

* VHOST_USER_ADD_MEM_REG is not specified as receiving a file
  descriptor, though it obviously does need to do so. All
  implementations agree on this one, fix the specification.

* VHOST_USER_REM_MEM_REG is not specified as receiving a file
  descriptor either, and it also has no reason to do so. rust-vmm does
  not send file descriptors for removing a memory region (in agreement
  with the specification), libvhost-user and QEMU do (which is a bug),
  though libvhost-user doesn't actually make any use of it.

Change the specification so that for compatibility QEMU's behaviour
  becomes legal, even if discouraged, but rust-vmm's behaviour becomes
  the explicitly recommended mode of operation.

* VHOST_USER_ADD_MEM_REG doesn't have a documented return value, which
  is the desired behaviour in the non-postcopy case. It also implemented
  like this in QEMU and rust-vmm, though libvhost-user is buggy and
  sometimes sends an unexpected reply. This will be fixed in a separate
  patch.

However, in postcopy mode it does reply like VHOST_USER_SET_MEM_TABLE.
  This behaviour is shared between libvhost-user and QEMU; rust-vmm
  doesn't implement postcopy mode yet. Mention it explicitly in the
  spec.

* The specification doesn't mention how VHOST_USER_REM_MEM_REG
  identifies the memory region to be removed. Change it to describe the
  existing behaviour of libvhost-user (guest address, user address and
  size must match).

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20220407133657.155281-2-kwolf@redhat.com>
Reviewed-by: Raphael Norwitz <raphael.norwitz@nutanix.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 docs/interop/vhost-user.rst | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/docs/interop/vhost-user.rst b/docs/interop/vhost-user.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/vhost-user.rst
+++ b/docs/interop/vhost-user.rst
@@ -XXX,XX +XXX,XX @@ replies. Here is a list of the ones that do:
 There are several messages that the master sends with file descriptors passed
 in the ancillary data:
 
+* ``VHOST_USER_ADD_MEM_REG``
 * ``VHOST_USER_SET_MEM_TABLE``
 * ``VHOST_USER_SET_LOG_BASE`` (if ``VHOST_USER_PROTOCOL_F_LOG_SHMFD``)
 * ``VHOST_USER_SET_LOG_FD``
@@ -XXX,XX +XXX,XX @@ Master message types
   ``VHOST_USER_REM_MEM_REG`` message, this message is used to set and
   update the memory tables of the slave device.
 
+  Exactly one file descriptor from which the memory is mapped is
+  passed in the ancillary data.
+
+  In postcopy mode (see ``VHOST_USER_POSTCOPY_LISTEN``), the slave
+  replies with the bases of the memory mapped region to the master.
+  For further details on postcopy, see ``VHOST_USER_SET_MEM_TABLE``.
+  They apply to ``VHOST_USER_ADD_MEM_REG`` accordingly.
+
 ``VHOST_USER_REM_MEM_REG``
   :id: 38
   :equivalent ioctl: N/A
@@ -XXX,XX +XXX,XX @@ Master message types
   ``VHOST_USER_ADD_MEM_REG`` message, this message is used to set and
   update the memory tables of the slave device.
 
+  The memory region to be removed is identified by its guest address,
+  user address and size. The mmap offset is ignored.
+
+  No file descriptors SHOULD be passed in the ancillary data. For
+  compatibility with existing incorrect implementations, the slave MAY
+  accept messages with one file descriptor. If a file descriptor is
+  passed, the slave MUST close it without using it otherwise.
+
 ``VHOST_USER_SET_STATUS``
   :id: 39
   :equivalent ioctl: VHOST_VDPA_SET_STATUS
-- 
2.35.1

Outside of postcopy mode, neither VHOST_USER_ADD_MEM_REG nor
VHOST_USER_REM_MEM_REG are supposed to send a reply unless explicitly
requested with the need_reply flag. Their current implementation always
sends a reply, even if it isn't requested. This confuses the master
because it will interpret the reply as a reply for the next message for
which it actually expects a reply.

need_reply is already handled correctly by vu_dispatch(), so just don't
send a reply in the non-postcopy part of the message handler for these
two commands.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20220407133657.155281-3-kwolf@redhat.com>
Reviewed-by: Raphael Norwitz <raphael.norwitz@nutanix.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 subprojects/libvhost-user/libvhost-user.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/subprojects/libvhost-user/libvhost-user.c b/subprojects/libvhost-user/libvhost-user.c
index XXXXXXX..XXXXXXX 100644
--- a/subprojects/libvhost-user/libvhost-user.c
+++ b/subprojects/libvhost-user/libvhost-user.c
@@ -XXX,XX +XXX,XX @@ vu_add_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
 
         DPRINT("Successfully added new region\n");
         dev->nregions++;
-        vmsg_set_reply_u64(vmsg, 0);
-        return true;
+        return false;
     }
 }
 
@@ -XXX,XX +XXX,XX @@ vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
         }
     }
 
-    if (found) {
-        vmsg_set_reply_u64(vmsg, 0);
-    } else {
+    if (!found) {
         vu_panic(dev, "Specified region not found\n");
     }
 
     close(vmsg->fds[0]);
 
-    return true;
+    return false;
 }
 
 static bool
-- 
2.35.1

The spec clarifies now that QEMU should not send a file descriptor in a
request to remove a memory region. Change it accordingly.

For libvhost-user, this is a bug fix that makes it compatible with
rust-vmm's implementation that doesn't send a file descriptor. Keep
accepting, but ignoring a file descriptor for compatibility with older
QEMU versions.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20220407133657.155281-4-kwolf@redhat.com>
Reviewed-by: Raphael Norwitz <raphael.norwitz@nutanix.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/virtio/vhost-user.c                    | 2 +-
 subprojects/libvhost-user/libvhost-user.c | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -XXX,XX +XXX,XX @@ static int send_remove_regions(struct vhost_dev *dev,
             vhost_user_fill_msg_region(&region_buffer, shadow_reg, 0);
             msg->payload.mem_reg.region = region_buffer;
 
-            ret = vhost_user_write(dev, msg, &fd, 1);
+            ret = vhost_user_write(dev, msg, NULL, 0);
             if (ret < 0) {
                 return ret;
             }
diff --git a/subprojects/libvhost-user/libvhost-user.c b/subprojects/libvhost-user/libvhost-user.c
index XXXXXXX..XXXXXXX 100644
--- a/subprojects/libvhost-user/libvhost-user.c
+++ b/subprojects/libvhost-user/libvhost-user.c
@@ -XXX,XX +XXX,XX @@ vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
     int i;
     bool found = false;
 
-    if (vmsg->fd_num != 1) {
+    if (vmsg->fd_num > 1) {
         vmsg_close_fds(vmsg);
-        vu_panic(dev, "VHOST_USER_REM_MEM_REG received %d fds - only 1 fd "
+        vu_panic(dev, "VHOST_USER_REM_MEM_REG received %d fds - at most 1 fd "
                       "should be sent for this message type", vmsg->fd_num);
         return false;
     }
 
     if (vmsg->size < VHOST_USER_MEM_REG_SIZE) {
-        close(vmsg->fds[0]);
+        vmsg_close_fds(vmsg);
         vu_panic(dev, "VHOST_USER_REM_MEM_REG requires a message size of at "
                       "least %d bytes and only %d bytes were received",
                       VHOST_USER_MEM_REG_SIZE, vmsg->size);
@@ -XXX,XX +XXX,XX @@ vu_rem_mem_reg(VuDev *dev, VhostUserMsg *vmsg) {
         vu_panic(dev, "Specified region not found\n");
     }
 
-    close(vmsg->fds[0]);
+    vmsg_close_fds(vmsg);
 
     return false;
 }
-- 
2.35.1

From: Hanna Reitz <hreitz@redhat.com>

This function is safe to call in an I/O context, and qcow2_do_open()
does so (invoked in an I/O context by qcow2_co_invalidate_cache()).

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220427114057.36651-2-hreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block-global-state.h | 1 -
 include/block/block-io.h           | 1 +
 block.c                            | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/block/block-global-state.h b/include/block/block-global-state.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-global-state.h
+++ b/include/block/block-global-state.h
@@ -XXX,XX +XXX,XX @@ void bdrv_next_cleanup(BdrvNextIterator *it);
 BlockDriverState *bdrv_next_monitor_owned(BlockDriverState *bs);
 void bdrv_iterate_format(void (*it)(void *opaque, const char *name),
                          void *opaque, bool read_only);
-int bdrv_get_flags(BlockDriverState *bs);
 char *bdrv_get_full_backing_filename(BlockDriverState *bs, Error **errp);
 char *bdrv_dirname(BlockDriverState *bs, Error **errp);
 
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_apply_auto_read_only(BlockDriverState *bs, const char *errmsg,
 bool bdrv_is_read_only(BlockDriverState *bs);
 bool bdrv_is_writable(BlockDriverState *bs);
 bool bdrv_is_sg(BlockDriverState *bs);
+int bdrv_get_flags(BlockDriverState *bs);
 bool bdrv_is_inserted(BlockDriverState *bs);
 void bdrv_lock_medium(BlockDriverState *bs, bool locked);
 void bdrv_eject(BlockDriverState *bs, bool eject_flag);
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ const char *bdrv_get_device_or_node_name(const BlockDriverState *bs)
 
 int bdrv_get_flags(BlockDriverState *bs)
 {
-    GLOBAL_STATE_CODE();
+    IO_CODE();
     return bs->open_flags;
 }
 
-- 
2.35.1

From: Hanna Reitz <hreitz@redhat.com>

qcow2_co_invalidate_cache() closes and opens the qcow2 file, by calling
qcow2_close() and qcow2_do_open().  These two functions must thus be
usable from both a global-state and an I/O context.

As they are, they are not safe to call in an I/O context, because they
use bdrv_unref_child() and bdrv_open_child() to close/open the data_file
child, respectively, both of which are global-state functions.  When
used from qcow2_co_invalidate_cache(), we do not need to close/open the
data_file child, though (we do not do this for bs->file or bs->backing
either), and so we should skip it in the qcow2_co_invalidate_cache()
path.

To do so, add a parameter to qcow2_do_open() and qcow2_close() to make
them skip handling s->data_file, and have qcow2_co_invalidate_cache()
exempt it from the memset() on the BDRVQcow2State.

(Note that the QED driver similarly closes/opens the QED image by
invoking bdrv_qed_close()+bdrv_qed_do_open(), but both functions seem
safe to use in an I/O context.)

Fixes: https://gitlab.com/qemu-project/qemu/-/issues/945
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220427114057.36651-3-hreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 104 ++++++++++++++++++++++++++++++--------------------
 1 file changed, 62 insertions(+), 42 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 @@ static int validate_compression_type(BDRVQcow2State *s, Error **errp)
 
 /* Called with s->lock held.  */
 static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
-                                      int flags, Error **errp)
+                                      int flags, bool open_data_file,
+                                      Error **errp)
 {
     ERRP_GUARD();
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
         goto fail;
     }
 
-    /* Open external data file */
-    s->data_file = bdrv_open_child(NULL, options, "data-file", bs,
-                                   &child_of_bds, BDRV_CHILD_DATA,
-                                   true, errp);
-    if (*errp) {
-        ret = -EINVAL;
-        goto fail;
-    }
+    if (open_data_file) {
+        /* Open external data file */
+        s->data_file = bdrv_open_child(NULL, options, "data-file", bs,
+                                       &child_of_bds, BDRV_CHILD_DATA,
+                                       true, errp);
+        if (*errp) {
+            ret = -EINVAL;
+            goto fail;
+        }
 
-    if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
-        if (!s->data_file && s->image_data_file) {
-            s->data_file = bdrv_open_child(s->image_data_file, options,
-                                           "data-file", bs, &child_of_bds,
-                                           BDRV_CHILD_DATA, false, errp);
+        if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
+            if (!s->data_file && s->image_data_file) {
+                s->data_file = bdrv_open_child(s->image_data_file, options,
+                                               "data-file", bs, &child_of_bds,
+                                               BDRV_CHILD_DATA, false, errp);
+                if (!s->data_file) {
+                    ret = -EINVAL;
+                    goto fail;
+                }
+            }
             if (!s->data_file) {
+                error_setg(errp, "'data-file' is required for this image");
                 ret = -EINVAL;
                 goto fail;
             }
-        }
-        if (!s->data_file) {
-            error_setg(errp, "'data-file' is required for this image");
-            ret = -EINVAL;
-            goto fail;
-        }
 
-        /* No data here */
-        bs->file->role &= ~BDRV_CHILD_DATA;
+            /* No data here */
+            bs->file->role &= ~BDRV_CHILD_DATA;
 
-        /* Must succeed because we have given up permissions if anything */
-        bdrv_child_refresh_perms(bs, bs->file, &error_abort);
-    } else {
-        if (s->data_file) {
-            error_setg(errp, "'data-file' can only be set for images with an "
-                             "external data file");
-            ret = -EINVAL;
-            goto fail;
-        }
+            /* Must succeed because we have given up permissions if anything */
+            bdrv_child_refresh_perms(bs, bs->file, &error_abort);
+        } else {
+            if (s->data_file) {
+                error_setg(errp, "'data-file' can only be set for images with "
+                                 "an external data file");
+                ret = -EINVAL;
+                goto fail;
+            }
 
-        s->data_file = bs->file;
+            s->data_file = bs->file;
 
-        if (data_file_is_raw(bs)) {
-            error_setg(errp, "data-file-raw requires a data file");
-            ret = -EINVAL;
-            goto fail;
+            if (data_file_is_raw(bs)) {
+                error_setg(errp, "data-file-raw requires a data file");
+                ret = -EINVAL;
+                goto fail;
+            }
         }
     }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
 
  fail:
     g_free(s->image_data_file);
-    if (has_data_file(bs)) {
+    if (open_data_file && has_data_file(bs)) {
         bdrv_unref_child(bs, s->data_file);
         s->data_file = NULL;
     }
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qcow2_open_entry(void *opaque)
     BDRVQcow2State *s = qoc->bs->opaque;
 
     qemu_co_mutex_lock(&s->lock);
-    qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, qoc->errp);
+    qoc->ret = qcow2_do_open(qoc->bs, qoc->options, qoc->flags, true,
+                             qoc->errp);
     qemu_co_mutex_unlock(&s->lock);
 }
 
@@ -XXX,XX +XXX,XX @@ static int qcow2_inactivate(BlockDriverState *bs)
     return result;
 }
 
-static void qcow2_close(BlockDriverState *bs)
+static void qcow2_do_close(BlockDriverState *bs, bool close_data_file)
 {
     BDRVQcow2State *s = bs->opaque;
     qemu_vfree(s->l1_table);
@@ -XXX,XX +XXX,XX @@ static void qcow2_close(BlockDriverState *bs)
     g_free(s->image_backing_file);
     g_free(s->image_backing_format);
 
-    if (has_data_file(bs)) {
+    if (close_data_file && has_data_file(bs)) {
         bdrv_unref_child(bs, s->data_file);
         s->data_file = NULL;
     }
@@ -XXX,XX +XXX,XX @@ static void qcow2_close(BlockDriverState *bs)
     qcow2_free_snapshots(bs);
 }
 
+static void qcow2_close(BlockDriverState *bs)
+{
+    qcow2_do_close(bs, true);
+}
+
 static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
                                                    Error **errp)
 {
     ERRP_GUARD();
     BDRVQcow2State *s = bs->opaque;
+    BdrvChild *data_file;
     int flags = s->flags;
     QCryptoBlock *crypto = NULL;
     QDict *options;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qcow2_co_invalidate_cache(BlockDriverState *bs,
     crypto = s->crypto;
     s->crypto = NULL;
 
-    qcow2_close(bs);
+    /*
+     * Do not reopen s->data_file (i.e., have qcow2_do_close() not close it,
+     * and then prevent qcow2_do_open() from opening it), because this function
+     * runs in the I/O path and as such we must not invoke global-state
+     * functions like bdrv_unref_child() and bdrv_open_child().
+     */
 
+    qcow2_do_close(bs, false);
+
+    data_file = s->data_file;
     memset(s, 0, sizeof(BDRVQcow2State));
+    s->data_file = data_file;
+
     options = qdict_clone_shallow(bs->options);
 
     flags &= ~BDRV_O_INACTIVE;
     qemu_co_mutex_lock(&s->lock);
-    ret = qcow2_do_open(bs, options, flags, errp);
+    ret = qcow2_do_open(bs, options, flags, false, errp);
     qemu_co_mutex_unlock(&s->lock);
     qobject_unref(options);
     if (ret < 0) {
-- 
2.35.1

From: Hanna Reitz <hreitz@redhat.com>

This reverts commit b1c073490553f80594b903ceedfc7c1aef6b1b19.  (We
wanted to do so once the 7.1 tree opens, which has happened.  The issue
reported in https://gitlab.com/qemu-project/qemu/-/issues/945 should be
fixed by the preceding patches.)

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220427114057.36651-4-hreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qemu/main-loop.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

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 @@ bool qemu_in_main_thread(void);
 #else
 #define GLOBAL_STATE_CODE()                                         \
     do {                                                            \
-        /* FIXME: Re-enable after 7.0 release */                    \
-        /* assert(qemu_in_main_thread()); */                        \
+        assert(qemu_in_main_thread());                              \
     } while (0)
 #endif /* CONFIG_COCOA */
 
-- 
2.35.1

From: Hanna Reitz <hreitz@redhat.com>

Create a VM with a BDS in an iothread, add -incoming defer to the
command line, and then export this BDS via NBD.  Doing so should not
fail an assertion.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220427114057.36651-5-hreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 .../tests/export-incoming-iothread            | 81 +++++++++++++++++++
 .../tests/export-incoming-iothread.out        |  5 ++
 2 files changed, 86 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/export-incoming-iothread
 create mode 100644 tests/qemu-iotests/tests/export-incoming-iothread.out

diff --git a/tests/qemu-iotests/tests/export-incoming-iothread b/tests/qemu-iotests/tests/export-incoming-iothread
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/export-incoming-iothread
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+# group: rw quick migration
+#
+# Regression test for issue 945:
+# https://gitlab.com/qemu-project/qemu/-/issues/945
+# Test adding an export on top of an iothread-ed block device while in
+# -incoming defer.
+#
+# Copyright (C) 2022 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import os
+import iotests
+from iotests import qemu_img_create
+
+
+image_size = 1 * 1024 * 1024
+test_img = os.path.join(iotests.test_dir, 'test.img')
+node_name = 'node0'
+iothread_id = 'iothr0'
+
+nbd_sock = os.path.join(iotests.sock_dir, 'nbd.sock')
+
+
+class TestExportIncomingIothread(iotests.QMPTestCase):
+    def setUp(self) -> None:
+        qemu_img_create('-f', iotests.imgfmt, test_img, str(image_size))
+
+        self.vm = iotests.VM()
+        self.vm.add_object(f'iothread,id={iothread_id}')
+        self.vm.add_blockdev((
+            f'driver={iotests.imgfmt}',
+            f'node-name={node_name}',
+            'file.driver=file',
+            f'file.filename={test_img}'
+        ))
+        self.vm.add_incoming('defer')
+        self.vm.launch()
+
+    def tearDown(self):
+        self.vm.shutdown()
+        os.remove(test_img)
+
+    def test_export_add(self):
+        result = self.vm.qmp('nbd-server-start', {
+            'addr': {
+                'type': 'unix',
+                'data': {
+                    'path': nbd_sock
+                }
+            }
+        })
+        self.assert_qmp(result, 'return', {})
+
+        # Regression test for issue 945: This should not fail an assertion
+        result = self.vm.qmp('block-export-add', {
+            'type': 'nbd',
+            'id': 'exp0',
+            'node-name': node_name,
+            'iothread': iothread_id
+        })
+        self.assert_qmp(result, 'return', {})
+
+
+if __name__ == '__main__':
+    iotests.main(supported_fmts=['generic'],
+                 unsupported_fmts=['luks'], # Would need a secret
+                 supported_protocols=['file'])
diff --git a/tests/qemu-iotests/tests/export-incoming-iothread.out b/tests/qemu-iotests/tests/export-incoming-iothread.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/export-incoming-iothread.out
@@ -XXX,XX +XXX,XX @@
+.
+----------------------------------------------------------------------
+Ran 1 tests
+
+OK
-- 
2.35.1

From: Hanna Reitz <hreitz@redhat.com>

VMDK disk data is stored in extents, which may or may not be separate
from bs->file.  VmdkExtent.file points to where they are stored.  Each
that is stored in bs->file will simply reuse the exact pointer value of
bs->file.

(That is why vmdk_free_extents() will unref VmdkExtent.file (e->file)
only if e->file != bs->file.)

Reopen operations can change bs->file (they will replace the whole
BdrvChild object, not just the BDS stored in that BdrvChild), and then
we will need to change all .file pointers of all such VmdkExtents to
point to the new BdrvChild.

In vmdk_reopen_prepare(), we have to check which VmdkExtents are
affected, and in vmdk_reopen_commit(), we can modify them.  We have to
split this because:
- The new BdrvChild is created only after prepare, so we can change
  VmdkExtent.file only in commit
- In commit, there no longer is any (valid) reference to the old
  BdrvChild object, so there would be nothing to compare VmdkExtent.file
  against to see whether it was equal to bs->file before reopening
  (There is BDRVReopenState.old_file_bs, but the old bs->file
  BdrvChild's .bs pointer will be NULL-ed when the new BdrvChild is
  created, and so we cannot compare VmdkExtent.file->bs against
  BDRVReopenState.old_file_bs)

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220314162719.65384-2-hreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vmdk.c | 56 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)

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 @@ typedef struct BDRVVmdkState {
     char *create_type;
 } BDRVVmdkState;
 
+typedef struct BDRVVmdkReopenState {
+    bool *extents_using_bs_file;
+} BDRVVmdkReopenState;
+
 typedef struct VmdkMetaData {
     unsigned int l1_index;
     unsigned int l2_index;
@@ -XXX,XX +XXX,XX @@ static int vmdk_is_cid_valid(BlockDriverState *bs)
     return 1;
 }
 
-/* We have nothing to do for VMDK reopen, stubs just return success */
 static int vmdk_reopen_prepare(BDRVReopenState *state,
                                BlockReopenQueue *queue, Error **errp)
 {
+    BDRVVmdkState *s;
+    BDRVVmdkReopenState *rs;
+    int i;
+
     assert(state != NULL);
     assert(state->bs != NULL);
+    assert(state->opaque == NULL);
+
+    s = state->bs->opaque;
+
+    rs = g_new0(BDRVVmdkReopenState, 1);
+    state->opaque = rs;
+
+    /*
+     * Check whether there are any extents stored in bs->file; if bs->file
+     * changes, we will need to update their .file pointers to follow suit
+     */
+    rs->extents_using_bs_file = g_new(bool, s->num_extents);
+    for (i = 0; i < s->num_extents; i++) {
+        rs->extents_using_bs_file[i] = s->extents[i].file == state->bs->file;
+    }
+
     return 0;
 }
 
+static void vmdk_reopen_clean(BDRVReopenState *state)
+{
+    BDRVVmdkReopenState *rs = state->opaque;
+
+    g_free(rs->extents_using_bs_file);
+    g_free(rs);
+    state->opaque = NULL;
+}
+
+static void vmdk_reopen_commit(BDRVReopenState *state)
+{
+    BDRVVmdkState *s = state->bs->opaque;
+    BDRVVmdkReopenState *rs = state->opaque;
+    int i;
+
+    for (i = 0; i < s->num_extents; i++) {
+        if (rs->extents_using_bs_file[i]) {
+            s->extents[i].file = state->bs->file;
+        }
+    }
+
+    vmdk_reopen_clean(state);
+}
+
+static void vmdk_reopen_abort(BDRVReopenState *state)
+{
+    vmdk_reopen_clean(state);
+}
+
 static int vmdk_parent_open(BlockDriverState *bs)
 {
     char *p_name;
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_vmdk = {
     .bdrv_open                    = vmdk_open,
     .bdrv_co_check                = vmdk_co_check,
     .bdrv_reopen_prepare          = vmdk_reopen_prepare,
+    .bdrv_reopen_commit           = vmdk_reopen_commit,
+    .bdrv_reopen_abort            = vmdk_reopen_abort,
     .bdrv_child_perm              = bdrv_default_perms,
     .bdrv_co_preadv               = vmdk_co_preadv,
     .bdrv_co_pwritev              = vmdk_co_pwritev,
-- 
2.35.1

From: Hanna Reitz <hreitz@redhat.com>

This should work for all format drivers that support reopening, so test
it.

(This serves as a regression test for HEAD^: This test used to fail for
VMDK before HEAD^.)

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220314162719.65384-3-hreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/tests/reopen-file     | 89 ++++++++++++++++++++++++
 tests/qemu-iotests/tests/reopen-file.out |  5 ++
 2 files changed, 94 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/reopen-file
 create mode 100644 tests/qemu-iotests/tests/reopen-file.out

diff --git a/tests/qemu-iotests/tests/reopen-file b/tests/qemu-iotests/tests/reopen-file
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/reopen-file
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+# group: rw quick
+#
+# Test reopening a format driver's file child
+#
+# Copyright (C) 2022 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import os
+import iotests
+from iotests import imgfmt, qemu_img_create, QMPTestCase
+
+
+image_size = 1 * 1024 * 1024
+test_img = os.path.join(iotests.test_dir, 'test.img')
+
+
+class TestReopenFile(QMPTestCase):
+    def setUp(self) -> None:
+        res = qemu_img_create('-f', imgfmt, test_img, str(image_size))
+        assert res.returncode == 0
+
+        # Add format driver node ('format') on top of the file ('file'), then
+        # add another raw node ('raw') on top of 'file' so for the reopen we
+        # can just switch from 'file' to 'raw'
+        self.vm = iotests.VM()
+        self.vm.add_blockdev(self.vm.qmp_to_opts({
+            'driver': imgfmt,
+            'node-name': 'format',
+            'file': {
+                'driver': 'file',
+                'node-name': 'file',
+                'filename': test_img
+            }
+        }))
+        self.vm.add_blockdev(self.vm.qmp_to_opts({
+            'driver': 'raw',
+            'node-name': 'raw',
+            'file': 'file'
+        }))
+        self.vm.launch()
+
+    def tearDown(self) -> None:
+        self.vm.shutdown()
+        os.remove(test_img)
+
+        # Check if there was any qemu-io run that failed
+        if 'Pattern verification failed' in self.vm.get_log():
+            print('ERROR: Pattern verification failed:')
+            print(self.vm.get_log())
+            self.fail('qemu-io pattern verification failed')
+
+    def test_reopen_file(self) -> None:
+        result = self.vm.qmp('blockdev-reopen', options=[{
+            'driver': imgfmt,
+            'node-name': 'format',
+            'file': 'raw'
+        }])
+        self.assert_qmp(result, 'return', {})
+
+        # Do some I/O to the image to see whether it still works
+        # (Pattern verification will be checked by tearDown())
+        result = self.vm.qmp('human-monitor-command',
+                             command_line='qemu-io format "write -P 42 0 64k"')
+        self.assert_qmp(result, 'return', '')
+
+        result = self.vm.qmp('human-monitor-command',
+                             command_line='qemu-io format "read -P 42 0 64k"')
+        self.assert_qmp(result, 'return', '')
+
+
+if __name__ == '__main__':
+    # Must support creating images and reopen
+    iotests.main(supported_fmts=['qcow', 'qcow2', 'qed', 'raw', 'vdi', 'vhdx',
+                                 'vmdk', 'vpc'],
+                 supported_protocols=['file'])
diff --git a/tests/qemu-iotests/tests/reopen-file.out b/tests/qemu-iotests/tests/reopen-file.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/reopen-file.out
@@ -XXX,XX +XXX,XX @@
+.
+----------------------------------------------------------------------
+Ran 1 tests
+
+OK
-- 
2.35.1

From: Stefan Hajnoczi <stefanha@redhat.com>

Thread-Local Storage variables cannot be used directly from coroutine
code because the compiler may optimize TLS variable accesses across
qemu_coroutine_yield() calls. When the coroutine is re-entered from
another thread the TLS variables from the old thread must no longer be
used.

Use QEMU_DEFINE_STATIC_CO_TLS() for the current and leader variables.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20220307153853.602859-2-stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 util/coroutine-ucontext.c | 38 ++++++++++++++++++++++++--------------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/util/coroutine-ucontext.c b/util/coroutine-ucontext.c
index XXXXXXX..XXXXXXX 100644
--- a/util/coroutine-ucontext.c
+++ b/util/coroutine-ucontext.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include <ucontext.h>
 #include "qemu/coroutine_int.h"
+#include "qemu/coroutine-tls.h"
 
 #ifdef CONFIG_VALGRIND_H
 #include <valgrind/valgrind.h>
@@ -XXX,XX +XXX,XX @@ typedef struct {
 /**
  * Per-thread coroutine bookkeeping
  */
-static __thread CoroutineUContext leader;
-static __thread Coroutine *current;
+QEMU_DEFINE_STATIC_CO_TLS(Coroutine *, current);
+QEMU_DEFINE_STATIC_CO_TLS(CoroutineUContext, leader);
 
 /*
  * va_args to makecontext() must be type 'int', so passing
@@ -XXX,XX +XXX,XX @@ static inline __attribute__((always_inline))
 void finish_switch_fiber(void *fake_stack_save)
 {
 #ifdef CONFIG_ASAN
+    CoroutineUContext *leaderp = get_ptr_leader();
     const void *bottom_old;
     size_t size_old;
 
     __sanitizer_finish_switch_fiber(fake_stack_save, &bottom_old, &size_old);
 
-    if (!leader.stack) {
-        leader.stack = (void *)bottom_old;
-        leader.stack_size = size_old;
+    if (!leaderp->stack) {
+        leaderp->stack = (void *)bottom_old;
+        leaderp->stack_size = size_old;
     }
 #endif
 #ifdef CONFIG_TSAN
@@ -XXX,XX +XXX,XX @@ static void coroutine_trampoline(int i0, int i1)
 
     /* Initialize longjmp environment and switch back the caller */
     if (!sigsetjmp(self->env, 0)) {
-        start_switch_fiber_asan(COROUTINE_YIELD, &fake_stack_save, leader.stack,
-                                leader.stack_size);
+        CoroutineUContext *leaderp = get_ptr_leader();
+
+        start_switch_fiber_asan(COROUTINE_YIELD, &fake_stack_save,
+                                leaderp->stack, leaderp->stack_size);
         start_switch_fiber_tsan(&fake_stack_save, self, true); /* true=caller */
         siglongjmp(*(sigjmp_buf *)co->entry_arg, 1);
     }
@@ -XXX,XX +XXX,XX @@ qemu_coroutine_switch(Coroutine *from_, Coroutine *to_,
     int ret;
     void *fake_stack_save = NULL;
 
-    current = to_;
+    set_current(to_);
 
     ret = sigsetjmp(from->env, 0);
     if (ret == 0) {
@@ -XXX,XX +XXX,XX @@ qemu_coroutine_switch(Coroutine *from_, Coroutine *to_,
 
 Coroutine *qemu_coroutine_self(void)
 {
-    if (!current) {
-        current = &leader.base;
+    Coroutine *self = get_current();
+    CoroutineUContext *leaderp = get_ptr_leader();
+
+    if (!self) {
+        self = &leaderp->base;
+        set_current(self);
     }
 #ifdef CONFIG_TSAN
-    if (!leader.tsan_co_fiber) {
-        leader.tsan_co_fiber = __tsan_get_current_fiber();
+    if (!leaderp->tsan_co_fiber) {
+        leaderp->tsan_co_fiber = __tsan_get_current_fiber();
     }
 #endif
-    return current;
+    return self;
 }
 
 bool qemu_in_coroutine(void)
 {
-    return current && current->caller;
+    Coroutine *self = get_current();
+
+    return self && self->caller;
 }
-- 
2.35.1

From: Stefan Hajnoczi <stefanha@redhat.com>

Use QEMU_DEFINE_STATIC_CO_TLS() for the current and leader variables.
The alloc_pool QSLIST needs a typedef so the return value of
get_ptr_alloc_pool() can be stored in a local variable.

One example of why this code is necessary: a coroutine that yields
before calling qemu_coroutine_create() to create another coroutine is
affected by the TLS issue.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20220307153853.602859-3-stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 util/qemu-coroutine.c | 41 ++++++++++++++++++++++++-----------------
 1 file changed, 24 insertions(+), 17 deletions(-)

diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine.c
+++ b/util/qemu-coroutine.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/atomic.h"
 #include "qemu/coroutine.h"
 #include "qemu/coroutine_int.h"
+#include "qemu/coroutine-tls.h"
 #include "block/aio.h"
 
 /** Initial batch size is 64, and is increased on demand */
@@ -XXX,XX +XXX,XX @@ enum {
 static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool);
 static unsigned int pool_batch_size = POOL_INITIAL_BATCH_SIZE;
 static unsigned int release_pool_size;
-static __thread QSLIST_HEAD(, Coroutine) alloc_pool = QSLIST_HEAD_INITIALIZER(pool);
-static __thread unsigned int alloc_pool_size;
-static __thread Notifier coroutine_pool_cleanup_notifier;
+
+typedef QSLIST_HEAD(, Coroutine) CoroutineQSList;
+QEMU_DEFINE_STATIC_CO_TLS(CoroutineQSList, alloc_pool);
+QEMU_DEFINE_STATIC_CO_TLS(unsigned int, alloc_pool_size);
+QEMU_DEFINE_STATIC_CO_TLS(Notifier, coroutine_pool_cleanup_notifier);
 
 static void coroutine_pool_cleanup(Notifier *n, void *value)
 {
     Coroutine *co;
     Coroutine *tmp;
+    CoroutineQSList *alloc_pool = get_ptr_alloc_pool();
 
-    QSLIST_FOREACH_SAFE(co, &alloc_pool, pool_next, tmp) {
-        QSLIST_REMOVE_HEAD(&alloc_pool, pool_next);
+    QSLIST_FOREACH_SAFE(co, alloc_pool, pool_next, tmp) {
+        QSLIST_REMOVE_HEAD(alloc_pool, pool_next);
         qemu_coroutine_delete(co);
     }
 }
@@ -XXX,XX +XXX,XX @@ Coroutine *qemu_coroutine_create(CoroutineEntry *entry, void *opaque)
     Coroutine *co = NULL;
 
     if (CONFIG_COROUTINE_POOL) {
-        co = QSLIST_FIRST(&alloc_pool);
+        CoroutineQSList *alloc_pool = get_ptr_alloc_pool();
+
+        co = QSLIST_FIRST(alloc_pool);
         if (!co) {
             if (release_pool_size > qatomic_read(&pool_batch_size)) {
                 /* Slow path; a good place to register the destructor, too.  */
-                if (!coroutine_pool_cleanup_notifier.notify) {
-                    coroutine_pool_cleanup_notifier.notify = coroutine_pool_cleanup;
-                    qemu_thread_atexit_add(&coroutine_pool_cleanup_notifier);
+                Notifier *notifier = get_ptr_coroutine_pool_cleanup_notifier();
+                if (!notifier->notify) {
+                    notifier->notify = coroutine_pool_cleanup;
+                    qemu_thread_atexit_add(notifier);
                 }
 
                 /* This is not exact; there could be a little skew between
                  * release_pool_size and the actual size of release_pool.  But
                  * it is just a heuristic, it does not need to be perfect.
                  */
-                alloc_pool_size = qatomic_xchg(&release_pool_size, 0);
-                QSLIST_MOVE_ATOMIC(&alloc_pool, &release_pool);
-                co = QSLIST_FIRST(&alloc_pool);
+                set_alloc_pool_size(qatomic_xchg(&release_pool_size, 0));
+                QSLIST_MOVE_ATOMIC(alloc_pool, &release_pool);
+                co = QSLIST_FIRST(alloc_pool);
             }
         }
         if (co) {
-            QSLIST_REMOVE_HEAD(&alloc_pool, pool_next);
-            alloc_pool_size--;
+            QSLIST_REMOVE_HEAD(alloc_pool, pool_next);
+            set_alloc_pool_size(get_alloc_pool_size() - 1);
         }
     }
 
@@ -XXX,XX +XXX,XX @@ static void coroutine_delete(Coroutine *co)
             qatomic_inc(&release_pool_size);
             return;
         }
-        if (alloc_pool_size < qatomic_read(&pool_batch_size)) {
-            QSLIST_INSERT_HEAD(&alloc_pool, co, pool_next);
-            alloc_pool_size++;
+        if (get_alloc_pool_size() < qatomic_read(&pool_batch_size)) {
+            QSLIST_INSERT_HEAD(get_ptr_alloc_pool(), co, pool_next);
+            set_alloc_pool_size(get_alloc_pool_size() + 1);
             return;
         }
     }
-- 
2.35.1

From: Stefan Hajnoczi <stefanha@redhat.com>

Use QEMU_DEFINE_STATIC_CO_TLS() for the current and leader variables.

I think coroutine-win32.c could get away with __thread because the
variables are only used in situations where either the stale value is
correct (current) or outside coroutine context (loading leader when
current is NULL). Due to the difficulty of being sure that this is
really safe in all scenarios it seems worth converting it anyway.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20220307153853.602859-4-stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 util/coroutine-win32.c | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/util/coroutine-win32.c b/util/coroutine-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/util/coroutine-win32.c
+++ b/util/coroutine-win32.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "qemu/coroutine_int.h"
+#include "qemu/coroutine-tls.h"
 
 typedef struct
 {
@@ -XXX,XX +XXX,XX @@ typedef struct
     CoroutineAction action;
 } CoroutineWin32;
 
-static __thread CoroutineWin32 leader;
-static __thread Coroutine *current;
+QEMU_DEFINE_STATIC_CO_TLS(CoroutineWin32, leader);
+QEMU_DEFINE_STATIC_CO_TLS(Coroutine *, current);
 
 /* This function is marked noinline to prevent GCC from inlining it
  * into coroutine_trampoline(). If we allow it to do that then it
@@ -XXX,XX +XXX,XX @@ qemu_coroutine_switch(Coroutine *from_, Coroutine *to_,
     CoroutineWin32 *from = DO_UPCAST(CoroutineWin32, base, from_);
     CoroutineWin32 *to = DO_UPCAST(CoroutineWin32, base, to_);
 
-    current = to_;
+    set_current(to_);
 
     to->action = action;
     SwitchToFiber(to->fiber);
@@ -XXX,XX +XXX,XX @@ void qemu_coroutine_delete(Coroutine *co_)
 
 Coroutine *qemu_coroutine_self(void)
 {
+    Coroutine *current = get_current();
+
     if (!current) {
-        current = &leader.base;
-        leader.fiber = ConvertThreadToFiber(NULL);
+        CoroutineWin32 *leader = get_ptr_leader();
+
+        current = &leader->base;
+        set_current(current);
+        leader->fiber = ConvertThreadToFiber(NULL);
     }
     return current;
 }
 
 bool qemu_in_coroutine(void)
 {
+    Coroutine *current = get_current();
+
     return current && current->caller;
 }
-- 
2.35.1