Series comparison

-[Qemu-devel] [PULL 00/11] Block patches
+[Qemu-devel] [PULL 00/27] Block patches
-The following changes since commit 19b599f7664b2ebfd0f405fb79c14dd241557452:
+The following changes since commit fc3dbb90f2eb069801bfb4cfe9cbc83cf9c5f4a9:
-  Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2018-08-27-v2' into staging (2018-08-27 16:44:20 +0100)
+  Merge remote-tracking branch 'remotes/jnsnow/tags/bitmaps-pull-request' into staging (2019-02-21 13:09:33 +0000)
 are available in the Git repository at:
-  https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2018-08-31
+  git://github.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 40954cc7831c4f95f9ce6402ae3d6761f44f31ff:
+for you to fetch changes up to 9a9f4b74fa547b68edb38fa414999836770a4735:
-  jobs: remove job_defer_to_main_loop (2018-08-31 16:11:27 +0200)
+  tests/virtio-blk: add test for DISCARD command (2019-02-22 09:42:17 +0000)
 ----------------------------------------------------------------
-Block patches:
+Pull request
 - (Block) job exit refactoring, part 1
   (removing job_defer_to_main_loop())
 - Locking fix for the file-posix block driver
 - test-bdrv-drain leak fix
 ----------------------------------------------------------------
-Fam Zheng (1):
-  file-posix: Skip effectiveless OFD lock operations
-John Snow (9):
+Stefano Garzarella (10):
-  jobs: change start callback to run callback
+  virtio-blk: add acct_failed param to virtio_blk_handle_rw_error()
-  jobs: canonize Error object
+  virtio-blk: add host_features field in VirtIOBlock
-  jobs: add exit shim
+  virtio-blk: add "discard" and "write-zeroes" properties
-  block/commit: utilize job_exit shim
+  virtio-net: make VirtIOFeature usable for other virtio devices
-  block/mirror: utilize job_exit shim
+  virtio-blk: set config size depending on the features enabled
-  jobs: utilize job_exit shim
+  virtio-blk: add DISCARD and WRITE_ZEROES features
-  block/backup: make function variables consistently named
+  tests/virtio-blk: change assert on data_size in virtio_blk_request()
-  jobs: remove ret argument to job_completed; privatize it
+  tests/virtio-blk: add virtio_blk_fix_dwz_hdr() function
-  jobs: remove job_defer_to_main_loop
+  tests/virtio-blk: add test for WRITE_ZEROES command
   tests/virtio-blk: add test for DISCARD command
-Marc-André Lureau (1):
+Vladimir Sementsov-Ogievskiy (17):
-  tests: fix bdrv-drain leak
+  block: enhance QEMUIOVector structure
   block/io: use qemu_iovec_init_buf
   block/block-backend: use QEMU_IOVEC_INIT_BUF
   block/backup: use qemu_iovec_init_buf
   block/commit: use QEMU_IOVEC_INIT_BUF
   block/stream: use QEMU_IOVEC_INIT_BUF
   block/parallels: use QEMU_IOVEC_INIT_BUF
   block/qcow: use qemu_iovec_init_buf
   block/qcow2: use qemu_iovec_init_buf
   block/qed: use qemu_iovec_init_buf
   block/vmdk: use qemu_iovec_init_buf
   qemu-img: use qemu_iovec_init_buf
   migration/block: use qemu_iovec_init_buf
   tests/test-bdrv-drain: use QEMU_IOVEC_INIT_BUF
   hw/ide: drop iov field from IDEState
   hw/ide: drop iov field from IDEBufferedRequest
   hw/ide: drop iov field from IDEDMA
- include/qemu/job.h        | 70 ++++++++++++++++-----------------
+ include/hw/ide/internal.h      |   3 -
- block/backup.c            | 81 ++++++++++++++++-----------------------
+ include/hw/virtio/virtio-blk.h |   6 +-
- block/commit.c            | 29 +++++---------
+ include/hw/virtio/virtio.h     |  15 ++
- block/create.c            | 19 +++------
+ include/qemu/iov.h             |  64 ++++++++-
- block/file-posix.c        | 41 +++++++++++++++-----
+ block/backup.c                 |   5 +-
- block/mirror.c            | 39 ++++++++-----------
+ block/block-backend.c          |  13 +-
- block/stream.c            | 29 ++++++--------
+ block/commit.c                 |   7 +-
- job-qmp.c                 |  5 ++-
+ block/io.c                     |  89 +++---------
- job.c                     | 73 ++++++++++++-----------------------
+ block/parallels.c              |  13 +-
- tests/test-bdrv-drain.c   | 14 +++----
+ block/qcow.c                   |  21 +--
- tests/test-blockjob-txn.c | 25 +++++-------
+ block/qcow2.c                  |  12 +-
- tests/test-blockjob.c     | 17 ++++----
+ block/qed-table.c              |  16 +--
- trace-events              |  2 +-
+ block/qed.c                    |  31 ++---
-files changed, 192 insertions(+), 252 deletions(-)
+ block/stream.c                 |   7 +-
  block/vmdk.c                   |   7 +-
  hw/block/virtio-blk.c          | 245 ++++++++++++++++++++++++++++++---
  hw/core/machine.c              |   2 +
  hw/ide/atapi.c                 |  14 +-
  hw/ide/core.c                  |  19 ++-
  hw/net/virtio-net.c            |  31 +----
  hw/virtio/virtio.c             |  15 ++
  migration/block.c              |  10 +-
  qemu-img.c                     |  10 +-
  tests/test-bdrv-drain.c        |  29 +---
  tests/virtio-blk-test.c        | 127 ++++++++++++++++-
 files changed, 525 insertions(+), 286 deletions(-)
 --
-.17.1
+.20.1

-New patch
+[Qemu-devel] [PULL 01/27] block: enhance QEMUIOVector structure
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Add a possibility of embedded iovec, for cases when we need only one
+local iov.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Message-id: 20190218140926.333779-2-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-2-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ include/qemu/iov.h | 64 ++++++++++++++++++++++++++++++++++++++++++++--
+file changed, 62 insertions(+), 2 deletions(-)
+diff --git a/include/qemu/iov.h b/include/qemu/iov.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/qemu/iov.h
++++ b/include/qemu/iov.h
+@@ -XXX,XX +XXX,XX @@ size_t iov_discard_back(struct iovec *iov, unsigned int *iov_cnt,
+ typedef struct QEMUIOVector {
+     struct iovec *iov;
+     int niov;
+-    int nalloc;
+-    size_t size;
++
++    /*
++     * For external @iov (qemu_iovec_init_external()) or allocated @iov
++     * (qemu_iovec_init()), @size is the cumulative size of iovecs and
++     * @local_iov is invalid and unused.
++     *
++     * For embedded @iov (QEMU_IOVEC_INIT_BUF() or qemu_iovec_init_buf()),
++     * @iov is equal to &@local_iov, and @size is valid, as it has same
++     * offset and type as @local_iov.iov_len, which is guaranteed by
++     * static assertion below.
++     *
++     * @nalloc is always valid and is -1 both for embedded and external
++     * cases. It is included in the union only to ensure the padding prior
++     * to the @size field will not result in a 0-length array.
++     */
++    union {
++        struct {
++            int nalloc;
++            struct iovec local_iov;
++        };
++        struct {
++            char __pad[sizeof(int) + offsetof(struct iovec, iov_len)];
++            size_t size;
++        };
++    };
+ } QEMUIOVector;
++QEMU_BUILD_BUG_ON(offsetof(QEMUIOVector, size) !=
++                  offsetof(QEMUIOVector, local_iov.iov_len));
++
++#define QEMU_IOVEC_INIT_BUF(self, buf, len)              \
++{                                                        \
++    .iov = &(self).local_iov,                            \
++    .niov = 1,                                           \
++    .nalloc = -1,                                        \
++    .local_iov = {                                       \
++        .iov_base = (void *)(buf), /* cast away const */ \
++        .iov_len = (len),                                \
++    },                                                   \
++}
++
++/*
++ * qemu_iovec_init_buf
++ *
++ * Initialize embedded QEMUIOVector.
++ *
++ * Note: "const" is used over @buf pointer to make it simple to pass
++ * const pointers, appearing in read functions. Then this "const" is
++ * cast away by QEMU_IOVEC_INIT_BUF().
++ */
++static inline void qemu_iovec_init_buf(QEMUIOVector *qiov,
++                                       const void *buf, size_t len)
++{
++    *qiov = (QEMUIOVector) QEMU_IOVEC_INIT_BUF(*qiov, buf, len);
++}
++
++static inline void *qemu_iovec_buf(QEMUIOVector *qiov)
++{
++    /* Only supports embedded iov */
++    assert(qiov->nalloc == -1 && qiov->iov == &qiov->local_iov);
++
++    return qiov->local_iov.iov_base;
++}
++
+ void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
+ void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
+ void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
+--
+.20.1

-New patch
+[Qemu-devel] [PULL 02/27] block/io: use qemu_iovec_init_buf
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Use new qemu_iovec_init_buf() instead of
 qemu_iovec_init_external( ... , 1), which simplifies the code.
 While being here, use qemu_try_blockalign0 as well.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20190218140926.333779-3-vsementsov@virtuozzo.com
 Message-Id: <20190218140926.333779-3-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  block/io.c | 89 ++++++++++++------------------------------------------
 file changed, 20 insertions(+), 69 deletions(-)
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static int bdrv_prwv_co(BdrvChild *child, int64_t offset,
  static int bdrv_rw_co(BdrvChild *child, int64_t sector_num, uint8_t *buf,
                        int nb_sectors, bool is_write, BdrvRequestFlags flags)
  {
 -    QEMUIOVector qiov;
 -    struct iovec iov = {
 -        .iov_base = (void *)buf,
 -        .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
 -    };
 +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf,
 +                                            nb_sectors * BDRV_SECTOR_SIZE);
      if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
          return -EINVAL;
      }
 -    qemu_iovec_init_external(&qiov, &iov, 1);
      return bdrv_prwv_co(child, sector_num << BDRV_SECTOR_BITS,
                          &qiov, is_write, flags);
  }
@@ -XXX,XX +XXX,XX @@ int bdrv_write(BdrvChild *child, int64_t sector_num,
  int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
                         int bytes, BdrvRequestFlags flags)
  {
 -    QEMUIOVector qiov;
 -    struct iovec iov = {
 -        .iov_base = NULL,
 -        .iov_len = bytes,
 -    };
 +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, bytes);
 -    qemu_iovec_init_external(&qiov, &iov, 1);
      return bdrv_prwv_co(child, offset, &qiov, true,
                          BDRV_REQ_ZERO_WRITE | flags);
  }
@@ -XXX,XX +XXX,XX @@ int bdrv_preadv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov)
  int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int bytes)
  {
 -    QEMUIOVector qiov;
 -    struct iovec iov = {
 -        .iov_base = (void *)buf,
 -        .iov_len = bytes,
 -    };
 +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
      if (bytes < 0) {
          return -EINVAL;
      }
 -    qemu_iovec_init_external(&qiov, &iov, 1);
      return bdrv_preadv(child, offset, &qiov);
  }
@@ -XXX,XX +XXX,XX @@ int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov)
  int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf, int bytes)
  {
 -    QEMUIOVector qiov;
 -    struct iovec iov = {
 -        .iov_base   = (void *) buf,
 -        .iov_len    = bytes,
 -    };
 +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
      if (bytes < 0) {
          return -EINVAL;
      }
 -    qemu_iovec_init_external(&qiov, &iov, 1);
      return bdrv_pwritev(child, offset, &qiov);
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
      void *bounce_buffer;
      BlockDriver *drv = bs->drv;
 -    struct iovec iov;
      QEMUIOVector local_qiov;
      int64_t cluster_offset;
      int64_t cluster_bytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
          if (ret <= 0) {
              /* Must copy-on-read; use the bounce buffer */
 -            iov.iov_base = bounce_buffer;
 -            iov.iov_len = pnum = MIN(pnum, MAX_BOUNCE_BUFFER);
 -            qemu_iovec_init_external(&local_qiov, &iov, 1);
 +            pnum = MIN(pnum, MAX_BOUNCE_BUFFER);
 +            qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);
              ret = bdrv_driver_preadv(bs, cluster_offset, pnum,
                                       &local_qiov, 0);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
  {
      BlockDriver *drv = bs->drv;
      QEMUIOVector qiov;
 -    struct iovec iov = {0};
 +    void *buf = NULL;
      int ret = 0;
      bool need_flush = false;
      int head = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
                  need_flush = true;
              }
              num = MIN(num, max_transfer);
 -            iov.iov_len = num;
 -            if (iov.iov_base == NULL) {
 -                iov.iov_base = qemu_try_blockalign(bs, num);
 -                if (iov.iov_base == NULL) {
 +            if (buf == NULL) {
 +                buf = qemu_try_blockalign0(bs, num);
 +                if (buf == NULL) {
                      ret = -ENOMEM;
                      goto fail;
                  }
 -                memset(iov.iov_base, 0, num);
              }
 -            qemu_iovec_init_external(&qiov, &iov, 1);
 +            qemu_iovec_init_buf(&qiov, buf, num);
              ret = bdrv_driver_pwritev(bs, offset, num, &qiov, write_flags);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
               * all future requests.
               */
              if (num < max_transfer) {
 -                qemu_vfree(iov.iov_base);
 -                iov.iov_base = NULL;
 +                qemu_vfree(buf);
 +                buf = NULL;
              }
          }
@@ -XXX,XX +XXX,XX @@ fail:
      if (ret == 0 && need_flush) {
          ret = bdrv_co_flush(bs);
      }
 -    qemu_vfree(iov.iov_base);
 +    qemu_vfree(buf);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
      BlockDriverState *bs = child->bs;
      uint8_t *buf = NULL;
      QEMUIOVector local_qiov;
 -    struct iovec iov;
      uint64_t align = bs->bl.request_alignment;
      unsigned int head_padding_bytes, tail_padding_bytes;
      int ret = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
      assert(flags & BDRV_REQ_ZERO_WRITE);
      if (head_padding_bytes || tail_padding_bytes) {
          buf = qemu_blockalign(bs, align);
 -        iov = (struct iovec) {
 -            .iov_base   = buf,
 -            .iov_len    = align,
 -        };
 -        qemu_iovec_init_external(&local_qiov, &iov, 1);
 +        qemu_iovec_init_buf(&local_qiov, buf, align);
      }
      if (head_padding_bytes) {
          uint64_t zero_bytes = MIN(bytes, align - head_padding_bytes);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
      if (offset & (align - 1)) {
          QEMUIOVector head_qiov;
 -        struct iovec head_iov;
          mark_request_serialising(&req, align);
          wait_serialising_requests(&req);
          head_buf = qemu_blockalign(bs, align);
 -        head_iov = (struct iovec) {
 -            .iov_base   = head_buf,
 -            .iov_len    = align,
 -        };
 -        qemu_iovec_init_external(&head_qiov, &head_iov, 1);
 +        qemu_iovec_init_buf(&head_qiov, head_buf, align);
          bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
          ret = bdrv_aligned_preadv(child, &req, offset & ~(align - 1), align,
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
      if ((offset + bytes) & (align - 1)) {
          QEMUIOVector tail_qiov;
 -        struct iovec tail_iov;
          size_t tail_bytes;
          bool waited;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
          assert(!waited || !use_local_qiov);
          tail_buf = qemu_blockalign(bs, align);
 -        tail_iov = (struct iovec) {
 -            .iov_base   = tail_buf,
 -            .iov_len    = align,
 -        };
 -        qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
 +        qemu_iovec_init_buf(&tail_qiov, tail_buf, align);
          bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
          ret = bdrv_aligned_preadv(child, &req, (offset + bytes) & ~(align - 1),
@@ -XXX,XX +XXX,XX @@ bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
  int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                        int64_t pos, int size)
  {
 -    QEMUIOVector qiov;
 -    struct iovec iov = {
 -        .iov_base   = (void *) buf,
 -        .iov_len    = size,
 -    };
 +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, size);
      int ret;
 -    qemu_iovec_init_external(&qiov, &iov, 1);
 -
      ret = bdrv_writev_vmstate(bs, &qiov, pos);
      if (ret < 0) {
          return ret;
@@ -XXX,XX +XXX,XX @@ int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
  int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                        int64_t pos, int size)
  {
 -    QEMUIOVector qiov;
 -    struct iovec iov = {
 -        .iov_base   = buf,
 -        .iov_len    = size,
 -    };
 +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, size);
      int ret;
 -    qemu_iovec_init_external(&qiov, &iov, 1);
      ret = bdrv_readv_vmstate(bs, &qiov, pos);
      if (ret < 0) {
          return ret;
 --
 .20.1

-New patch
+[Qemu-devel] [PULL 03/27] block/block-backend: use QEMU_IOVEC_INIT_BUF
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use new QEMU_IOVEC_INIT_BUF() instead of
+qemu_iovec_init_external( ... , 1), which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-4-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-4-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/block-backend.c | 13 ++-----------
+file changed, 2 insertions(+), 11 deletions(-)
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
+                    int64_t bytes, CoroutineEntry co_entry,
+                    BdrvRequestFlags flags)
+ {
+-    QEMUIOVector qiov;
+-    struct iovec iov;
+-    BlkRwCo rwco;
+-
+-    iov = (struct iovec) {
+-        .iov_base = buf,
+-        .iov_len = bytes,
+-    };
+-    qemu_iovec_init_external(&qiov, &iov, 1);
+-
+-    rwco = (BlkRwCo) {
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
++    BlkRwCo rwco = {
+         .blk    = blk,
+         .offset = offset,
+         .iobuf  = &qiov,
+--
+.20.1

-[Qemu-devel] [PULL 08/11] jobs: utilize job_exit shim
+[Qemu-devel] [PULL 04/27] block/backup: use qemu_iovec_init_buf
-From: John Snow <jsnow@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Utilize the job_exit shim by not calling job_defer_to_main_loop, and
+Use new qemu_iovec_init_buf() instead of
-where applicable, converting the deferred callback into the job_exit
+qemu_iovec_init_external( ... , 1), which simplifies the code.
 callback.
-This converts backup, stream, create, and the unit tests all at once.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Most of these jobs do not see any changes to the order in which they
+Reviewed-by: Eric Blake <eblake@redhat.com>
-clean up their resources, except the test-blockjob-txn test, which
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-now puts down its bs before job_completed is called.
+Message-id: 20190218140926.333779-5-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-5-vsementsov@virtuozzo.com>
-This is safe for the same reason the reordering in the mirror job is
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 safe, because job_completed no longer runs under two locks, making
 the unref safe even if it causes a flush.
 Signed-off-by: John Snow <jsnow@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-id: 20180830015734.19765-7-jsnow@redhat.com
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block/backup.c            | 16 ----------------
+ block/backup.c | 5 +----
- block/create.c            | 14 +++-----------
+file changed, 1 insertion(+), 4 deletions(-)
  block/stream.c            | 22 +++++++---------------
  tests/test-bdrv-drain.c   |  6 ------
  tests/test-blockjob-txn.c | 11 ++---------
  tests/test-blockjob.c     | 10 ++++------
 files changed, 16 insertions(+), 63 deletions(-)
 diff --git a/block/backup.c b/block/backup.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/backup.c
 +++ b/block/backup.c
-@@ -XXX,XX +XXX,XX @@ static BlockErrorAction backup_error_action(BackupBlockJob *job,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job,
                                                        void **bounce_buffer)
  {
      int ret;
 -    struct iovec iov;
      QEMUIOVector qiov;
      BlockBackend *blk = job->common.blk;
      int nbytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job,
      if (!*bounce_buffer) {
          *bounce_buffer = blk_blockalign(blk, job->cluster_size);
      }
- }
+-    iov.iov_base = *bounce_buffer;
+-    iov.iov_len = nbytes;
--typedef struct {
+-    qemu_iovec_init_external(&qiov, &iov, 1);
--    int ret;
++    qemu_iovec_init_buf(&qiov, *bounce_buffer, nbytes);
--} BackupCompleteData;
--
+     ret = blk_co_preadv(blk, start, qiov.size, &qiov, read_flags);
--static void backup_complete(Job *job, void *opaque)
+     if (ret < 0) {
 -{
 -    BackupCompleteData *data = opaque;
 -
 -    job_completed(job, data->ret);
 -    g_free(data);
 -}
 -
  static bool coroutine_fn yield_and_check(BackupBlockJob *job)
  {
      uint64_t delay_ns;
@@ -XXX,XX +XXX,XX @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)
  static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
  {
      BackupBlockJob *job = container_of(opaque_job, BackupBlockJob, common.job);
 -    BackupCompleteData *data;
      BlockDriverState *bs = blk_bs(job->common.blk);
      int64_t offset, nb_clusters;
      int ret = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
      qemu_co_rwlock_unlock(&job->flush_rwlock);
      hbitmap_free(job->copy_bitmap);
 -    data = g_malloc(sizeof(*data));
 -    data->ret = ret;
 -    job_defer_to_main_loop(&job->common.job, backup_complete, data);
      return ret;
  }
 diff --git a/block/create.c b/block/create.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/create.c
 +++ b/block/create.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlockdevCreateJob {
      Job common;
      BlockDriver *drv;
      BlockdevCreateOptions *opts;
 -    int ret;
  } BlockdevCreateJob;
 -static void blockdev_create_complete(Job *job, void *opaque)
 -{
 -    BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
 -
 -    job_completed(job, s->ret);
 -}
 -
  static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
  {
      BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
 +    int ret;
      job_progress_set_remaining(&s->common, 1);
 -    s->ret = s->drv->bdrv_co_create(s->opts, errp);
 +    ret = s->drv->bdrv_co_create(s->opts, errp);
      job_progress_update(&s->common, 1);
      qapi_free_BlockdevCreateOptions(s->opts);
 -    job_defer_to_main_loop(&s->common, blockdev_create_complete, NULL);
 -    return s->ret;
 +    return ret;
  }
  static const JobDriver blockdev_create_job_driver = {
 diff --git a/block/stream.c b/block/stream.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/stream.c
 +++ b/block/stream.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_populate(BlockBackend *blk,
      return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ);
  }
 -typedef struct {
 -    int ret;
 -} StreamCompleteData;
 -
 -static void stream_complete(Job *job, void *opaque)
 +static void stream_exit(Job *job)
  {
      StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
      BlockJob *bjob = &s->common;
 -    StreamCompleteData *data = opaque;
      BlockDriverState *bs = blk_bs(bjob->blk);
      BlockDriverState *base = s->base;
      Error *local_err = NULL;
 +    int ret = job->ret;
 -    if (!job_is_cancelled(job) && bs->backing && data->ret == 0) {
 +    if (!job_is_cancelled(job) && bs->backing && ret == 0) {
          const char *base_id = NULL, *base_fmt = NULL;
          if (base) {
              base_id = s->backing_file_str;
@@ -XXX,XX +XXX,XX @@ static void stream_complete(Job *job, void *opaque)
                  base_fmt = base->drv->format_name;
              }
          }
 -        data->ret = bdrv_change_backing_file(bs, base_id, base_fmt);
 +        ret = bdrv_change_backing_file(bs, base_id, base_fmt);
          bdrv_set_backing_hd(bs, base, &local_err);
          if (local_err) {
              error_report_err(local_err);
 -            data->ret = -EPERM;
 +            ret = -EPERM;
              goto out;
          }
      }
@@ -XXX,XX +XXX,XX @@ out:
      }
      g_free(s->backing_file_str);
 -    job_completed(job, data->ret);
 -    g_free(data);
 +    job->ret = ret;
  }
  static int coroutine_fn stream_run(Job *job, Error **errp)
  {
      StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
 -    StreamCompleteData *data;
      BlockBackend *blk = s->common.blk;
      BlockDriverState *bs = blk_bs(blk);
      BlockDriverState *base = s->base;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_run(Job *job, Error **errp)
  out:
      /* Modify backing chain and close BDSes in main loop */
 -    data = g_malloc(sizeof(*data));
 -    data->ret = ret;
 -    job_defer_to_main_loop(&s->common.job, stream_complete, data);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver stream_job_driver = {
          .job_type      = JOB_TYPE_STREAM,
          .free          = block_job_free,
          .run           = stream_run,
 +        .exit          = stream_exit,
          .user_resume   = block_job_user_resume,
          .drain         = block_job_drain,
      },
 diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-bdrv-drain.c
 +++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ typedef struct TestBlockJob {
      bool should_complete;
  } TestBlockJob;
 -static void test_job_completed(Job *job, void *opaque)
 -{
 -    job_completed(job, 0);
 -}
 -
  static int coroutine_fn test_job_run(Job *job, Error **errp)
  {
      TestBlockJob *s = container_of(job, TestBlockJob, common.job);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn test_job_run(Job *job, Error **errp)
          job_pause_point(&s->common.job);
      }
 -    job_defer_to_main_loop(&s->common.job, test_job_completed, NULL);
      return 0;
  }
 diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob-txn.c
 +++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ typedef struct {
      int *result;
  } TestBlockJob;
 -static void test_block_job_complete(Job *job, void *opaque)
 +static void test_block_job_exit(Job *job)
  {
      BlockJob *bjob = container_of(job, BlockJob, job);
      BlockDriverState *bs = blk_bs(bjob->blk);
 -    int rc = (intptr_t)opaque;
 -    if (job_is_cancelled(job)) {
 -        rc = -ECANCELED;
 -    }
 -
 -    job_completed(job, rc);
      bdrv_unref(bs);
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn test_block_job_run(Job *job, Error **errp)
          }
      }
 -    job_defer_to_main_loop(job, test_block_job_complete,
 -                           (void *)(intptr_t)s->rc);
      return s->rc;
  }
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_block_job_driver = {
          .user_resume   = block_job_user_resume,
          .drain         = block_job_drain,
          .run           = test_block_job_run,
 +        .exit          = test_block_job_exit,
      },
  };
 diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob.c
 +++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ typedef struct CancelJob {
      bool completed;
  } CancelJob;
 -static void cancel_job_completed(Job *job, void *opaque)
 +static void cancel_job_exit(Job *job)
  {
 -    CancelJob *s = opaque;
 +    CancelJob *s = container_of(job, CancelJob, common.job);
      s->completed = true;
 -    job_completed(job, 0);
  }
  static void cancel_job_complete(Job *job, Error **errp)
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn cancel_job_run(Job *job, Error **errp)
      while (!s->should_complete) {
          if (job_is_cancelled(&s->common.job)) {
 -            goto defer;
 +            return 0;
          }
          if (!job_is_ready(&s->common.job) && s->should_converge) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn cancel_job_run(Job *job, Error **errp)
          job_sleep_ns(&s->common.job, 100000);
      }
 - defer:
 -    job_defer_to_main_loop(&s->common.job, cancel_job_completed, s);
      return 0;
  }
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_cancel_driver = {
          .user_resume   = block_job_user_resume,
          .drain         = block_job_drain,
          .run           = cancel_job_run,
 +        .exit          = cancel_job_exit,
          .complete      = cancel_job_complete,
      },
  };
 --
-.17.1
+.20.1

-[Qemu-devel] [PULL 06/11] block/commit: utilize job_exit shim
+[Qemu-devel] [PULL 05/27] block/commit: use QEMU_IOVEC_INIT_BUF
-From: John Snow <jsnow@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Change the manual deferment to commit_complete into the implicit
+Use new QEMU_IOVEC_INIT_BUF() instead of
-callback to job_exit, renaming commit_complete to commit_exit.
+qemu_iovec_init_external( ... , 1), which simplifies the code.
-This conversion does change the timing of when job_completed is
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-called to after the bdrv_replace_node and bdrv_unref calls, which
+Reviewed-by: Eric Blake <eblake@redhat.com>
-could have implications for bjob->blk which will now be put down
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-after this cleanup.
+Message-id: 20190218140926.333779-6-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-6-vsementsov@virtuozzo.com>
-Kevin highlights that we did not take any permissions for that backend
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 at job creation time, so it is safe to reorder these operations.
 Signed-off-by: John Snow <jsnow@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-id: 20180830015734.19765-5-jsnow@redhat.com
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block/commit.c | 22 +++++-----------------
+ block/commit.c | 7 +------
-file changed, 5 insertions(+), 17 deletions(-)
+file changed, 1 insertion(+), 6 deletions(-)
 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_populate(BlockBackend *bs, BlockBackend *base,
-     return 0;
+                                         void *buf)
  }
 -typedef struct {
 -    int ret;
 -} CommitCompleteData;
 -
 -static void commit_complete(Job *job, void *opaque)
 +static void commit_exit(Job *job)
  {
-     CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
-     BlockJob *bjob = &s->common;
--    CommitCompleteData *data = opaque;
-     BlockDriverState *top = blk_bs(s->top);
-     BlockDriverState *base = blk_bs(s->base);
-     BlockDriverState *commit_top_bs = s->commit_top_bs;
--    int ret = data->ret;
-     bool remove_commit_top_bs = false;
-     /* Make sure commit_top_bs and top stay around until bdrv_replace_node() */
-@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)
-      * the normal backing chain can be restored. */
-     blk_unref(s->base);
--    if (!job_is_cancelled(job) && ret == 0) {
-+    if (!job_is_cancelled(job) && job->ret == 0) {
-         /* success */
--        ret = bdrv_drop_intermediate(s->commit_top_bs, base,
--                                     s->backing_file_str);
-+        job->ret = bdrv_drop_intermediate(s->commit_top_bs, base,
-+                                          s->backing_file_str);
-     } else {
-         /* XXX Can (or should) we somehow keep 'consistent read' blocked even
-          * after the failed/cancelled commit job is gone? If we already wrote
-@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)
-      * bdrv_set_backing_hd() to fail. */
-     block_job_remove_all_bdrv(bjob);
--    job_completed(job, ret);
--    g_free(data);
--
-     /* If bdrv_drop_intermediate() didn't already do that, remove the commit
-      * filter driver from the backing chain. Do this as the final step so that
-      * the 'consistent read' permission can be granted.  */
-@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)
- static int coroutine_fn commit_run(Job *job, Error **errp)
- {
-     CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
--    CommitCompleteData *data;
-     int64_t offset;
-     uint64_t delay_ns = 0;
      int ret = 0;
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
+-    QEMUIOVector qiov;
- out:
+-    struct iovec iov = {
-     qemu_vfree(buf);
+-        .iov_base = buf,
+-        .iov_len = bytes,
--    data = g_malloc(sizeof(*data));
+-    };
--    data->ret = ret;
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
--    job_defer_to_main_loop(&s->common.job, commit_complete, data);
-     return ret;
+     assert(bytes < SIZE_MAX);
- }
+-    qemu_iovec_init_external(&qiov, &iov, 1);
-@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_job_driver = {
+     ret = blk_co_preadv(bs, offset, qiov.size, &qiov, 0);
-         .user_resume   = block_job_user_resume,
+     if (ret < 0) {
          .drain         = block_job_drain,
          .run           = commit_run,
 +        .exit          = commit_exit,
      },
  };
 --
-.17.1
+.20.1

-[Qemu-devel] [PULL 03/11] jobs: change start callback to run callback
+[Qemu-devel] [PULL 06/27] block/stream: use QEMU_IOVEC_INIT_BUF
-From: John Snow <jsnow@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Presently we codify the entry point for a job as the "start" callback,
+Use new QEMU_IOVEC_INIT_BUF() instead of
-but a more apt name would be "run" to clarify the idea that when this
+qemu_iovec_init_external( ... , 1), which simplifies the code.
 function returns we consider the job to have "finished," except for
 any cleanup which occurs in separate callbacks later.
-As part of this clarification, change the signature to include an error
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-object and a return code. The error ptr is not yet used, and the return
+Reviewed-by: Eric Blake <eblake@redhat.com>
-code while captured, will be overwritten by actions in the job_completed
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-function.
+Message-id: 20190218140926.333779-7-vsementsov@virtuozzo.com
 Message-Id: <20190218140926.333779-7-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  block/stream.c | 7 +------
 file changed, 1 insertion(+), 6 deletions(-)
-Signed-off-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20180830015734.19765-2-jsnow@redhat.com
-Reviewed-by: Jeff Cody <jcody@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- include/qemu/job.h        |  2 +-
- block/backup.c            |  7 ++++---
- block/commit.c            |  7 ++++---
- block/create.c            |  8 +++++---
- block/mirror.c            | 10 ++++++----
- block/stream.c            |  7 ++++---
- job.c                     |  6 +++---
- tests/test-bdrv-drain.c   |  7 ++++---
- tests/test-blockjob-txn.c | 16 ++++++++--------
- tests/test-blockjob.c     |  7 ++++---
-files changed, 43 insertions(+), 34 deletions(-)
-diff --git a/include/qemu/job.h b/include/qemu/job.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/job.h
-+++ b/include/qemu/job.h
-@@ -XXX,XX +XXX,XX @@ struct JobDriver {
-     JobType job_type;
-     /** Mandatory: Entrypoint for the Coroutine. */
--    CoroutineEntry *start;
-+    int coroutine_fn (*run)(Job *job, Error **errp);
-     /**
-      * If the callback is not NULL, it will be invoked when the job transitions
-diff --git a/block/backup.c b/block/backup.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/backup.c
-+++ b/block/backup.c
-@@ -XXX,XX +XXX,XX @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)
-     bdrv_dirty_iter_free(dbi);
- }
--static void coroutine_fn backup_run(void *opaque)
-+static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
- {
--    BackupBlockJob *job = opaque;
-+    BackupBlockJob *job = container_of(opaque_job, BackupBlockJob, common.job);
-     BackupCompleteData *data;
-     BlockDriverState *bs = blk_bs(job->common.blk);
-     int64_t offset, nb_clusters;
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn backup_run(void *opaque)
-     data = g_malloc(sizeof(*data));
-     data->ret = ret;
-     job_defer_to_main_loop(&job->common.job, backup_complete, data);
-+    return ret;
- }
- static const BlockJobDriver backup_job_driver = {
-@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver backup_job_driver = {
-         .free                   = block_job_free,
-         .user_resume            = block_job_user_resume,
-         .drain                  = block_job_drain,
--        .start                  = backup_run,
-+        .run                    = backup_run,
-         .commit                 = backup_commit,
-         .abort                  = backup_abort,
-         .clean                  = backup_clean,
-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 void commit_complete(Job *job, void *opaque)
-     bdrv_unref(top);
- }
--static void coroutine_fn commit_run(void *opaque)
-+static int coroutine_fn commit_run(Job *job, Error **errp)
- {
--    CommitBlockJob *s = opaque;
-+    CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
-     CommitCompleteData *data;
-     int64_t offset;
-     uint64_t delay_ns = 0;
-@@ -XXX,XX +XXX,XX @@ out:
-     data = g_malloc(sizeof(*data));
-     data->ret = ret;
-     job_defer_to_main_loop(&s->common.job, commit_complete, data);
-+    return ret;
- }
- static const BlockJobDriver commit_job_driver = {
-@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_job_driver = {
-         .free          = block_job_free,
-         .user_resume   = block_job_user_resume,
-         .drain         = block_job_drain,
--        .start         = commit_run,
-+        .run           = commit_run,
-     },
- };
-diff --git a/block/create.c b/block/create.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/create.c
-+++ b/block/create.c
-@@ -XXX,XX +XXX,XX @@ static void blockdev_create_complete(Job *job, void *opaque)
-     job_completed(job, s->ret, s->err);
- }
--static void coroutine_fn blockdev_create_run(void *opaque)
-+static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
- {
--    BlockdevCreateJob *s = opaque;
-+    BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
-     job_progress_set_remaining(&s->common, 1);
-     s->ret = s->drv->bdrv_co_create(s->opts, &s->err);
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn blockdev_create_run(void *opaque)
-     qapi_free_BlockdevCreateOptions(s->opts);
-     job_defer_to_main_loop(&s->common, blockdev_create_complete, NULL);
-+
-+    return s->ret;
- }
- static const JobDriver blockdev_create_job_driver = {
-     .instance_size = sizeof(BlockdevCreateJob),
-     .job_type      = JOB_TYPE_CREATE,
--    .start         = blockdev_create_run,
-+    .run           = blockdev_create_run,
- };
- void qmp_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
-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 mirror_flush(MirrorBlockJob *s)
-     return ret;
- }
--static void coroutine_fn mirror_run(void *opaque)
-+static int coroutine_fn mirror_run(Job *job, Error **errp)
- {
--    MirrorBlockJob *s = opaque;
-+    MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
-     MirrorExitData *data;
-     BlockDriverState *bs = s->mirror_top_bs->backing->bs;
-     BlockDriverState *target_bs = blk_bs(s->target);
-@@ -XXX,XX +XXX,XX @@ immediate_exit:
-     if (need_drain) {
-         bdrv_drained_begin(bs);
-     }
-+
-     job_defer_to_main_loop(&s->common.job, mirror_exit, data);
-+    return ret;
- }
- static void mirror_complete(Job *job, Error **errp)
-@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver mirror_job_driver = {
-         .free                   = block_job_free,
-         .user_resume            = block_job_user_resume,
-         .drain                  = block_job_drain,
--        .start                  = mirror_run,
-+        .run                    = mirror_run,
-         .pause                  = mirror_pause,
-         .complete               = mirror_complete,
-     },
-@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_active_job_driver = {
-         .free                   = block_job_free,
-         .user_resume            = block_job_user_resume,
-         .drain                  = block_job_drain,
--        .start                  = mirror_run,
-+        .run                    = mirror_run,
-         .pause                  = mirror_pause,
-         .complete               = mirror_complete,
-     },
 diff --git a/block/stream.c b/block/stream.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/stream.c
 +++ b/block/stream.c
-@@ -XXX,XX +XXX,XX @@ out:
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_populate(BlockBackend *blk,
-     g_free(data);
+                                         int64_t offset, uint64_t bytes,
- }
+                                         void *buf)
 -static void coroutine_fn stream_run(void *opaque)
 +static int coroutine_fn stream_run(Job *job, Error **errp)
  {
--    StreamBlockJob *s = opaque;
+-    struct iovec iov = {
-+    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
+-        .iov_base = buf,
-     StreamCompleteData *data;
+-        .iov_len  = bytes,
-     BlockBackend *blk = s->common.blk;
+-    };
-     BlockDriverState *bs = blk_bs(blk);
+-    QEMUIOVector qiov;
-@@ -XXX,XX +XXX,XX @@ out:
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
-     data = g_malloc(sizeof(*data));
-     data->ret = ret;
+     assert(bytes < SIZE_MAX);
-     job_defer_to_main_loop(&s->common.job, stream_complete, data);
+-    qemu_iovec_init_external(&qiov, &iov, 1);
-+    return ret;
- }
+     /* Copy-on-read the unallocated clusters */
+     return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ);
  static const BlockJobDriver stream_job_driver = {
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver stream_job_driver = {
          .instance_size = sizeof(StreamBlockJob),
          .job_type      = JOB_TYPE_STREAM,
          .free          = block_job_free,
 -        .start         = stream_run,
 +        .run           = stream_run,
          .user_resume   = block_job_user_resume,
          .drain         = block_job_drain,
      },
 diff --git a/job.c b/job.c
 index XXXXXXX..XXXXXXX 100644
 --- a/job.c
 +++ b/job.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn job_co_entry(void *opaque)
  {
      Job *job = opaque;
 -    assert(job && job->driver && job->driver->start);
 +    assert(job && job->driver && job->driver->run);
      job_pause_point(job);
 -    job->driver->start(job);
 +    job->ret = job->driver->run(job, NULL);
  }
  void job_start(Job *job)
  {
      assert(job && !job_started(job) && job->paused &&
 -           job->driver && job->driver->start);
 +           job->driver && job->driver->run);
      job->co = qemu_coroutine_create(job_co_entry, job);
      job->pause_count--;
      job->busy = true;
 diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-bdrv-drain.c
 +++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_job_completed(Job *job, void *opaque)
      job_completed(job, 0, NULL);
  }
 -static void coroutine_fn test_job_start(void *opaque)
 +static int coroutine_fn test_job_run(Job *job, Error **errp)
  {
 -    TestBlockJob *s = opaque;
 +    TestBlockJob *s = container_of(job, TestBlockJob, common.job);
      job_transition_to_ready(&s->common.job);
      while (!s->should_complete) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_job_start(void *opaque)
      }
      job_defer_to_main_loop(&s->common.job, test_job_completed, NULL);
 +    return 0;
  }
  static void test_job_complete(Job *job, Error **errp)
@@ -XXX,XX +XXX,XX @@ BlockJobDriver test_job_driver = {
          .free           = block_job_free,
          .user_resume    = block_job_user_resume,
          .drain          = block_job_drain,
 -        .start          = test_job_start,
 +        .run            = test_job_run,
          .complete       = test_job_complete,
      },
  };
 diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob-txn.c
 +++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static void test_block_job_complete(Job *job, void *opaque)
      bdrv_unref(bs);
  }
 -static void coroutine_fn test_block_job_run(void *opaque)
 +static int coroutine_fn test_block_job_run(Job *job, Error **errp)
  {
 -    TestBlockJob *s = opaque;
 -    BlockJob *job = &s->common;
 +    TestBlockJob *s = container_of(job, TestBlockJob, common.job);
      while (s->iterations--) {
          if (s->use_timer) {
 -            job_sleep_ns(&job->job, 0);
 +            job_sleep_ns(job, 0);
          } else {
 -            job_yield(&job->job);
 +            job_yield(job);
          }
 -        if (job_is_cancelled(&job->job)) {
 +        if (job_is_cancelled(job)) {
              break;
          }
      }
 -    job_defer_to_main_loop(&job->job, test_block_job_complete,
 +    job_defer_to_main_loop(job, test_block_job_complete,
                             (void *)(intptr_t)s->rc);
 +    return s->rc;
  }
  typedef struct {
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_block_job_driver = {
          .free          = block_job_free,
          .user_resume   = block_job_user_resume,
          .drain         = block_job_drain,
 -        .start         = test_block_job_run,
 +        .run           = test_block_job_run,
      },
  };
 diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob.c
 +++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static void cancel_job_complete(Job *job, Error **errp)
      s->should_complete = true;
  }
 -static void coroutine_fn cancel_job_start(void *opaque)
 +static int coroutine_fn cancel_job_run(Job *job, Error **errp)
  {
 -    CancelJob *s = opaque;
 +    CancelJob *s = container_of(job, CancelJob, common.job);
      while (!s->should_complete) {
          if (job_is_cancelled(&s->common.job)) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn cancel_job_start(void *opaque)
   defer:
      job_defer_to_main_loop(&s->common.job, cancel_job_completed, s);
 +    return 0;
  }
  static const BlockJobDriver test_cancel_driver = {
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_cancel_driver = {
          .free          = block_job_free,
          .user_resume   = block_job_user_resume,
          .drain         = block_job_drain,
 -        .start         = cancel_job_start,
 +        .run           = cancel_job_run,
          .complete      = cancel_job_complete,
      },
  };
 --
-.17.1
+.20.1

-New patch
+[Qemu-devel] [PULL 07/27] block/parallels: use QEMU_IOVEC_INIT_BUF
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use new QEMU_IOVEC_INIT_BUF() instead of
+qemu_iovec_init_external( ... , 1), which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-8-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-8-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/parallels.c | 13 +++++--------
+file changed, 5 insertions(+), 8 deletions(-)
+diff --git a/block/parallels.c b/block/parallels.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/parallels.c
++++ b/block/parallels.c
+@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
+     if (bs->backing) {
+         int64_t nb_cow_sectors = to_allocate * s->tracks;
+         int64_t nb_cow_bytes = nb_cow_sectors << BDRV_SECTOR_BITS;
+-        QEMUIOVector qiov;
+-        struct iovec iov = {
+-            .iov_len = nb_cow_bytes,
+-            .iov_base = qemu_blockalign(bs, nb_cow_bytes)
+-        };
+-        qemu_iovec_init_external(&qiov, &iov, 1);
++        QEMUIOVector qiov =
++            QEMU_IOVEC_INIT_BUF(qiov, qemu_blockalign(bs, nb_cow_bytes),
++                                nb_cow_bytes);
+         ret = bdrv_co_preadv(bs->backing, idx * s->tracks * BDRV_SECTOR_SIZE,
+                              nb_cow_bytes, &qiov, 0);
+         if (ret < 0) {
+-            qemu_vfree(iov.iov_base);
++            qemu_vfree(qemu_iovec_buf(&qiov));
+             return ret;
+         }
+         ret = bdrv_co_pwritev(bs->file, s->data_end * BDRV_SECTOR_SIZE,
+                               nb_cow_bytes, &qiov, 0);
+-        qemu_vfree(iov.iov_base);
++        qemu_vfree(qemu_iovec_buf(&qiov));
+         if (ret < 0) {
+             return ret;
+         }
+--
+.20.1

-New patch
+[Qemu-devel] [PULL 08/27] block/qcow: use qemu_iovec_init_buf
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use new qemu_iovec_init_buf() instead of
+qemu_iovec_init_external( ... , 1), which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-9-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-9-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/qcow.c | 21 ++++-----------------
+file changed, 4 insertions(+), 17 deletions(-)
+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 coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
+     int offset_in_cluster;
+     int ret = 0, n;
+     uint64_t cluster_offset;
+-    struct iovec hd_iov;
+     QEMUIOVector hd_qiov;
+     uint8_t *buf;
+     void *orig_buf;
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
+         if (!cluster_offset) {
+             if (bs->backing) {
+                 /* read from the base image */
+-                hd_iov.iov_base = (void *)buf;
+-                hd_iov.iov_len = n;
+-                qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
++                qemu_iovec_init_buf(&hd_qiov, buf, n);
+                 qemu_co_mutex_unlock(&s->lock);
+                 /* qcow2 emits this on bs->file instead of bs->backing */
+                 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
+                 ret = -EIO;
+                 break;
+             }
+-            hd_iov.iov_base = (void *)buf;
+-            hd_iov.iov_len = n;
+-            qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
++            qemu_iovec_init_buf(&hd_qiov, buf, n);
+             qemu_co_mutex_unlock(&s->lock);
+             BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+             ret = bdrv_co_preadv(bs->file, cluster_offset + offset_in_cluster,
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_pwritev(BlockDriverState *bs, uint64_t offset,
+     int offset_in_cluster;
+     uint64_t cluster_offset;
+     int ret = 0, n;
+-    struct iovec hd_iov;
+     QEMUIOVector hd_qiov;
+     uint8_t *buf;
+     void *orig_buf;
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_pwritev(BlockDriverState *bs, uint64_t offset,
+             }
+         }
+-        hd_iov.iov_base = (void *)buf;
+-        hd_iov.iov_len = n;
+-        qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
++        qemu_iovec_init_buf(&hd_qiov, buf, n);
+         qemu_co_mutex_unlock(&s->lock);
+         BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+         ret = bdrv_co_pwritev(bs->file, cluster_offset + offset_in_cluster,
+@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
+ {
+     BDRVQcowState *s = bs->opaque;
+     QEMUIOVector hd_qiov;
+-    struct iovec iov;
+     z_stream strm;
+     int ret, out_len;
+     uint8_t *buf, *out_buf;
+@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
+     }
+     cluster_offset &= s->cluster_offset_mask;
+-    iov = (struct iovec) {
+-        .iov_base   = out_buf,
+-        .iov_len    = out_len,
+-    };
+-    qemu_iovec_init_external(&hd_qiov, &iov, 1);
++    qemu_iovec_init_buf(&hd_qiov, out_buf, out_len);
+     BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
+     ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);
+     if (ret < 0) {
+--
+.20.1

-New patch
+[Qemu-devel] [PULL 09/27] block/qcow2: use qemu_iovec_init_buf
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use new qemu_iovec_init_buf() instead of
+qemu_iovec_init_external( ... , 1), which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-10-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-10-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/qcow2.c | 12 ++----------
+file changed, 2 insertions(+), 10 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 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
+ {
+     BDRVQcow2State *s = bs->opaque;
+     QEMUIOVector hd_qiov;
+-    struct iovec iov;
+     int ret;
+     size_t out_len;
+     uint8_t *buf, *out_buf;
+@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
+         goto fail;
+     }
+-    iov = (struct iovec) {
+-        .iov_base   = out_buf,
+-        .iov_len    = out_len,
+-    };
+-    qemu_iovec_init_external(&hd_qiov, &iov, 1);
++    qemu_iovec_init_buf(&hd_qiov, out_buf, out_len);
+     BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
+     ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);
+@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
+     int ret = 0, csize, nb_csectors;
+     uint64_t coffset;
+     uint8_t *buf, *out_buf;
+-    struct iovec iov;
+     QEMUIOVector local_qiov;
+     int offset_in_cluster = offset_into_cluster(s, offset);
+@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
+     if (!buf) {
+         return -ENOMEM;
+     }
+-    iov.iov_base = buf;
+-    iov.iov_len = csize;
+-    qemu_iovec_init_external(&local_qiov, &iov, 1);
++    qemu_iovec_init_buf(&local_qiov, buf, csize);
+     out_buf = qemu_blockalign(bs, s->cluster_size);
+--
+.20.1

-New patch
+[Qemu-devel] [PULL 10/27] block/qed: use qemu_iovec_init_buf
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use new qemu_iovec_init_buf() instead of
+qemu_iovec_init_external( ... , 1), which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-11-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-11-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/qed-table.c | 16 +++-------------
+ block/qed.c       | 31 +++++++++----------------------
+files changed, 12 insertions(+), 35 deletions(-)
+diff --git a/block/qed-table.c b/block/qed-table.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qed-table.c
++++ b/block/qed-table.c
+@@ -XXX,XX +XXX,XX @@
+ /* Called with table_lock held.  */
+ static int qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table)
+ {
+-    QEMUIOVector qiov;
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(
++        qiov, table->offsets, s->header.cluster_size * s->header.table_size);
+     int noffsets;
+     int i, ret;
+-    struct iovec iov = {
+-        .iov_base = table->offsets,
+-        .iov_len = s->header.cluster_size * s->header.table_size,
+-    };
+-    qemu_iovec_init_external(&qiov, &iov, 1);
+-
+     trace_qed_read_table(s, offset, table);
+     qemu_co_mutex_unlock(&s->table_lock);
+@@ -XXX,XX +XXX,XX @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
+     unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;
+     unsigned int start, end, i;
+     QEDTable *new_table;
+-    struct iovec iov;
+     QEMUIOVector qiov;
+     size_t len_bytes;
+     int ret;
+@@ -XXX,XX +XXX,XX @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
+     len_bytes = (end - start) * sizeof(uint64_t);
+     new_table = qemu_blockalign(s->bs, len_bytes);
+-    iov = (struct iovec) {
+-        .iov_base = new_table->offsets,
+-        .iov_len = len_bytes,
+-    };
+-    qemu_iovec_init_external(&qiov, &iov, 1);
++    qemu_iovec_init_buf(&qiov, new_table->offsets, len_bytes);
+     /* Byteswap table */
+     for (i = start; i < end; i++) {
+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 qed_write_header(BDRVQEDState *s)
+     int nsectors = DIV_ROUND_UP(sizeof(QEDHeader), BDRV_SECTOR_SIZE);
+     size_t len = nsectors * BDRV_SECTOR_SIZE;
+     uint8_t *buf;
+-    struct iovec iov;
+     QEMUIOVector qiov;
+     int ret;
+     assert(s->allocating_acb || s->allocating_write_reqs_plugged);
+     buf = qemu_blockalign(s->bs, len);
+-    iov = (struct iovec) {
+-        .iov_base = buf,
+-        .iov_len = len,
+-    };
+-    qemu_iovec_init_external(&qiov, &iov, 1);
++    qemu_iovec_init_buf(&qiov, buf, len);
+     ret = bdrv_co_preadv(s->bs->file, 0, qiov.size, &qiov, 0);
+     if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,
+ {
+     QEMUIOVector qiov;
+     QEMUIOVector *backing_qiov = NULL;
+-    struct iovec iov;
+     int ret;
+     /* Skip copy entirely if there is no work to do */
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,
+         return 0;
+     }
+-    iov = (struct iovec) {
+-        .iov_base = qemu_blockalign(s->bs, len),
+-        .iov_len = len,
+-    };
+-    qemu_iovec_init_external(&qiov, &iov, 1);
++    qemu_iovec_init_buf(&qiov, qemu_blockalign(s->bs, len), len);
+     ret = qed_read_backing_file(s, pos, &qiov, &backing_qiov);
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,
+     }
+     ret = 0;
+ out:
+-    qemu_vfree(iov.iov_base);
++    qemu_vfree(qemu_iovec_buf(&qiov));
+     return ret;
+ }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_pwrite_zeroes(BlockDriverState *bs,
+                                                   BdrvRequestFlags flags)
+ {
+     BDRVQEDState *s = bs->opaque;
+-    QEMUIOVector qiov;
+-    struct iovec iov;
++
++    /*
++     * Zero writes start without an I/O buffer.  If a buffer becomes necessary
++     * then it will be allocated during request processing.
++     */
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, bytes);
+     /* Fall back if the request is not aligned */
+     if (qed_offset_into_cluster(s, offset) ||
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_pwrite_zeroes(BlockDriverState *bs,
+         return -ENOTSUP;
+     }
+-    /* Zero writes start without an I/O buffer.  If a buffer becomes necessary
+-     * then it will be allocated during request processing.
+-     */
+-    iov.iov_base = NULL;
+-    iov.iov_len = bytes;
+-
+-    qemu_iovec_init_external(&qiov, &iov, 1);
+     return qed_co_request(bs, offset >> BDRV_SECTOR_BITS, &qiov,
+                           bytes >> BDRV_SECTOR_BITS,
+                           QED_AIOCB_WRITE | QED_AIOCB_ZERO);
+--
+.20.1

-New patch
+[Qemu-devel] [PULL 11/27] block/vmdk: use qemu_iovec_init_buf
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use new qemu_iovec_init_buf() instead of
+qemu_iovec_init_external( ... , 1), which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-12-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-12-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/vmdk.c | 7 +------
+file changed, 1 insertion(+), 6 deletions(-)
+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_write_extent(VmdkExtent *extent, int64_t cluster_offset,
+     VmdkGrainMarker *data = NULL;
+     uLongf buf_len;
+     QEMUIOVector local_qiov;
+-    struct iovec iov;
+     int64_t write_offset;
+     int64_t write_end_sector;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
+         data->size = cpu_to_le32(buf_len);
+         n_bytes = buf_len + sizeof(VmdkGrainMarker);
+-        iov = (struct iovec) {
+-            .iov_base   = data,
+-            .iov_len    = n_bytes,
+-        };
+-        qemu_iovec_init_external(&local_qiov, &iov, 1);
++        qemu_iovec_init_buf(&local_qiov, data, n_bytes);
+         BLKDBG_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED);
+     } else {
+--
+.20.1

-New patch
+[Qemu-devel] [PULL 12/27] qemu-img: use qemu_iovec_init_buf
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use new qemu_iovec_init_buf() instead of
+qemu_iovec_init_external( ... , 1), which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-13-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-13-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ qemu-img.c | 10 ++--------
+file changed, 2 insertions(+), 8 deletions(-)
+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 coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
+ {
+     int n, ret;
+     QEMUIOVector qiov;
+-    struct iovec iov;
+     assert(nb_sectors <= s->buf_sectors);
+     while (nb_sectors > 0) {
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
+         bs_sectors = s->src_sectors[src_cur];
+         n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
+-        iov.iov_base = buf;
+-        iov.iov_len = n << BDRV_SECTOR_BITS;
+-        qemu_iovec_init_external(&qiov, &iov, 1);
++        qemu_iovec_init_buf(&qiov, buf, n << BDRV_SECTOR_BITS);
+         ret = blk_co_preadv(
+                 blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
+ {
+     int ret;
+     QEMUIOVector qiov;
+-    struct iovec iov;
+     while (nb_sectors > 0) {
+         int n = nb_sectors;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
+                 (s->compressed &&
+                  !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
+             {
+-                iov.iov_base = buf;
+-                iov.iov_len = n << BDRV_SECTOR_BITS;
+-                qemu_iovec_init_external(&qiov, &iov, 1);
++                qemu_iovec_init_buf(&qiov, buf, n << BDRV_SECTOR_BITS);
+                 ret = blk_co_pwritev(s->target, sector_num << BDRV_SECTOR_BITS,
+                                      n << BDRV_SECTOR_BITS, &qiov, flags);
+--
+.20.1

-New patch
+[Qemu-devel] [PULL 13/27] migration/block: use qemu_iovec_init_buf
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use new qemu_iovec_init_buf() instead of
+qemu_iovec_init_external( ... , 1), which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-14-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-14-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ migration/block.c | 10 +++-------
+file changed, 3 insertions(+), 7 deletions(-)
+diff --git a/migration/block.c b/migration/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/migration/block.c
++++ b/migration/block.c
+@@ -XXX,XX +XXX,XX @@ typedef struct BlkMigBlock {
+     BlkMigDevState *bmds;
+     int64_t sector;
+     int nr_sectors;
+-    struct iovec iov;
+     QEMUIOVector qiov;
+     BlockAIOCB *aiocb;
+@@ -XXX,XX +XXX,XX @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
+     blk->sector = cur_sector;
+     blk->nr_sectors = nr_sectors;
+-    blk->iov.iov_base = blk->buf;
+-    blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
+-    qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
++    qemu_iovec_init_buf(&blk->qiov, blk->buf, nr_sectors * BDRV_SECTOR_SIZE);
+     blk_mig_lock();
+     block_mig_state.submitted++;
+@@ -XXX,XX +XXX,XX @@ static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds,
+             blk->nr_sectors = nr_sectors;
+             if (is_async) {
+-                blk->iov.iov_base = blk->buf;
+-                blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
+-                qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
++                qemu_iovec_init_buf(&blk->qiov, blk->buf,
++                                    nr_sectors * BDRV_SECTOR_SIZE);
+                 blk->aiocb = blk_aio_preadv(bmds->blk,
+                                             sector * BDRV_SECTOR_SIZE,
+--
+.20.1

-[Qemu-devel] [PULL 02/11] tests: fix bdrv-drain leak
+[Qemu-devel] [PULL 14/27] tests/test-bdrv-drain: use QEMU_IOVEC_INIT_BUF
-From: Marc-André Lureau <marcandre.lureau@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Spotted by ASAN:
+Use new QEMU_IOVEC_INIT_BUF() instead of
 qemu_iovec_init_external( ... , 1), which simplifies the code.
-=================================================================
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-==5378==ERROR: LeakSanitizer: detected memory leaks
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Direct leak of 65536 byte(s) in 1 object(s) allocated from:
+Message-id: 20190218140926.333779-15-vsementsov@virtuozzo.com
-    #0 0x7f788f83bc48 in malloc (/lib64/libasan.so.5+0xeec48)
+Message-Id: <20190218140926.333779-15-vsementsov@virtuozzo.com>
-    #1 0x7f788c9923c5 in g_malloc (/lib64/libglib-2.0.so.0+0x523c5)
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
     #2 0x5622a1fe37bc in coroutine_trampoline /home/elmarco/src/qq/util/coroutine-ucontext.c:116
     #3 0x7f788a15d75f in __correctly_grouped_prefixwc (/lib64/libc.so.6+0x4c75f)
 (Broken in commit 4c8158e359d.)
 Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
 Message-id: 20180809114417.28718-3-marcandre.lureau@redhat.com
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/test-bdrv-drain.c | 1 +
+ tests/test-bdrv-drain.c | 29 ++++-------------------------
-file changed, 1 insertion(+)
+file changed, 4 insertions(+), 25 deletions(-)
 diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-bdrv-drain.c
 +++ b/tests/test-bdrv-drain.c
+@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
+     BlockAIOCB *acb;
+     int aio_ret;
+-    QEMUIOVector qiov;
+-    struct iovec iov = {
+-        .iov_base = NULL,
+-        .iov_len = 0,
+-    };
+-    qemu_iovec_init_external(&qiov, &iov, 1);
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
+     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
+@@ -XXX,XX +XXX,XX @@ static void test_iothread_common(enum drain_type drain_type, int drain_thread)
+     AioContext *ctx_a = iothread_get_aio_context(a);
+     AioContext *ctx_b = iothread_get_aio_context(b);
+-    QEMUIOVector qiov;
+-    struct iovec iov = {
+-        .iov_base = NULL,
+-        .iov_len = 0,
+-    };
+-    qemu_iovec_init_external(&qiov, &iov, 1);
++    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
+     /* bdrv_drain_all() may only be called from the main loop thread */
+     if (drain_type == BDRV_DRAIN_ALL && drain_thread != 0) {
 @@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_co_delete_by_drain(void *opaque)
-     }
+     BlockDriverState *bs = blk_bs(blk);
+     BDRVTestTopState *tts = bs->opaque;
-     dbdd->done = true;
+     void *buffer = g_malloc(65536);
-+    g_free(buffer);
+-    QEMUIOVector qiov;
- }
+-    struct iovec iov = {
+-        .iov_base = buffer,
- /**
+-        .iov_len  = 65536,
 -    };
 -
 -    qemu_iovec_init_external(&qiov, &iov, 1);
 +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buffer, 65536);
      /* Pretend some internal write operation from parent to child.
       * Important: We have to read from the child, not from the parent!
@@ -XXX,XX +XXX,XX @@ static void test_detach_indirect(bool by_parent_cb)
      BdrvChild *child_a, *child_b;
      BlockAIOCB *acb;
 -    QEMUIOVector qiov;
 -    struct iovec iov = {
 -        .iov_base = NULL,
 -        .iov_len = 0,
 -    };
 -    qemu_iovec_init_external(&qiov, &iov, 1);
 +    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
      if (!by_parent_cb) {
          detach_by_driver_cb_role = child_file;
 --
-.17.1
+.20.1

-[Qemu-devel] [PULL 01/11] file-posix: Skip effectiveless OFD lock operations
+[Qemu-devel] [PULL 15/27] hw/ide: drop iov field from IDEState
-From: Fam Zheng <famz@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-If we know we've already locked the bytes, don't do it again; similarly
+@iov is used only to initialize @qiov. Let's use new
-don't unlock a byte if we haven't locked it. This doesn't change the
+qemu_iovec_init_buf() instead, which simplifies the code.
 behavior, but fixes a corner case explained below.
-Libvirt had an error handling bug that an image can get its (ownership,
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-file mode, SELinux) permissions changed (RHBZ 1584982) by mistake behind
+Reviewed-by: Eric Blake <eblake@redhat.com>
-QEMU. Specifically, an image in use by Libvirt VM has:
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20190218140926.333779-16-vsementsov@virtuozzo.com
 Message-Id: <20190218140926.333779-16-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/hw/ide/internal.h | 1 -
  hw/ide/atapi.c            | 9 ++++-----
  hw/ide/core.c             | 8 ++------
 files changed, 6 insertions(+), 12 deletions(-)
-    $ ls -lhZ b.img
+diff --git a/include/hw/ide/internal.h b/include/hw/ide/internal.h
     -rw-r--r--. qemu qemu system_u:object_r:svirt_image_t:s0:c600,c690 b.img
 Trying to attach it a second time won't work because of image locking.
 And after the error, it becomes:
     $ ls -lhZ b.img
     -rw-r--r--. root root system_u:object_r:virt_image_t:s0 b.img
 Then, we won't be able to do OFD lock operations with the existing fd.
 In other words, the code such as in blk_detach_dev:
     blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);
 can abort() QEMU, out of environmental changes.
 This patch is an easy fix to this and the change is regardlessly
 reasonable, so do it.
 Signed-off-by: Fam Zheng <famz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
  block/file-posix.c | 41 +++++++++++++++++++++++++++++++----------
 file changed, 31 insertions(+), 10 deletions(-)
 diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/include/hw/ide/internal.h
-+++ b/block/file-posix.c
++++ b/include/hw/ide/internal.h
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@ struct IDEState {
-  * file; if @unlock == true, also unlock the unneeded bytes.
+     int atapi_dma; /* true if dma is requested for the packet cmd */
-  * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
+     BlockAcctCookie acct;
-  */
+     BlockAIOCB *pio_aiocb;
--static int raw_apply_lock_bytes(int fd,
+-    struct iovec iov;
-+static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
+     QEMUIOVector qiov;
-                                 uint64_t perm_lock_bits,
+     QLIST_HEAD(, IDEBufferedRequest) buffered_requests;
-                                 uint64_t shared_perm_lock_bits,
+     /* ATA DMA state */
-                                 bool unlock, Error **errp)
+diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/ide/atapi.c
 +++ b/hw/ide/atapi.c
@@ -XXX,XX +XXX,XX @@ static void cd_read_sector_cb(void *opaque, int ret)
  static int cd_read_sector(IDEState *s)
  {
-     int ret;
++    void *buf;
      int i;
 +    uint64_t locked_perm, locked_shared_perm;
 +
-+    if (s) {
+     if (s->cd_sector_size != 2048 && s->cd_sector_size != 2352) {
-+        locked_perm = s->perm;
+         block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_READ);
-+        locked_shared_perm = ~s->shared_perm & BLK_PERM_ALL;
+         return -EINVAL;
 +    } else {
 +        /*
 +         * We don't have the previous bits, just lock/unlock for each of the
 +         * requested bits.
 +         */
 +        if (unlock) {
 +            locked_perm = BLK_PERM_ALL;
 +            locked_shared_perm = BLK_PERM_ALL;
 +        } else {
 +            locked_perm = 0;
 +            locked_shared_perm = 0;
 +        }
 +    }
      PERM_FOREACH(i) {
          int off = RAW_LOCK_PERM_BASE + i;
 -        if (perm_lock_bits & (1ULL << i)) {
 +        uint64_t bit = (1ULL << i);
 +        if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
              ret = qemu_lock_fd(fd, off, 1, false);
              if (ret) {
                  error_setg(errp, "Failed to lock byte %d", off);
                  return ret;
              }
 -        } else if (unlock) {
 +        } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
              ret = qemu_unlock_fd(fd, off, 1);
              if (ret) {
                  error_setg(errp, "Failed to unlock byte %d", off);
@@ -XXX,XX +XXX,XX @@ static int raw_apply_lock_bytes(int fd,
      }
-     PERM_FOREACH(i) {
-         int off = RAW_LOCK_SHARED_BASE + i;
+-    s->iov.iov_base = (s->cd_sector_size == 2352) ?
--        if (shared_perm_lock_bits & (1ULL << i)) {
+-                      s->io_buffer + 16 : s->io_buffer;
-+        uint64_t bit = (1ULL << i);
+-
-+        if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
+-    s->iov.iov_len = ATAPI_SECTOR_SIZE;
-             ret = qemu_lock_fd(fd, off, 1, false);
+-    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
-             if (ret) {
++    buf = (s->cd_sector_size == 2352) ? s->io_buffer + 16 : s->io_buffer;
-                 error_setg(errp, "Failed to lock byte %d", off);
++    qemu_iovec_init_buf(&s->qiov, buf, ATAPI_SECTOR_SIZE);
-                 return ret;
-             }
+     trace_cd_read_sector(s->lba);
--        } else if (unlock) {
-+        } else if (unlock && (locked_shared_perm & bit) &&
+diff --git a/hw/ide/core.c b/hw/ide/core.c
-+                   !(shared_perm_lock_bits & bit)) {
+index XXXXXXX..XXXXXXX 100644
-             ret = qemu_unlock_fd(fd, off, 1);
+--- a/hw/ide/core.c
-             if (ret) {
++++ b/hw/ide/core.c
-                 error_setg(errp, "Failed to unlock byte %d", off);
+@@ -XXX,XX +XXX,XX @@ static void ide_sector_read(IDEState *s)
-@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,
+         return;
      switch (op) {
      case RAW_PL_PREPARE:
 -        ret = raw_apply_lock_bytes(s->lock_fd, s->perm | new_perm,
 +        ret = raw_apply_lock_bytes(s, s->lock_fd, s->perm | new_perm,
                                     ~s->shared_perm | ~new_shared,
                                     false, errp);
          if (!ret) {
@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,
          op = RAW_PL_ABORT;
          /* fall through to unlock bytes. */
      case RAW_PL_ABORT:
 -        raw_apply_lock_bytes(s->lock_fd, s->perm, ~s->shared_perm,
 +        raw_apply_lock_bytes(s, s->lock_fd, s->perm, ~s->shared_perm,
                               true, &local_err);
          if (local_err) {
              /* Theoretically the above call only unlocks bytes and it cannot
@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,
          }
          break;
      case RAW_PL_COMMIT:
 -        raw_apply_lock_bytes(s->lock_fd, new_perm, ~new_shared,
 +        raw_apply_lock_bytes(s, s->lock_fd, new_perm, ~new_shared,
                               true, &local_err);
          if (local_err) {
              /* Theoretically the above call only unlocks bytes and it cannot
@@ -XXX,XX +XXX,XX @@ raw_co_create(BlockdevCreateOptions *options, Error **errp)
      shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
      /* Step one: Take locks */
 -    result = raw_apply_lock_bytes(fd, perm, ~shared, false, errp);
 +    result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
      if (result < 0) {
          goto out_close;
      }
-@@ -XXX,XX +XXX,XX @@ raw_co_create(BlockdevCreateOptions *options, Error **errp)
 -    s->iov.iov_base = s->io_buffer;
 -    s->iov.iov_len  = n * BDRV_SECTOR_SIZE;
 -    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
 +    qemu_iovec_init_buf(&s->qiov, s->io_buffer, n * BDRV_SECTOR_SIZE);
      block_acct_start(blk_get_stats(s->blk), &s->acct,
                       n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
@@ -XXX,XX +XXX,XX @@ static void ide_sector_write(IDEState *s)
          return;
      }
- out_unlock:
+-    s->iov.iov_base = s->io_buffer;
--    raw_apply_lock_bytes(fd, 0, 0, true, &local_err);
+-    s->iov.iov_len  = n * BDRV_SECTOR_SIZE;
-+    raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
+-    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
-     if (local_err) {
++    qemu_iovec_init_buf(&s->qiov, s->io_buffer, n * BDRV_SECTOR_SIZE);
-         /* The above call should not fail, and if it does, that does
-          * not mean the whole creation operation has failed.  So
+     block_acct_start(blk_get_stats(s->blk), &s->acct,
                       n * BDRV_SECTOR_SIZE, BLOCK_ACCT_WRITE);
 --
-.17.1
+.20.1

-[Qemu-devel] [PULL 11/11] jobs: remove job_defer_to_main_loop
+[Qemu-devel] [PULL 16/27] hw/ide: drop iov field from IDEBufferedRequest
-From: John Snow <jsnow@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Now that the job infrastructure is handling the job_completed call for
+@iov is used only to initialize @qiov. Let's use new
-all implemented jobs, we can remove the interface that allowed jobs to
+qemu_iovec_init_buf() instead, which simplifies the code.
 schedule their own completion.
-Signed-off-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
-Message-id: 20180830015734.19765-10-jsnow@redhat.com
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Message-id: 20190218140926.333779-17-vsementsov@virtuozzo.com
 Message-Id: <20190218140926.333779-17-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/job.h | 17 -----------------
+ include/hw/ide/internal.h |  1 -
- job.c              | 40 ++--------------------------------------
+ hw/ide/core.c             | 11 ++++++-----
-files changed, 2 insertions(+), 55 deletions(-)
+files changed, 6 insertions(+), 6 deletions(-)
-diff --git a/include/qemu/job.h b/include/qemu/job.h
+diff --git a/include/hw/ide/internal.h b/include/hw/ide/internal.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/job.h
+--- a/include/hw/ide/internal.h
-+++ b/include/qemu/job.h
++++ b/include/hw/ide/internal.h
-@@ -XXX,XX +XXX,XX @@ void job_finalize(Job *job, Error **errp);
+@@ -XXX,XX +XXX,XX @@ extern const char *IDE_DMA_CMD_lookup[IDE_DMA__COUNT];
-  */
- void job_dismiss(Job **job, Error **errp);
+ typedef struct IDEBufferedRequest {
+     QLIST_ENTRY(IDEBufferedRequest) list;
--typedef void JobDeferToMainLoopFn(Job *job, void *opaque);
+-    struct iovec iov;
--
+     QEMUIOVector qiov;
--/**
+     QEMUIOVector *original_qiov;
-- * @job: The job
+     BlockCompletionFunc *original_cb;
-- * @fn: The function to run in the main loop
+diff --git a/hw/ide/core.c b/hw/ide/core.c
 - * @opaque: The opaque value that is passed to @fn
 - *
 - * This function must be called by the main job coroutine just before it
 - * returns.  @fn is executed in the main loop with the job AioContext acquired.
 - *
 - * Block jobs must call bdrv_unref(), bdrv_close(), and anything that uses
 - * bdrv_drain_all() in the main loop.
 - *
 - * The @job AioContext is held while @fn executes.
 - */
 -void job_defer_to_main_loop(Job *job, JobDeferToMainLoopFn *fn, void *opaque);
 -
  /**
   * Synchronously finishes the given @job. If @finish is given, it is called to
   * trigger completion or cancellation of the job.
 diff --git a/job.c b/job.c
 index XXXXXXX..XXXXXXX 100644
---- a/job.c
+--- a/hw/ide/core.c
-+++ b/job.c
++++ b/hw/ide/core.c
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn job_co_entry(void *opaque)
+@@ -XXX,XX +XXX,XX @@ static void ide_buffered_readv_cb(void *opaque, int ret)
-     assert(job && job->driver && job->driver->run);
+     IDEBufferedRequest *req = opaque;
-     job_pause_point(job);
+     if (!req->orphaned) {
-     job->ret = job->driver->run(job, &job->err);
+         if (!ret) {
--    if (!job->deferred_to_main_loop) {
+-            qemu_iovec_from_buf(req->original_qiov, 0, req->iov.iov_base,
--        job->deferred_to_main_loop = true;
++            assert(req->qiov.size == req->original_qiov->size);
--        aio_bh_schedule_oneshot(qemu_get_aio_context(),
++            qemu_iovec_from_buf(req->original_qiov, 0,
--                                job_exit,
++                                req->qiov.local_iov.iov_base,
--                                job);
+                                 req->original_qiov->size);
--    }
+         }
-+    job->deferred_to_main_loop = true;
+         req->original_cb(req->original_opaque, ret);
-+    aio_bh_schedule_oneshot(qemu_get_aio_context(), job_exit, job);
+     }
      QLIST_REMOVE(req, list);
 -    qemu_vfree(req->iov.iov_base);
 +    qemu_vfree(qemu_iovec_buf(&req->qiov));
      g_free(req);
  }
+@@ -XXX,XX +XXX,XX @@ BlockAIOCB *ide_buffered_readv(IDEState *s, int64_t sector_num,
-@@ -XXX,XX +XXX,XX @@ void job_complete(Job *job, Error **errp)
+     req->original_qiov = iov;
-     job->driver->complete(job, errp);
+     req->original_cb = cb;
- }
+     req->original_opaque = opaque;
+-    req->iov.iov_base = qemu_blockalign(blk_bs(s->blk), iov->size);
--
+-    req->iov.iov_len = iov->size;
--typedef struct {
+-    qemu_iovec_init_external(&req->qiov, &req->iov, 1);
--    Job *job;
++    qemu_iovec_init_buf(&req->qiov, blk_blockalign(s->blk, iov->size),
--    JobDeferToMainLoopFn *fn;
++                        iov->size);
--    void *opaque;
--} JobDeferToMainLoopData;
+     aioreq = blk_aio_preadv(s->blk, sector_num << BDRV_SECTOR_BITS,
--
+                             &req->qiov, 0, ide_buffered_readv_cb, req);
 -static void job_defer_to_main_loop_bh(void *opaque)
 -{
 -    JobDeferToMainLoopData *data = opaque;
 -    Job *job = data->job;
 -    AioContext *aio_context = job->aio_context;
 -
 -    aio_context_acquire(aio_context);
 -    data->fn(data->job, data->opaque);
 -    aio_context_release(aio_context);
 -
 -    g_free(data);
 -}
 -
 -void job_defer_to_main_loop(Job *job, JobDeferToMainLoopFn *fn, void *opaque)
 -{
 -    JobDeferToMainLoopData *data = g_malloc(sizeof(*data));
 -    data->job = job;
 -    data->fn = fn;
 -    data->opaque = opaque;
 -    job->deferred_to_main_loop = true;
 -
 -    aio_bh_schedule_oneshot(qemu_get_aio_context(),
 -                            job_defer_to_main_loop_bh, data);
 -}
 -
  int job_finish_sync(Job *job, void (*finish)(Job *, Error **errp), Error **errp)
  {
      Error *local_err = NULL;
 --
-.17.1
+.20.1

-New patch
+[Qemu-devel] [PULL 17/27] hw/ide: drop iov field from IDEDMA
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+@iov is used only to initialize @qiov. Let's use new
+qemu_iovec_init_buf() instead, which simplifies the code.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20190218140926.333779-18-vsementsov@virtuozzo.com
+Message-Id: <20190218140926.333779-18-vsementsov@virtuozzo.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ include/hw/ide/internal.h | 1 -
+ hw/ide/atapi.c            | 5 ++---
+files changed, 2 insertions(+), 4 deletions(-)
+diff --git a/include/hw/ide/internal.h b/include/hw/ide/internal.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/hw/ide/internal.h
++++ b/include/hw/ide/internal.h
+@@ -XXX,XX +XXX,XX @@ struct IDEDMAOps {
+ struct IDEDMA {
+     const struct IDEDMAOps *ops;
+-    struct iovec iov;
+     QEMUIOVector qiov;
+     BlockAIOCB *aiocb;
+ };
+diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/ide/atapi.c
++++ b/hw/ide/atapi.c
+@@ -XXX,XX +XXX,XX @@ static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
+         data_offset = 0;
+     }
+     trace_ide_atapi_cmd_read_dma_cb_aio(s, s->lba, n);
+-    s->bus->dma->iov.iov_base = (void *)(s->io_buffer + data_offset);
+-    s->bus->dma->iov.iov_len = n * ATAPI_SECTOR_SIZE;
+-    qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1);
++    qemu_iovec_init_buf(&s->bus->dma->qiov, s->io_buffer + data_offset,
++                        n * ATAPI_SECTOR_SIZE);
+     s->bus->dma->aiocb = ide_buffered_readv(s, (int64_t)s->lba << 2,
+                                             &s->bus->dma->qiov, n * 4,
+--
+.20.1

-[Qemu-devel] [PULL 09/11] block/backup: make function variables consistently named
+[Qemu-devel] [PULL 18/27] virtio-blk: add acct_failed param to virtio_blk_handle_rw_error()
-From: John Snow <jsnow@redhat.com>
+From: Stefano Garzarella <sgarzare@redhat.com>
-Rename opaque_job to job to be consistent with other job implementations.
+We add acct_failed param in order to use virtio_blk_handle_rw_error()
-Rename 'job', the BackupBlockJob object, to 's' to also be consistent.
+also when is not required to call block_acct_failed(). (eg. a discard
 operation is failed)
-Suggested-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
-Signed-off-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
-Message-id: 20180830015734.19765-8-jsnow@redhat.com
+Message-id: 20190221103314.58500-2-sgarzare@redhat.com
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Message-Id: <20190221103314.58500-2-sgarzare@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/backup.c | 62 +++++++++++++++++++++++++-------------------------
+ hw/block/virtio-blk.c | 10 ++++++----
-file changed, 31 insertions(+), 31 deletions(-)
+file changed, 6 insertions(+), 4 deletions(-)
-diff --git a/block/backup.c b/block/backup.c
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/backup.c
+--- a/hw/block/virtio-blk.c
-+++ b/block/backup.c
++++ b/hw/block/virtio-blk.c
-@@ -XXX,XX +XXX,XX @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status)
      bdrv_dirty_iter_free(dbi);
  }
--static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
+ static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
-+static int coroutine_fn backup_run(Job *job, Error **errp)
+-    bool is_read)
 +    bool is_read, bool acct_failed)
  {
--    BackupBlockJob *job = container_of(opaque_job, BackupBlockJob, common.job);
+     VirtIOBlock *s = req->dev;
--    BlockDriverState *bs = blk_bs(job->common.blk);
+     BlockErrorAction action = blk_get_error_action(s->blk, is_read, error);
-+    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
+@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
-+    BlockDriverState *bs = blk_bs(s->common.blk);
+         s->rq = req;
-     int64_t offset, nb_clusters;
+     } else if (action == BLOCK_ERROR_ACTION_REPORT) {
-     int ret = 0;
+         virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
+-        block_acct_failed(blk_get_stats(s->blk), &req->acct);
--    QLIST_INIT(&job->inflight_reqs);
++        if (acct_failed) {
--    qemu_co_rwlock_init(&job->flush_rwlock);
++            block_acct_failed(blk_get_stats(s->blk), &req->acct);
-+    QLIST_INIT(&s->inflight_reqs);
++        }
-+    qemu_co_rwlock_init(&s->flush_rwlock);
+         virtio_blk_free_request(req);
 -    nb_clusters = DIV_ROUND_UP(job->len, job->cluster_size);
 -    job_progress_set_remaining(&job->common.job, job->len);
 +    nb_clusters = DIV_ROUND_UP(s->len, s->cluster_size);
 +    job_progress_set_remaining(job, s->len);
 -    job->copy_bitmap = hbitmap_alloc(nb_clusters, 0);
 -    if (job->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
 -        backup_incremental_init_copy_bitmap(job);
 +    s->copy_bitmap = hbitmap_alloc(nb_clusters, 0);
 +    if (s->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
 +        backup_incremental_init_copy_bitmap(s);
      } else {
 -        hbitmap_set(job->copy_bitmap, 0, nb_clusters);
 +        hbitmap_set(s->copy_bitmap, 0, nb_clusters);
      }
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_rw_complete(void *opaque, int ret)
--    job->before_write.notify = backup_before_write_notify;
+              * the memory until the request is completed (which will
--    bdrv_add_before_write_notifier(bs, &job->before_write);
+              * happen on the other side of the migration).
-+    s->before_write.notify = backup_before_write_notify;
+              */
-+    bdrv_add_before_write_notifier(bs, &s->before_write);
+-            if (virtio_blk_handle_rw_error(req, -ret, is_read)) {
++            if (virtio_blk_handle_rw_error(req, -ret, is_read, true)) {
--    if (job->sync_mode == MIRROR_SYNC_MODE_NONE) {
+                 continue;
 +    if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {
          /* All bits are set in copy_bitmap to allow any cluster to be copied.
           * This does not actually require them to be copied. */
 -        while (!job_is_cancelled(&job->common.job)) {
 +        while (!job_is_cancelled(job)) {
              /* Yield until the job is cancelled.  We just let our before_write
               * notify callback service CoW requests. */
 -            job_yield(&job->common.job);
 +            job_yield(job);
          }
 -    } else if (job->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
 -        ret = backup_run_incremental(job);
 +    } else if (s->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
 +        ret = backup_run_incremental(s);
      } else {
          /* Both FULL and TOP SYNC_MODE's require copying.. */
 -        for (offset = 0; offset < job->len;
 -             offset += job->cluster_size) {
 +        for (offset = 0; offset < s->len;
 +             offset += s->cluster_size) {
              bool error_is_read;
              int alloced = 0;
 -            if (yield_and_check(job)) {
 +            if (yield_and_check(s)) {
                  break;
              }
 -            if (job->sync_mode == MIRROR_SYNC_MODE_TOP) {
 +            if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {
                  int i;
                  int64_t n;
                  /* Check to see if these blocks are already in the
                   * backing file. */
 -                for (i = 0; i < job->cluster_size;) {
 +                for (i = 0; i < s->cluster_size;) {
                      /* bdrv_is_allocated() only returns true/false based
                       * on the first set of sectors it comes across that
                       * are are all in the same state.
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
                       * needed but at some point that is always the case. */
                      alloced =
                          bdrv_is_allocated(bs, offset + i,
 -                                          job->cluster_size - i, &n);
 +                                          s->cluster_size - i, &n);
                      i += n;
                      if (alloced || n == 0) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
              if (alloced < 0) {
                  ret = alloced;
              } else {
 -                ret = backup_do_cow(job, offset, job->cluster_size,
 +                ret = backup_do_cow(s, offset, s->cluster_size,
                                      &error_is_read, false);
              }
              if (ret < 0) {
                  /* Depending on error action, fail now or retry cluster */
                  BlockErrorAction action =
 -                    backup_error_action(job, error_is_read, -ret);
 +                    backup_error_action(s, error_is_read, -ret);
                  if (action == BLOCK_ERROR_ACTION_REPORT) {
                      break;
                  } else {
 -                    offset -= job->cluster_size;
 +                    offset -= s->cluster_size;
                      continue;
                  }
              }
          }
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_flush_complete(void *opaque, int ret)
+     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
+     if (ret) {
+-        if (virtio_blk_handle_rw_error(req, -ret, 0)) {
++        if (virtio_blk_handle_rw_error(req, -ret, 0, true)) {
+             goto out;
+         }
      }
--    notifier_with_return_remove(&job->before_write);
-+    notifier_with_return_remove(&s->before_write);
-     /* wait until pending backup_do_cow() calls have completed */
--    qemu_co_rwlock_wrlock(&job->flush_rwlock);
--    qemu_co_rwlock_unlock(&job->flush_rwlock);
--    hbitmap_free(job->copy_bitmap);
-+    qemu_co_rwlock_wrlock(&s->flush_rwlock);
-+    qemu_co_rwlock_unlock(&s->flush_rwlock);
-+    hbitmap_free(s->copy_bitmap);
-     return ret;
- }
 --
-.17.1
+.20.1

-New patch
+[Qemu-devel] [PULL 19/27] virtio-blk: add host_features field in VirtIOBlock
+From: Stefano Garzarella <sgarzare@redhat.com>
+Since configurable features for virtio-blk are growing, this patch
+adds host_features field in the struct VirtIOBlock. (as in virtio-net)
+In this way, we can avoid to add new fields for new properties and
+we can directly set VIRTIO_BLK_F* flags in the host_features.
+We update "config-wce" and "scsi" property definition to use the new
+host_features field without change the behaviour.
+Suggested-by: Michael S. Tsirkin <mst@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-id: 20190221103314.58500-3-sgarzare@redhat.com
+Message-Id: <20190221103314.58500-3-sgarzare@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ include/hw/virtio/virtio-blk.h |  3 +--
+ hw/block/virtio-blk.c          | 16 +++++++++-------
+files changed, 10 insertions(+), 9 deletions(-)
+diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/hw/virtio/virtio-blk.h
++++ b/include/hw/virtio/virtio-blk.h
+@@ -XXX,XX +XXX,XX @@ struct VirtIOBlkConf
+     BlockConf conf;
+     IOThread *iothread;
+     char *serial;
+-    uint32_t scsi;
+-    uint32_t config_wce;
+     uint32_t request_merging;
+     uint16_t num_queues;
+     uint16_t queue_size;
+@@ -XXX,XX +XXX,XX @@ typedef struct VirtIOBlock {
+     bool dataplane_disabled;
+     bool dataplane_started;
+     struct VirtIOBlockDataPlane *dataplane;
++    uint64_t host_features;
+ } VirtIOBlock;
+ typedef struct VirtIOBlockReq {
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/virtio-blk.c
++++ b/hw/block/virtio-blk.c
+@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req)
+      */
+     scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base;
+-    if (!blk->conf.scsi) {
++    if (!virtio_has_feature(blk->host_features, VIRTIO_BLK_F_SCSI)) {
+         status = VIRTIO_BLK_S_UNSUPP;
+         goto fail;
+     }
+@@ -XXX,XX +XXX,XX @@ static uint64_t virtio_blk_get_features(VirtIODevice *vdev, uint64_t features,
+ {
+     VirtIOBlock *s = VIRTIO_BLK(vdev);
++    /* Firstly sync all virtio-blk possible supported features */
++    features |= s->host_features;
++
+     virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX);
+     virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY);
+     virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY);
+     virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE);
+     if (virtio_has_feature(features, VIRTIO_F_VERSION_1)) {
+-        if (s->conf.scsi) {
++        if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_SCSI)) {
+             error_setg(errp, "Please set scsi=off for virtio-blk devices in order to use virtio 1.0");
+             return 0;
+         }
+@@ -XXX,XX +XXX,XX @@ static uint64_t virtio_blk_get_features(VirtIODevice *vdev, uint64_t features,
+         virtio_add_feature(&features, VIRTIO_BLK_F_SCSI);
+     }
+-    if (s->conf.config_wce) {
+-        virtio_add_feature(&features, VIRTIO_BLK_F_CONFIG_WCE);
+-    }
+     if (blk_enable_write_cache(s->blk)) {
+         virtio_add_feature(&features, VIRTIO_BLK_F_WCE);
+     }
+@@ -XXX,XX +XXX,XX @@ static Property virtio_blk_properties[] = {
+     DEFINE_BLOCK_ERROR_PROPERTIES(VirtIOBlock, conf.conf),
+     DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, conf.conf),
+     DEFINE_PROP_STRING("serial", VirtIOBlock, conf.serial),
+-    DEFINE_PROP_BIT("config-wce", VirtIOBlock, conf.config_wce, 0, true),
++    DEFINE_PROP_BIT64("config-wce", VirtIOBlock, host_features,
++                      VIRTIO_BLK_F_CONFIG_WCE, true),
+ #ifdef __linux__
+-    DEFINE_PROP_BIT("scsi", VirtIOBlock, conf.scsi, 0, false),
++    DEFINE_PROP_BIT64("scsi", VirtIOBlock, host_features,
++                      VIRTIO_BLK_F_SCSI, false),
+ #endif
+     DEFINE_PROP_BIT("request-merging", VirtIOBlock, conf.request_merging, 0,
+                     true),
+--
+.20.1

-[Qemu-devel] [PULL 05/11] jobs: add exit shim
+[Qemu-devel] [PULL 20/27] virtio-blk: add "discard" and "write-zeroes" properties
-From: John Snow <jsnow@redhat.com>
+From: Stefano Garzarella <sgarzare@redhat.com>
-All jobs do the same thing when they leave their running loop:
+In order to avoid migration issues, we enable DISCARD and
-- Store the return code in a structure
+WRITE_ZEROES features only for machine type >= 4.0
 - wait to receive this structure in the main thread
 - signal job completion via job_completed
-Few jobs do anything beyond exactly this. Consolidate this exit
+As discussed with Michael S. Tsirkin and Stefan Hajnoczi on the
-logic for a net reduction in SLOC.
+list [1], DISCARD operation should not have security implications
 (eg. page cache attacks), so we can enable it by default.
-More seriously, when we utilize job_defer_to_main_loop_bh to call
+[1] https://lists.gnu.org/archive/html/qemu-devel/2019-02/msg00504.html
 a function that calls job_completed, job_finalize_single will run
 in a context where it has recursively taken the aio_context lock,
 which can cause hangs if it puts down a reference that causes a flush.
-You can observe this in practice by looking at mirror_exit's careful
+Suggested-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
-placement of job_completed and bdrv_unref calls.
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
 Message-id: 20190221103314.58500-4-sgarzare@redhat.com
 Message-Id: <20190221103314.58500-4-sgarzare@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  hw/block/virtio-blk.c | 4 ++++
  hw/core/machine.c     | 2 ++
 files changed, 6 insertions(+)
-If we centralize job exiting, we can signal job completion from outside
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
 of the aio_context, which should allow for job cleanup code to run with
 only one lock, which makes cleanup callbacks less tricky to write.
 Signed-off-by: John Snow <jsnow@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-id: 20180830015734.19765-4-jsnow@redhat.com
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  include/qemu/job.h | 11 +++++++++++
  job.c              | 18 ++++++++++++++++++
 files changed, 29 insertions(+)
 diff --git a/include/qemu/job.h b/include/qemu/job.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/job.h
+--- a/hw/block/virtio-blk.c
-+++ b/include/qemu/job.h
++++ b/hw/block/virtio-blk.c
-@@ -XXX,XX +XXX,XX @@ struct JobDriver {
+@@ -XXX,XX +XXX,XX @@ static Property virtio_blk_properties[] = {
-      */
+     DEFINE_PROP_UINT16("queue-size", VirtIOBlock, conf.queue_size, 128),
-     void (*drain)(Job *job);
+     DEFINE_PROP_LINK("iothread", VirtIOBlock, conf.iothread, TYPE_IOTHREAD,
+                      IOThread *),
-+    /**
++    DEFINE_PROP_BIT64("discard", VirtIOBlock, host_features,
-+     * If the callback is not NULL, exit will be invoked from the main thread
++                      VIRTIO_BLK_F_DISCARD, true),
-+     * when the job's coroutine has finished, but before transactional
++    DEFINE_PROP_BIT64("write-zeroes", VirtIOBlock, host_features,
-+     * convergence; before @prepare or @abort.
++                      VIRTIO_BLK_F_WRITE_ZEROES, true),
-+     *
+     DEFINE_PROP_END_OF_LIST(),
-+     * FIXME TODO: This callback is only temporary to transition remaining jobs
+ };
-+     * to prepare/commit/abort/clean callbacks and will be removed before 3.1.
-+     * is released.
+diff --git a/hw/core/machine.c b/hw/core/machine.c
 +     */
 +    void (*exit)(Job *job);
 +
      /**
       * If the callback is not NULL, prepare will be invoked when all the jobs
       * belonging to the same transaction complete; or upon this job's completion
 diff --git a/job.c b/job.c
 index XXXXXXX..XXXXXXX 100644
---- a/job.c
+--- a/hw/core/machine.c
-+++ b/job.c
++++ b/hw/core/machine.c
-@@ -XXX,XX +XXX,XX @@ void job_drain(Job *job)
+@@ -XXX,XX +XXX,XX @@ GlobalProperty hw_compat_3_1[] = {
-     }
+     { "usb-kbd", "serial", "42" },
- }
+     { "usb-mouse", "serial", "42" },
+     { "usb-kbd", "serial", "42" },
-+static void job_exit(void *opaque)
++    { "virtio-blk-device", "discard", "false" },
-+{
++    { "virtio-blk-device", "write-zeroes", "false" },
-+    Job *job = (Job *)opaque;
+ };
-+    AioContext *aio_context = job->aio_context;
+ const size_t hw_compat_3_1_len = G_N_ELEMENTS(hw_compat_3_1);
 +
 +    if (job->driver->exit) {
 +        aio_context_acquire(aio_context);
 +        job->driver->exit(job);
 +        aio_context_release(aio_context);
 +    }
 +    job_completed(job, job->ret);
 +}
  /**
   * All jobs must allow a pause point before entering their job proper. This
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn job_co_entry(void *opaque)
      assert(job && job->driver && job->driver->run);
      job_pause_point(job);
      job->ret = job->driver->run(job, &job->err);
 +    if (!job->deferred_to_main_loop) {
 +        job->deferred_to_main_loop = true;
 +        aio_bh_schedule_oneshot(qemu_get_aio_context(),
 +                                job_exit,
 +                                job);
 +    }
  }
 --
-.17.1
+.20.1

-[Qemu-devel] [PULL 07/11] block/mirror: utilize job_exit shim
+[Qemu-devel] [PULL 21/27] virtio-net: make VirtIOFeature usable for other virtio devices
-From: John Snow <jsnow@redhat.com>
+From: Stefano Garzarella <sgarzare@redhat.com>
-Change the manual deferment to mirror_exit into the implicit
+In order to use VirtIOFeature also in other virtio devices, we move
-callback to job_exit and the mirror_exit callback.
+its declaration and the endof() macro (renamed in virtio_endof())
 in virtio.h.
 We add virtio_feature_get_config_size() function to iterate the array
 of VirtIOFeature and to return the config size depending on the
 features enabled. (as virtio_net_set_config_size() did)
-This does change the order of some bdrv_unref calls and job_completed,
+Suggested-by: Michael S. Tsirkin <mst@redhat.com>
-but thanks to the new context in which we call .exit, this is safe to
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-defer the possible flushing of any nodes to the job_finalize_single
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
-cleanup stage.
+Message-id: 20190221103314.58500-5-sgarzare@redhat.com
 Message-Id: <20190221103314.58500-5-sgarzare@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/hw/virtio/virtio.h | 15 +++++++++++++++
  hw/net/virtio-net.c        | 31 +++++++------------------------
  hw/virtio/virtio.c         | 15 +++++++++++++++
 files changed, 37 insertions(+), 24 deletions(-)
-Signed-off-by: John Snow <jsnow@redhat.com>
+diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h
 Message-id: 20180830015734.19765-6-jsnow@redhat.com
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/mirror.c | 29 +++++++++++------------------
 file changed, 11 insertions(+), 18 deletions(-)
 diff --git a/block/mirror.c b/block/mirror.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/mirror.c
+--- a/include/hw/virtio/virtio.h
-+++ b/block/mirror.c
++++ b/include/hw/virtio/virtio.h
-@@ -XXX,XX +XXX,XX @@ static void mirror_wait_for_all_io(MirrorBlockJob *s)
+@@ -XXX,XX +XXX,XX @@ static inline hwaddr vring_align(hwaddr addr,
-     }
+     return QEMU_ALIGN_UP(addr, align);
  }
--typedef struct {
++/*
--    int ret;
++ * Calculate the number of bytes up to and including the given 'field' of
--} MirrorExitData;
++ * 'container'.
 + */
 +#define virtio_endof(container, field) \
 +    (offsetof(container, field) + sizeof_field(container, field))
 +
 +typedef struct VirtIOFeature {
 +    uint64_t flags;
 +    size_t end;
 +} VirtIOFeature;
 +
 +size_t virtio_feature_get_config_size(VirtIOFeature *features,
 +                                      uint64_t host_features);
 +
  typedef struct VirtQueue VirtQueue;
  #define VIRTQUEUE_MAX_SIZE 1024
 diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/net/virtio-net.c
 +++ b/hw/net/virtio-net.c
@@ -XXX,XX +XXX,XX @@ static inline __virtio16 *virtio_net_rsc_ext_num_dupacks(
  #endif
 -/*
 - * Calculate the number of bytes up to and including the given 'field' of
 - * 'container'.
 - */
 -#define endof(container, field) \
 -    (offsetof(container, field) + sizeof_field(container, field))
 -
--static void mirror_exit(Job *job, void *opaque)
+-typedef struct VirtIOFeature {
-+static void mirror_exit(Job *job)
+-    uint64_t flags;
 -    size_t end;
 -} VirtIOFeature;
 -
  static VirtIOFeature feature_sizes[] = {
      {.flags = 1ULL << VIRTIO_NET_F_MAC,
 -     .end = endof(struct virtio_net_config, mac)},
 +     .end = virtio_endof(struct virtio_net_config, mac)},
      {.flags = 1ULL << VIRTIO_NET_F_STATUS,
 -     .end = endof(struct virtio_net_config, status)},
 +     .end = virtio_endof(struct virtio_net_config, status)},
      {.flags = 1ULL << VIRTIO_NET_F_MQ,
 -     .end = endof(struct virtio_net_config, max_virtqueue_pairs)},
 +     .end = virtio_endof(struct virtio_net_config, max_virtqueue_pairs)},
      {.flags = 1ULL << VIRTIO_NET_F_MTU,
 -     .end = endof(struct virtio_net_config, mtu)},
 +     .end = virtio_endof(struct virtio_net_config, mtu)},
      {.flags = 1ULL << VIRTIO_NET_F_SPEED_DUPLEX,
 -     .end = endof(struct virtio_net_config, duplex)},
 +     .end = virtio_endof(struct virtio_net_config, duplex)},
      {}
  };
@@ -XXX,XX +XXX,XX @@ static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
  static void virtio_net_set_config_size(VirtIONet *n, uint64_t host_features)
  {
-     MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
+-    int i, config_size = 0;
-     BlockJob *bjob = &s->common;
+     virtio_add_feature(&host_features, VIRTIO_NET_F_MAC);
--    MirrorExitData *data = opaque;
-     MirrorBDSOpaque *bs_opaque = s->mirror_top_bs->opaque;
+-    for (i = 0; feature_sizes[i].flags != 0; i++) {
-     AioContext *replace_aio_context = NULL;
+-        if (host_features & feature_sizes[i].flags) {
-     BlockDriverState *src = s->mirror_top_bs->backing->bs;
+-            config_size = MAX(feature_sizes[i].end, config_size);
-     BlockDriverState *target_bs = blk_bs(s->target);
+-        }
-     BlockDriverState *mirror_top_bs = s->mirror_top_bs;
+-    }
-     Error *local_err = NULL;
+-    n->config_size = config_size;
-+    int ret = job->ret;
++    n->config_size = virtio_feature_get_config_size(feature_sizes,
++                                                    host_features);
      bdrv_release_dirty_bitmap(src, s->dirty_bitmap);
 -    /* Make sure that the source BDS doesn't go away before we called
 -     * job_completed(). */
 +    /* Make sure that the source BDS doesn't go away during bdrv_replace_node,
 +     * before we can call bdrv_drained_end */
      bdrv_ref(src);
      bdrv_ref(mirror_top_bs);
      bdrv_ref(target_bs);
@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)
              bdrv_set_backing_hd(target_bs, backing, &local_err);
              if (local_err) {
                  error_report_err(local_err);
 -                data->ret = -EPERM;
 +                ret = -EPERM;
              }
          }
      }
@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)
          aio_context_acquire(replace_aio_context);
      }
 -    if (s->should_complete && data->ret == 0) {
 +    if (s->should_complete && ret == 0) {
          BlockDriverState *to_replace = src;
          if (s->to_replace) {
              to_replace = s->to_replace;
@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)
          bdrv_drained_end(target_bs);
          if (local_err) {
              error_report_err(local_err);
 -            data->ret = -EPERM;
 +            ret = -EPERM;
          }
      }
      if (s->to_replace) {
@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)
      blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);
      bs_opaque->job = NULL;
 -    job_completed(job, data->ret);
 -    g_free(data);
      bdrv_drained_end(src);
      bdrv_unref(mirror_top_bs);
      bdrv_unref(src);
 +
 +    job->ret = ret;
  }
- static void mirror_throttle(MirrorBlockJob *s)
+ void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
-@@ -XXX,XX +XXX,XX @@ static int mirror_flush(MirrorBlockJob *s)
+diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
- static int coroutine_fn mirror_run(Job *job, Error **errp)
+index XXXXXXX..XXXXXXX 100644
- {
+--- a/hw/virtio/virtio.c
-     MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
++++ b/hw/virtio/virtio.c
--    MirrorExitData *data;
+@@ -XXX,XX +XXX,XX @@ int virtio_set_features(VirtIODevice *vdev, uint64_t val)
      BlockDriverState *bs = s->mirror_top_bs->backing->bs;
      BlockDriverState *target_bs = blk_bs(s->target);
      bool need_drain = true;
@@ -XXX,XX +XXX,XX @@ immediate_exit:
      g_free(s->in_flight_bitmap);
      bdrv_dirty_iter_free(s->dbi);
 -    data = g_malloc(sizeof(*data));
 -    data->ret = ret;
 -
      if (need_drain) {
          bdrv_drained_begin(bs);
      }
 -    job_defer_to_main_loop(&s->common.job, mirror_exit, data);
      return ret;
  }
-@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver mirror_job_driver = {
++size_t virtio_feature_get_config_size(VirtIOFeature *feature_sizes,
-         .user_resume            = block_job_user_resume,
++                                      uint64_t host_features)
-         .drain                  = block_job_drain,
++{
-         .run                    = mirror_run,
++    size_t config_size = 0;
-+        .exit                   = mirror_exit,
++    int i;
-         .pause                  = mirror_pause,
++
-         .complete               = mirror_complete,
++    for (i = 0; feature_sizes[i].flags != 0; i++) {
-     },
++        if (host_features & feature_sizes[i].flags) {
-@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_active_job_driver = {
++            config_size = MAX(feature_sizes[i].end, config_size);
-         .user_resume            = block_job_user_resume,
++        }
-         .drain                  = block_job_drain,
++    }
-         .run                    = mirror_run,
++
-+        .exit                   = mirror_exit,
++    return config_size;
-         .pause                  = mirror_pause,
++}
-         .complete               = mirror_complete,
++
-     },
+ int virtio_load(VirtIODevice *vdev, QEMUFile *f, int version_id)
  {
      int i, ret;
 --
-.17.1
+.20.1

-[Qemu-devel] [PULL 04/11] jobs: canonize Error object
+[Qemu-devel] [PULL 22/27] virtio-blk: set config size depending on the features enabled
-From: John Snow <jsnow@redhat.com>
+From: Stefano Garzarella <sgarzare@redhat.com>
-Jobs presently use both an Error object in the case of the create job,
+Starting from DISABLE and WRITE_ZEROES features, we use an array of
-and char strings in the case of generic errors elsewhere.
+VirtIOFeature (as virtio-net) to properly set the config size
 depending on the features enabled.
-Unify the two paths as just j->err, and remove the extra argument from
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-job_completed. The integer error code for job_completed is kept for now,
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
-to be removed shortly in a separate patch.
+Message-id: 20190221103314.58500-6-sgarzare@redhat.com
 Message-Id: <20190221103314.58500-6-sgarzare@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/hw/virtio/virtio-blk.h |  1 +
  hw/block/virtio-blk.c          | 31 +++++++++++++++++++++++++------
 files changed, 26 insertions(+), 6 deletions(-)
-Signed-off-by: John Snow <jsnow@redhat.com>
+diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
 Message-id: 20180830015734.19765-3-jsnow@redhat.com
 [mreitz: Dropped a superfluous g_strdup()]
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  include/qemu/job.h        | 14 ++++++++------
  block/backup.c            |  2 +-
  block/commit.c            |  2 +-
  block/create.c            |  5 ++---
  block/mirror.c            |  2 +-
  block/stream.c            |  2 +-
  job-qmp.c                 |  5 +++--
  job.c                     | 18 ++++++------------
  tests/test-bdrv-drain.c   |  2 +-
  tests/test-blockjob-txn.c |  2 +-
  tests/test-blockjob.c     |  2 +-
 files changed, 26 insertions(+), 30 deletions(-)
 diff --git a/include/qemu/job.h b/include/qemu/job.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/job.h
+--- a/include/hw/virtio/virtio-blk.h
-+++ b/include/qemu/job.h
++++ b/include/hw/virtio/virtio-blk.h
-@@ -XXX,XX +XXX,XX @@ typedef struct Job {
+@@ -XXX,XX +XXX,XX @@ typedef struct VirtIOBlock {
-     /** Estimated progress_current value at the completion of the job */
+     bool dataplane_started;
-     int64_t progress_total;
+     struct VirtIOBlockDataPlane *dataplane;
+     uint64_t host_features;
--    /** Error string for a failed job (NULL if, and only if, job->ret == 0) */
++    size_t config_size;
--    char *error;
+ } VirtIOBlock;
--
-     /** ret code passed to job_completed. */
+ typedef struct VirtIOBlockReq {
-     int ret;
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
+index XXXXXXX..XXXXXXX 100644
-+    /**
+--- a/hw/block/virtio-blk.c
-+     * Error object for a failed job.
++++ b/hw/block/virtio-blk.c
-+     * If job->ret is nonzero and an error object was not set, it will be set
+@@ -XXX,XX +XXX,XX @@
-+     * to strerror(-job->ret) during job_completed.
+ #include "hw/virtio/virtio-bus.h"
-+     */
+ #include "hw/virtio/virtio-access.h"
-+    Error *err;
 -/* We don't support discard yet, hide associated config fields. */
 +/* Config size before the discard support (hide associated config fields) */
  #define VIRTIO_BLK_CFG_SIZE offsetof(struct virtio_blk_config, \
                                       max_discard_sectors)
 +/*
 + * Starting from the discard feature, we can use this array to properly
 + * set the config size depending on the features enabled.
 + */
 +static VirtIOFeature feature_sizes[] = {
 +    {.flags = 1ULL << VIRTIO_BLK_F_DISCARD,
 +     .end = virtio_endof(struct virtio_blk_config, discard_sector_alignment)},
 +    {.flags = 1ULL << VIRTIO_BLK_F_WRITE_ZEROES,
 +     .end = virtio_endof(struct virtio_blk_config, write_zeroes_may_unmap)},
 +    {}
 +};
 +
-     /** The completion function that will be called when the job completes.  */
++static void virtio_blk_set_config_size(VirtIOBlock *s, uint64_t host_features)
-     BlockCompletionFunc *cb;
++{
++    s->config_size = MAX(VIRTIO_BLK_CFG_SIZE,
-@@ -XXX,XX +XXX,XX @@ void job_transition_to_ready(Job *job);
++        virtio_feature_get_config_size(feature_sizes, host_features));
- /**
++
-  * @job: The job being completed.
++    assert(s->config_size <= sizeof(struct virtio_blk_config));
-  * @ret: The status code.
++}
-- * @error: The error message for a failing job (only with @ret < 0). If @ret is
-- *         negative, but NULL is given for @error, strerror() is used.
+ static void virtio_blk_init_request(VirtIOBlock *s, VirtQueue *vq,
-  *
+                                     VirtIOBlockReq *req)
-  * Marks @job as completed. If @ret is non-zero, the job transaction it is part
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
-  * of is aborted. If @ret is zero, the job moves into the WAITING state. If it
+     blkcfg.alignment_offset = 0;
-  * is the last job to complete in its transaction, all jobs in the transaction
+     blkcfg.wce = blk_enable_write_cache(s->blk);
-  * move from WAITING to PENDING.
+     virtio_stw_p(vdev, &blkcfg.num_queues, s->conf.num_queues);
-  */
+-    memcpy(config, &blkcfg, VIRTIO_BLK_CFG_SIZE);
--void job_completed(Job *job, int ret, Error *error);
+-    QEMU_BUILD_BUG_ON(VIRTIO_BLK_CFG_SIZE > sizeof(blkcfg));
-+void job_completed(Job *job, int ret);
++    memcpy(config, &blkcfg, s->config_size);
  /** Asynchronously complete the specified @job. */
  void job_complete(Job *job, Error **errp);
 diff --git a/block/backup.c b/block/backup.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/backup.c
 +++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void backup_complete(Job *job, void *opaque)
  {
      BackupCompleteData *data = opaque;
 -    job_completed(job, data->ret, NULL);
 +    job_completed(job, data->ret);
      g_free(data);
  }
-diff --git a/block/commit.c b/block/commit.c
+ static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
-index XXXXXXX..XXXXXXX 100644
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
---- a/block/commit.c
+     VirtIOBlock *s = VIRTIO_BLK(vdev);
-+++ b/block/commit.c
+     struct virtio_blk_config blkcfg;
-@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)
-      * bdrv_set_backing_hd() to fail. */
+-    memcpy(&blkcfg, config, VIRTIO_BLK_CFG_SIZE);
-     block_job_remove_all_bdrv(bjob);
+-    QEMU_BUILD_BUG_ON(VIRTIO_BLK_CFG_SIZE > sizeof(blkcfg));
++    memcpy(&blkcfg, config, s->config_size);
--    job_completed(job, ret, NULL);
-+    job_completed(job, ret);
+     aio_context_acquire(blk_get_aio_context(s->blk));
-     g_free(data);
+     blk_set_enable_write_cache(s->blk, blkcfg.wce != 0);
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
-     /* If bdrv_drop_intermediate() didn't already do that, remove the commit
+         return;
 diff --git a/block/create.c b/block/create.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/create.c
 +++ b/block/create.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlockdevCreateJob {
      BlockDriver *drv;
      BlockdevCreateOptions *opts;
      int ret;
 -    Error *err;
  } BlockdevCreateJob;
  static void blockdev_create_complete(Job *job, void *opaque)
  {
      BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
 -    job_completed(job, s->ret, s->err);
 +    job_completed(job, s->ret);
  }
  static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
      BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
      job_progress_set_remaining(&s->common, 1);
 -    s->ret = s->drv->bdrv_co_create(s->opts, &s->err);
 +    s->ret = s->drv->bdrv_co_create(s->opts, errp);
      job_progress_update(&s->common, 1);
      qapi_free_BlockdevCreateOptions(s->opts);
 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 void mirror_exit(Job *job, void *opaque)
      blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);
      bs_opaque->job = NULL;
 -    job_completed(job, data->ret, NULL);
 +    job_completed(job, data->ret);
      g_free(data);
      bdrv_drained_end(src);
 diff --git a/block/stream.c b/block/stream.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/stream.c
 +++ b/block/stream.c
@@ -XXX,XX +XXX,XX @@ out:
      }
-     g_free(s->backing_file_str);
+-    virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, VIRTIO_BLK_CFG_SIZE);
--    job_completed(job, data->ret, NULL);
++    virtio_blk_set_config_size(s, s->host_features);
-+    job_completed(job, data->ret);
++
-     g_free(data);
++    virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, s->config_size);
- }
+     s->blk = conf->conf.blk;
-diff --git a/job-qmp.c b/job-qmp.c
+     s->rq = NULL;
 index XXXXXXX..XXXXXXX 100644
 --- a/job-qmp.c
 +++ b/job-qmp.c
@@ -XXX,XX +XXX,XX @@ static JobInfo *job_query_single(Job *job, Error **errp)
          .status             = job->status,
          .current_progress   = job->progress_current,
          .total_progress     = job->progress_total,
 -        .has_error          = !!job->error,
 -        .error              = g_strdup(job->error),
 +        .has_error          = !!job->err,
 +        .error              = job->err ? \
 +                              g_strdup(error_get_pretty(job->err)) : NULL,
      };
      return info;
 diff --git a/job.c b/job.c
 index XXXXXXX..XXXXXXX 100644
 --- a/job.c
 +++ b/job.c
@@ -XXX,XX +XXX,XX @@ void job_unref(Job *job)
          QLIST_REMOVE(job, job_list);
 -        g_free(job->error);
 +        error_free(job->err);
          g_free(job->id);
          g_free(job);
      }
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn job_co_entry(void *opaque)
      assert(job && job->driver && job->driver->run);
      job_pause_point(job);
 -    job->ret = job->driver->run(job, NULL);
 +    job->ret = job->driver->run(job, &job->err);
  }
@@ -XXX,XX +XXX,XX @@ static void job_update_rc(Job *job)
          job->ret = -ECANCELED;
      }
      if (job->ret) {
 -        if (!job->error) {
 -            job->error = g_strdup(strerror(-job->ret));
 +        if (!job->err) {
 +            error_setg(&job->err, "%s", strerror(-job->ret));
          }
          job_state_transition(job, JOB_STATUS_ABORTING);
      }
@@ -XXX,XX +XXX,XX @@ static void job_completed_txn_success(Job *job)
      }
  }
 -void job_completed(Job *job, int ret, Error *error)
 +void job_completed(Job *job, int ret)
  {
      assert(job && job->txn && !job_is_completed(job));
      job->ret = ret;
 -    if (error) {
 -        assert(job->ret < 0);
 -        job->error = g_strdup(error_get_pretty(error));
 -        error_free(error);
 -    }
 -
      job_update_rc(job);
      trace_job_completed(job, ret, job->ret);
      if (job->ret) {
@@ -XXX,XX +XXX,XX @@ void job_cancel(Job *job, bool force)
      }
      job_cancel_async(job, force);
      if (!job_started(job)) {
 -        job_completed(job, -ECANCELED, NULL);
 +        job_completed(job, -ECANCELED);
      } else if (job->deferred_to_main_loop) {
          job_completed_txn_abort(job);
      } else {
 diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-bdrv-drain.c
 +++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ typedef struct TestBlockJob {
  static void test_job_completed(Job *job, void *opaque)
  {
 -    job_completed(job, 0, NULL);
 +    job_completed(job, 0);
  }
  static int coroutine_fn test_job_run(Job *job, Error **errp)
 diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob-txn.c
 +++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static void test_block_job_complete(Job *job, void *opaque)
          rc = -ECANCELED;
      }
 -    job_completed(job, rc, NULL);
 +    job_completed(job, rc);
      bdrv_unref(bs);
  }
 diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob.c
 +++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static void cancel_job_completed(Job *job, void *opaque)
  {
      CancelJob *s = opaque;
      s->completed = true;
 -    job_completed(job, 0, NULL);
 +    job_completed(job, 0);
  }
  static void cancel_job_complete(Job *job, Error **errp)
 --
-.17.1
+.20.1

-New patch
+[Qemu-devel] [PULL 23/27] virtio-blk: add DISCARD and WRITE_ZEROES features
+From: Stefano Garzarella <sgarzare@redhat.com>
 This patch adds the support of DISCARD and WRITE_ZEROES commands,
 that have been introduced in the virtio-blk protocol to have
 better performance when using SSD backend.
 We support only one segment per request since multiple segments
 are not widely used and there are no userspace APIs that allow
 applications to submit multiple segments in a single call.
 Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
 Message-id: 20190221103314.58500-7-sgarzare@redhat.com
 Message-Id: <20190221103314.58500-7-sgarzare@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/hw/virtio/virtio-blk.h |   2 +
  hw/block/virtio-blk.c          | 184 +++++++++++++++++++++++++++++++++
 files changed, 186 insertions(+)
 diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/hw/virtio/virtio-blk.h
 +++ b/include/hw/virtio/virtio-blk.h
@@ -XXX,XX +XXX,XX @@ struct VirtIOBlkConf
      uint32_t request_merging;
      uint16_t num_queues;
      uint16_t queue_size;
 +    uint32_t max_discard_sectors;
 +    uint32_t max_write_zeroes_sectors;
  };
  struct VirtIOBlockDataPlane;
 diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/virtio-blk.c
 +++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ out:
      aio_context_release(blk_get_aio_context(s->conf.conf.blk));
  }
 +static void virtio_blk_discard_write_zeroes_complete(void *opaque, int ret)
 +{
 +    VirtIOBlockReq *req = opaque;
 +    VirtIOBlock *s = req->dev;
 +    bool is_write_zeroes = (virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type) &
 +                            ~VIRTIO_BLK_T_BARRIER) == VIRTIO_BLK_T_WRITE_ZEROES;
 +
 +    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
 +    if (ret) {
 +        if (virtio_blk_handle_rw_error(req, -ret, false, is_write_zeroes)) {
 +            goto out;
 +        }
 +    }
 +
 +    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
 +    if (is_write_zeroes) {
 +        block_acct_done(blk_get_stats(s->blk), &req->acct);
 +    }
 +    virtio_blk_free_request(req);
 +
 +out:
 +    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
 +}
 +
  #ifdef __linux__
  typedef struct {
@@ -XXX,XX +XXX,XX @@ static bool virtio_blk_sect_range_ok(VirtIOBlock *dev,
      return true;
  }
 +static uint8_t virtio_blk_handle_discard_write_zeroes(VirtIOBlockReq *req,
 +    struct virtio_blk_discard_write_zeroes *dwz_hdr, bool is_write_zeroes)
 +{
 +    VirtIOBlock *s = req->dev;
 +    VirtIODevice *vdev = VIRTIO_DEVICE(s);
 +    uint64_t sector;
 +    uint32_t num_sectors, flags, max_sectors;
 +    uint8_t err_status;
 +    int bytes;
 +
 +    sector = virtio_ldq_p(vdev, &dwz_hdr->sector);
 +    num_sectors = virtio_ldl_p(vdev, &dwz_hdr->num_sectors);
 +    flags = virtio_ldl_p(vdev, &dwz_hdr->flags);
 +    max_sectors = is_write_zeroes ? s->conf.max_write_zeroes_sectors :
 +                  s->conf.max_discard_sectors;
 +
 +    /*
 +     * max_sectors is at most BDRV_REQUEST_MAX_SECTORS, this check
 +     * make us sure that "num_sectors << BDRV_SECTOR_BITS" can fit in
 +     * the integer variable.
 +     */
 +    if (unlikely(num_sectors > max_sectors)) {
 +        err_status = VIRTIO_BLK_S_IOERR;
 +        goto err;
 +    }
 +
 +    bytes = num_sectors << BDRV_SECTOR_BITS;
 +
 +    if (unlikely(!virtio_blk_sect_range_ok(s, sector, bytes))) {
 +        err_status = VIRTIO_BLK_S_IOERR;
 +        goto err;
 +    }
 +
 +    /*
 +     * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for discard
 +     * and write zeroes commands if any unknown flag is set.
 +     */
 +    if (unlikely(flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
 +        err_status = VIRTIO_BLK_S_UNSUPP;
 +        goto err;
 +    }
 +
 +    if (is_write_zeroes) { /* VIRTIO_BLK_T_WRITE_ZEROES */
 +        int blk_aio_flags = 0;
 +
 +        if (flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) {
 +            blk_aio_flags |= BDRV_REQ_MAY_UNMAP;
 +        }
 +
 +        block_acct_start(blk_get_stats(s->blk), &req->acct, bytes,
 +                         BLOCK_ACCT_WRITE);
 +
 +        blk_aio_pwrite_zeroes(s->blk, sector << BDRV_SECTOR_BITS,
 +                              bytes, blk_aio_flags,
 +                              virtio_blk_discard_write_zeroes_complete, req);
 +    } else { /* VIRTIO_BLK_T_DISCARD */
 +        /*
 +         * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for
 +         * discard commands if the unmap flag is set.
 +         */
 +        if (unlikely(flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
 +            err_status = VIRTIO_BLK_S_UNSUPP;
 +            goto err;
 +        }
 +
 +        blk_aio_pdiscard(s->blk, sector << BDRV_SECTOR_BITS, bytes,
 +                         virtio_blk_discard_write_zeroes_complete, req);
 +    }
 +
 +    return VIRTIO_BLK_S_OK;
 +
 +err:
 +    if (is_write_zeroes) {
 +        block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_WRITE);
 +    }
 +    return err_status;
 +}
 +
  static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
  {
      uint32_t type;
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
          virtio_blk_free_request(req);
          break;
      }
 +    /*
 +     * VIRTIO_BLK_T_DISCARD and VIRTIO_BLK_T_WRITE_ZEROES are defined with
 +     * VIRTIO_BLK_T_OUT flag set. We masked this flag in the switch statement,
 +     * so we must mask it for these requests, then we will check if it is set.
 +     */
 +    case VIRTIO_BLK_T_DISCARD & ~VIRTIO_BLK_T_OUT:
 +    case VIRTIO_BLK_T_WRITE_ZEROES & ~VIRTIO_BLK_T_OUT:
 +    {
 +        struct virtio_blk_discard_write_zeroes dwz_hdr;
 +        size_t out_len = iov_size(out_iov, out_num);
 +        bool is_write_zeroes = (type & ~VIRTIO_BLK_T_BARRIER) ==
 +                               VIRTIO_BLK_T_WRITE_ZEROES;
 +        uint8_t err_status;
 +
 +        /*
 +         * Unsupported if VIRTIO_BLK_T_OUT is not set or the request contains
 +         * more than one segment.
 +         */
 +        if (unlikely(!(type & VIRTIO_BLK_T_OUT) ||
 +                     out_len > sizeof(dwz_hdr))) {
 +            virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
 +            virtio_blk_free_request(req);
 +            return 0;
 +        }
 +
 +        if (unlikely(iov_to_buf(out_iov, out_num, 0, &dwz_hdr,
 +                                sizeof(dwz_hdr)) != sizeof(dwz_hdr))) {
 +            virtio_error(vdev, "virtio-blk discard/write_zeroes header"
 +                         " too short");
 +            return -1;
 +        }
 +
 +        err_status = virtio_blk_handle_discard_write_zeroes(req, &dwz_hdr,
 +                                                            is_write_zeroes);
 +        if (err_status != VIRTIO_BLK_S_OK) {
 +            virtio_blk_req_complete(req, err_status);
 +            virtio_blk_free_request(req);
 +        }
 +
 +        break;
 +    }
      default:
          virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
          virtio_blk_free_request(req);
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
      blkcfg.alignment_offset = 0;
      blkcfg.wce = blk_enable_write_cache(s->blk);
      virtio_stw_p(vdev, &blkcfg.num_queues, s->conf.num_queues);
 +    if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD)) {
 +        virtio_stl_p(vdev, &blkcfg.max_discard_sectors,
 +                     s->conf.max_discard_sectors);
 +        virtio_stl_p(vdev, &blkcfg.discard_sector_alignment,
 +                     blk_size >> BDRV_SECTOR_BITS);
 +        /*
 +         * We support only one segment per request since multiple segments
 +         * are not widely used and there are no userspace APIs that allow
 +         * applications to submit multiple segments in a single call.
 +         */
 +        virtio_stl_p(vdev, &blkcfg.max_discard_seg, 1);
 +    }
 +    if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES)) {
 +        virtio_stl_p(vdev, &blkcfg.max_write_zeroes_sectors,
 +                     s->conf.max_write_zeroes_sectors);
 +        blkcfg.write_zeroes_may_unmap = 1;
 +        virtio_stl_p(vdev, &blkcfg.max_write_zeroes_seg, 1);
 +    }
      memcpy(config, &blkcfg, s->config_size);
  }
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
          return;
      }
 +    if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD) &&
 +        (!conf->max_discard_sectors ||
 +         conf->max_discard_sectors > BDRV_REQUEST_MAX_SECTORS)) {
 +        error_setg(errp, "invalid max-discard-sectors property (%" PRIu32 ")"
 +                   ", must be between 1 and %d",
 +                   conf->max_discard_sectors, (int)BDRV_REQUEST_MAX_SECTORS);
 +        return;
 +    }
 +
 +    if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES) &&
 +        (!conf->max_write_zeroes_sectors ||
 +         conf->max_write_zeroes_sectors > BDRV_REQUEST_MAX_SECTORS)) {
 +        error_setg(errp, "invalid max-write-zeroes-sectors property (%" PRIu32
 +                   "), must be between 1 and %d",
 +                   conf->max_write_zeroes_sectors,
 +                   (int)BDRV_REQUEST_MAX_SECTORS);
 +        return;
 +    }
 +
      virtio_blk_set_config_size(s, s->host_features);
      virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, s->config_size);
@@ -XXX,XX +XXX,XX @@ static Property virtio_blk_properties[] = {
                        VIRTIO_BLK_F_DISCARD, true),
      DEFINE_PROP_BIT64("write-zeroes", VirtIOBlock, host_features,
                        VIRTIO_BLK_F_WRITE_ZEROES, true),
 +    DEFINE_PROP_UINT32("max-discard-sectors", VirtIOBlock,
 +                       conf.max_discard_sectors, BDRV_REQUEST_MAX_SECTORS),
 +    DEFINE_PROP_UINT32("max-write-zeroes-sectors", VirtIOBlock,
 +                       conf.max_write_zeroes_sectors, BDRV_REQUEST_MAX_SECTORS),
      DEFINE_PROP_END_OF_LIST(),
  };
 --
 .20.1

-New patch
+[Qemu-devel] [PULL 24/27] tests/virtio-blk: change assert on data_size in virtio_blk_request()
+From: Stefano Garzarella <sgarzare@redhat.com>
+The size of data in the virtio_blk_request must be a multiple
+of 512 bytes for IN and OUT requests, or a multiple of the size
+of struct virtio_blk_discard_write_zeroes for DISCARD and
+WRITE_ZEROES requests.
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Thomas Huth <thuth@redhat.com>
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-id: 20190221103314.58500-8-sgarzare@redhat.com
+Message-Id: <20190221103314.58500-8-sgarzare@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ tests/virtio-blk-test.c | 15 ++++++++++++++-
+file changed, 14 insertions(+), 1 deletion(-)
+diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/virtio-blk-test.c
++++ b/tests/virtio-blk-test.c
+@@ -XXX,XX +XXX,XX @@ static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d,
+     uint64_t addr;
+     uint8_t status = 0xFF;
+-    g_assert_cmpuint(data_size % 512, ==, 0);
++    switch (req->type) {
++    case VIRTIO_BLK_T_IN:
++    case VIRTIO_BLK_T_OUT:
++        g_assert_cmpuint(data_size % 512, ==, 0);
++        break;
++    case VIRTIO_BLK_T_DISCARD:
++    case VIRTIO_BLK_T_WRITE_ZEROES:
++        g_assert_cmpuint(data_size %
++                         sizeof(struct virtio_blk_discard_write_zeroes), ==, 0);
++        break;
++    default:
++        g_assert_cmpuint(data_size, ==, 0);
++    }
++
+     addr = guest_alloc(alloc, sizeof(*req) + data_size);
+     virtio_blk_fix_request(d, req);
+--
+.20.1

-[Qemu-devel] [PULL 10/11] jobs: remove ret argument to job_completed; privatize it
+[Qemu-devel] [PULL 25/27] tests/virtio-blk: add virtio_blk_fix_dwz_hdr() function
-From: John Snow <jsnow@redhat.com>
+From: Stefano Garzarella <sgarzare@redhat.com>
-Jobs are now expected to return their retcode on the stack, from the
+This function is useful to fix the endianness of struct
-.run callback, so we can remove that argument.
+virtio_blk_discard_write_zeroes headers.
-job_cancel does not need to set -ECANCELED because job_completed will
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-update the return code itself if the job was canceled.
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
 Message-id: 20190221103314.58500-9-sgarzare@redhat.com
 Message-Id: <20190221103314.58500-9-sgarzare@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  tests/virtio-blk-test.c | 23 +++++++++++++++++------
 file changed, 17 insertions(+), 6 deletions(-)
-While we're here, make job_completed static to job.c and remove it from
+diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
 job.h; move the documentation of return code to the .run() callback and
 to the job->ret property, accordingly.
 Signed-off-by: John Snow <jsnow@redhat.com>
 Message-id: 20180830015734.19765-9-jsnow@redhat.com
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  include/qemu/job.h | 28 +++++++++++++++-------------
  job.c              | 11 ++++++-----
  trace-events       |  2 +-
 files changed, 22 insertions(+), 19 deletions(-)
 diff --git a/include/qemu/job.h b/include/qemu/job.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/job.h
+--- a/tests/virtio-blk-test.c
-+++ b/include/qemu/job.h
++++ b/tests/virtio-blk-test.c
-@@ -XXX,XX +XXX,XX @@ typedef struct Job {
+@@ -XXX,XX +XXX,XX @@ typedef struct QVirtioBlkReq {
-     /** Estimated progress_current value at the completion of the job */
+     uint8_t status;
-     int64_t progress_total;
+ } QVirtioBlkReq;
--    /** ret code passed to job_completed. */
++#ifdef HOST_WORDS_BIGENDIAN
-+    /**
++const bool host_is_big_endian = true;
-+     * Return code from @run and/or @prepare callback(s).
++#else
-+     * Not final until the job has reached the CONCLUDED status.
++const bool host_is_big_endian; /* false */
-+     * 0 on success, -errno on failure.
++#endif
-+     */
++
-     int ret;
+ static char *drive_create(void)
+ {
-     /**
+     int fd, ret;
-@@ -XXX,XX +XXX,XX @@ struct JobDriver {
+@@ -XXX,XX +XXX,XX @@ static QVirtioPCIDevice *virtio_blk_pci_init(QPCIBus *bus, int slot)
-     /** Enum describing the operation */
-     JobType job_type;
+ static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req)
+ {
--    /** Mandatory: Entrypoint for the Coroutine. */
+-#ifdef HOST_WORDS_BIGENDIAN
-+    /**
+-    const bool host_is_big_endian = true;
-+     * Mandatory: Entrypoint for the Coroutine.
+-#else
-+     *
+-    const bool host_is_big_endian = false;
-+     * This callback will be invoked when moving from CREATED to RUNNING.
+-#endif
 +     *
 +     * If this callback returns nonzero, the job transaction it is part of is
 +     * aborted. If it returns zero, the job moves into the WAITING state. If it
 +     * is the last job to complete in its transaction, all jobs in the
 +     * transaction move from WAITING to PENDING.
 +     */
      int coroutine_fn (*run)(Job *job, Error **errp);
      /**
@@ -XXX,XX +XXX,XX @@ void job_early_fail(Job *job);
  /** Moves the @job from RUNNING to READY */
  void job_transition_to_ready(Job *job);
 -/**
 - * @job: The job being completed.
 - * @ret: The status code.
 - *
 - * Marks @job as completed. If @ret is non-zero, the job transaction it is part
 - * of is aborted. If @ret is zero, the job moves into the WAITING state. If it
 - * is the last job to complete in its transaction, all jobs in the transaction
 - * move from WAITING to PENDING.
 - */
 -void job_completed(Job *job, int ret);
 -
- /** Asynchronously complete the specified @job. */
+     if (qvirtio_is_big_endian(d) != host_is_big_endian) {
- void job_complete(Job *job, Error **errp);
+         req->type = bswap32(req->type);
+         req->ioprio = bswap32(req->ioprio);
-diff --git a/job.c b/job.c
+@@ -XXX,XX +XXX,XX @@ static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req)
 index XXXXXXX..XXXXXXX 100644
 --- a/job.c
 +++ b/job.c
@@ -XXX,XX +XXX,XX @@ void job_drain(Job *job)
      }
  }
-+static void job_completed(Job *job);
 +
- static void job_exit(void *opaque)
++static inline void virtio_blk_fix_dwz_hdr(QVirtioDevice *d,
 +    struct virtio_blk_discard_write_zeroes *dwz_hdr)
 +{
 +    if (qvirtio_is_big_endian(d) != host_is_big_endian) {
 +        dwz_hdr->sector = bswap64(dwz_hdr->sector);
 +        dwz_hdr->num_sectors = bswap32(dwz_hdr->num_sectors);
 +        dwz_hdr->flags = bswap32(dwz_hdr->flags);
 +    }
 +}
 +
  static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d,
                                     QVirtioBlkReq *req, uint64_t data_size)
  {
-     Job *job = (Job *)opaque;
-@@ -XXX,XX +XXX,XX @@ static void job_exit(void *opaque)
-         job->driver->exit(job);
-         aio_context_release(aio_context);
-     }
--    job_completed(job, job->ret);
-+    job_completed(job);
- }
- /**
-@@ -XXX,XX +XXX,XX @@ static void job_completed_txn_success(Job *job)
-     }
- }
--void job_completed(Job *job, int ret)
-+static void job_completed(Job *job)
- {
-     assert(job && job->txn && !job_is_completed(job));
--    job->ret = ret;
-     job_update_rc(job);
--    trace_job_completed(job, ret, job->ret);
-+    trace_job_completed(job, job->ret);
-     if (job->ret) {
-         job_completed_txn_abort(job);
-     } else {
-@@ -XXX,XX +XXX,XX @@ void job_cancel(Job *job, bool force)
-     }
-     job_cancel_async(job, force);
-     if (!job_started(job)) {
--        job_completed(job, -ECANCELED);
-+        job_completed(job);
-     } else if (job->deferred_to_main_loop) {
-         job_completed_txn_abort(job);
-     } else {
-diff --git a/trace-events b/trace-events
-index XXXXXXX..XXXXXXX 100644
---- a/trace-events
-+++ b/trace-events
-@@ -XXX,XX +XXX,XX @@ gdbstub_err_checksum_incorrect(uint8_t expected, uint8_t got) "got command packe
- # job.c
- job_state_transition(void *job,  int ret, const char *legal, const char *s0, const char *s1) "job %p (ret: %d) attempting %s transition (%s-->%s)"
- job_apply_verb(void *job, const char *state, const char *verb, const char *legal) "job %p in state %s; applying verb %s (%s)"
--job_completed(void *job, int ret, int jret) "job %p ret %d corrected ret %d"
-+job_completed(void *job, int ret) "job %p ret %d"
- # job-qmp.c
- qmp_job_cancel(void *job) "job %p"
 --
-.17.1
+.20.1

-New patch
+[Qemu-devel] [PULL 26/27] tests/virtio-blk: add test for WRITE_ZEROES command
+From: Stefano Garzarella <sgarzare@redhat.com>
+If the WRITE_ZEROES feature is enabled, we check this command
+in the test_basic().
+Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Acked-by: Thomas Huth <thuth@redhat.com>
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-id: 20190221103314.58500-10-sgarzare@redhat.com
+Message-Id: <20190221103314.58500-10-sgarzare@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ tests/virtio-blk-test.c | 62 +++++++++++++++++++++++++++++++++++++++++
+file changed, 62 insertions(+)
+diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/virtio-blk-test.c
++++ b/tests/virtio-blk-test.c
+@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
+     guest_free(alloc, req_addr);
++    if (features & (1u << VIRTIO_BLK_F_WRITE_ZEROES)) {
++        struct virtio_blk_discard_write_zeroes dwz_hdr;
++        void *expected;
++
++        /*
++         * WRITE_ZEROES request on the same sector of previous test where
++         * we wrote "TEST".
++         */
++        req.type = VIRTIO_BLK_T_WRITE_ZEROES;
++        req.data = (char *) &dwz_hdr;
++        dwz_hdr.sector = 0;
++        dwz_hdr.num_sectors = 1;
++        dwz_hdr.flags = 0;
++
++        virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
++
++        req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
++
++        free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
++        qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true);
++        qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false);
++
++        qvirtqueue_kick(dev, vq, free_head);
++
++        qvirtio_wait_used_elem(dev, vq, free_head, NULL,
++                               QVIRTIO_BLK_TIMEOUT_US);
++        status = readb(req_addr + 16 + sizeof(dwz_hdr));
++        g_assert_cmpint(status, ==, 0);
++
++        guest_free(alloc, req_addr);
++
++        /* Read request to check if the sector contains all zeroes */
++        req.type = VIRTIO_BLK_T_IN;
++        req.ioprio = 1;
++        req.sector = 0;
++        req.data = g_malloc0(512);
++
++        req_addr = virtio_blk_request(alloc, dev, &req, 512);
++
++        g_free(req.data);
++
++        free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
++        qvirtqueue_add(vq, req_addr + 16, 512, true, true);
++        qvirtqueue_add(vq, req_addr + 528, 1, true, false);
++
++        qvirtqueue_kick(dev, vq, free_head);
++
++        qvirtio_wait_used_elem(dev, vq, free_head, NULL,
++                               QVIRTIO_BLK_TIMEOUT_US);
++        status = readb(req_addr + 528);
++        g_assert_cmpint(status, ==, 0);
++
++        data = g_malloc(512);
++        expected = g_malloc0(512);
++        memread(req_addr + 16, data, 512);
++        g_assert_cmpmem(data, 512, expected, 512);
++        g_free(expected);
++        g_free(data);
++
++        guest_free(alloc, req_addr);
++    }
++
+     if (features & (1u << VIRTIO_F_ANY_LAYOUT)) {
+         /* Write and read with 2 descriptor layout */
+         /* Write request */
+--
+.20.1

-New patch
+[Qemu-devel] [PULL 27/27] tests/virtio-blk: add test for DISCARD command
+From: Stefano Garzarella <sgarzare@redhat.com>
+If the DISCARD feature is enabled, we try this command in the
+test_basic(), checking only the status returned by the request.
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-id: 20190221103314.58500-11-sgarzare@redhat.com
+Message-Id: <20190221103314.58500-11-sgarzare@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ tests/virtio-blk-test.c | 27 +++++++++++++++++++++++++++
+file changed, 27 insertions(+)
+diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/virtio-blk-test.c
++++ b/tests/virtio-blk-test.c
+@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
+         guest_free(alloc, req_addr);
+     }
++    if (features & (1u << VIRTIO_BLK_F_DISCARD)) {
++        struct virtio_blk_discard_write_zeroes dwz_hdr;
++
++        req.type = VIRTIO_BLK_T_DISCARD;
++        req.data = (char *) &dwz_hdr;
++        dwz_hdr.sector = 0;
++        dwz_hdr.num_sectors = 1;
++        dwz_hdr.flags = 0;
++
++        virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
++
++        req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
++
++        free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
++        qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true);
++        qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false);
++
++        qvirtqueue_kick(dev, vq, free_head);
++
++        qvirtio_wait_used_elem(dev, vq, free_head, NULL,
++                               QVIRTIO_BLK_TIMEOUT_US);
++        status = readb(req_addr + 16 + sizeof(dwz_hdr));
++        g_assert_cmpint(status, ==, 0);
++
++        guest_free(alloc, req_addr);
++    }
++
+     if (features & (1u << VIRTIO_F_ANY_LAYOUT)) {
+         /* Write and read with 2 descriptor layout */
+         /* Write request */
+--
+.20.1

The following changes since commit 19b599f7664b2ebfd0f405fb79c14dd241557452:

Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2018-08-27-v2' into staging (2018-08-27 16:44:20 +0100)

are available in the Git repository at:

https://git.xanclic.moe/XanClic/qemu.git tags/pull-block-2018-08-31

for you to fetch changes up to 40954cc7831c4f95f9ce6402ae3d6761f44f31ff:

jobs: remove job_defer_to_main_loop (2018-08-31 16:11:27 +0200)

----------------------------------------------------------------
Block patches:
- (Block) job exit refactoring, part 1
  (removing job_defer_to_main_loop())
- Locking fix for the file-posix block driver
- test-bdrv-drain leak fix

----------------------------------------------------------------
Fam Zheng (1):
  file-posix: Skip effectiveless OFD lock operations

John Snow (9):
  jobs: change start callback to run callback
  jobs: canonize Error object
  jobs: add exit shim
  block/commit: utilize job_exit shim
  block/mirror: utilize job_exit shim
  jobs: utilize job_exit shim
  block/backup: make function variables consistently named
  jobs: remove ret argument to job_completed; privatize it
  jobs: remove job_defer_to_main_loop

Marc-André Lureau (1):
  tests: fix bdrv-drain leak

-- 
2.17.1

From: Fam Zheng <famz@redhat.com>

If we know we've already locked the bytes, don't do it again; similarly
don't unlock a byte if we haven't locked it. This doesn't change the
behavior, but fixes a corner case explained below.

Libvirt had an error handling bug that an image can get its (ownership,
file mode, SELinux) permissions changed (RHBZ 1584982) by mistake behind
QEMU. Specifically, an image in use by Libvirt VM has:

$ ls -lhZ b.img
    -rw-r--r--. qemu qemu system_u:object_r:svirt_image_t:s0:c600,c690 b.img

Trying to attach it a second time won't work because of image locking.
And after the error, it becomes:

$ ls -lhZ b.img
    -rw-r--r--. root root system_u:object_r:virt_image_t:s0 b.img

Then, we won't be able to do OFD lock operations with the existing fd.
In other words, the code such as in blk_detach_dev:

blk_set_perm(blk, 0, BLK_PERM_ALL, &error_abort);

can abort() QEMU, out of environmental changes.

This patch is an easy fix to this and the change is regardlessly
reasonable, so do it.

Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/file-posix.c | 41 +++++++++++++++++++++++++++++++----------
 1 file changed, 31 insertions(+), 10 deletions(-)

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 @@ typedef enum {
  * file; if @unlock == true, also unlock the unneeded bytes.
  * @shared_perm_lock_bits is the mask of all permissions that are NOT shared.
  */
-static int raw_apply_lock_bytes(int fd,
+static int raw_apply_lock_bytes(BDRVRawState *s, int fd,
                                 uint64_t perm_lock_bits,
                                 uint64_t shared_perm_lock_bits,
                                 bool unlock, Error **errp)
 {
     int ret;
     int i;
+    uint64_t locked_perm, locked_shared_perm;
+
+    if (s) {
+        locked_perm = s->perm;
+        locked_shared_perm = ~s->shared_perm & BLK_PERM_ALL;
+    } else {
+        /*
+         * We don't have the previous bits, just lock/unlock for each of the
+         * requested bits.
+         */
+        if (unlock) {
+            locked_perm = BLK_PERM_ALL;
+            locked_shared_perm = BLK_PERM_ALL;
+        } else {
+            locked_perm = 0;
+            locked_shared_perm = 0;
+        }
+    }
 
     PERM_FOREACH(i) {
         int off = RAW_LOCK_PERM_BASE + i;
-        if (perm_lock_bits & (1ULL << i)) {
+        uint64_t bit = (1ULL << i);
+        if ((perm_lock_bits & bit) && !(locked_perm & bit)) {
             ret = qemu_lock_fd(fd, off, 1, false);
             if (ret) {
                 error_setg(errp, "Failed to lock byte %d", off);
                 return ret;
             }
-        } else if (unlock) {
+        } else if (unlock && (locked_perm & bit) && !(perm_lock_bits & bit)) {
             ret = qemu_unlock_fd(fd, off, 1);
             if (ret) {
                 error_setg(errp, "Failed to unlock byte %d", off);
@@ -XXX,XX +XXX,XX @@ static int raw_apply_lock_bytes(int fd,
     }
     PERM_FOREACH(i) {
         int off = RAW_LOCK_SHARED_BASE + i;
-        if (shared_perm_lock_bits & (1ULL << i)) {
+        uint64_t bit = (1ULL << i);
+        if ((shared_perm_lock_bits & bit) && !(locked_shared_perm & bit)) {
             ret = qemu_lock_fd(fd, off, 1, false);
             if (ret) {
                 error_setg(errp, "Failed to lock byte %d", off);
                 return ret;
             }
-        } else if (unlock) {
+        } else if (unlock && (locked_shared_perm & bit) &&
+                   !(shared_perm_lock_bits & bit)) {
             ret = qemu_unlock_fd(fd, off, 1);
             if (ret) {
                 error_setg(errp, "Failed to unlock byte %d", off);
@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,
 
     switch (op) {
     case RAW_PL_PREPARE:
-        ret = raw_apply_lock_bytes(s->lock_fd, s->perm | new_perm,
+        ret = raw_apply_lock_bytes(s, s->lock_fd, s->perm | new_perm,
                                    ~s->shared_perm | ~new_shared,
                                    false, errp);
         if (!ret) {
@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,
         op = RAW_PL_ABORT;
         /* fall through to unlock bytes. */
     case RAW_PL_ABORT:
-        raw_apply_lock_bytes(s->lock_fd, s->perm, ~s->shared_perm,
+        raw_apply_lock_bytes(s, s->lock_fd, s->perm, ~s->shared_perm,
                              true, &local_err);
         if (local_err) {
             /* Theoretically the above call only unlocks bytes and it cannot
@@ -XXX,XX +XXX,XX @@ static int raw_handle_perm_lock(BlockDriverState *bs,
         }
         break;
     case RAW_PL_COMMIT:
-        raw_apply_lock_bytes(s->lock_fd, new_perm, ~new_shared,
+        raw_apply_lock_bytes(s, s->lock_fd, new_perm, ~new_shared,
                              true, &local_err);
         if (local_err) {
             /* Theoretically the above call only unlocks bytes and it cannot
@@ -XXX,XX +XXX,XX @@ raw_co_create(BlockdevCreateOptions *options, Error **errp)
     shared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
 
     /* Step one: Take locks */
-    result = raw_apply_lock_bytes(fd, perm, ~shared, false, errp);
+    result = raw_apply_lock_bytes(NULL, fd, perm, ~shared, false, errp);
     if (result < 0) {
         goto out_close;
     }
@@ -XXX,XX +XXX,XX @@ raw_co_create(BlockdevCreateOptions *options, Error **errp)
     }
 
 out_unlock:
-    raw_apply_lock_bytes(fd, 0, 0, true, &local_err);
+    raw_apply_lock_bytes(NULL, fd, 0, 0, true, &local_err);
     if (local_err) {
         /* The above call should not fail, and if it does, that does
          * not mean the whole creation operation has failed.  So
-- 
2.17.1

From: Marc-André Lureau <marcandre.lureau@redhat.com>

Spotted by ASAN:

=================================================================
==5378==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 65536 byte(s) in 1 object(s) allocated from:
    #0 0x7f788f83bc48 in malloc (/lib64/libasan.so.5+0xeec48)
    #1 0x7f788c9923c5 in g_malloc (/lib64/libglib-2.0.so.0+0x523c5)
    #2 0x5622a1fe37bc in coroutine_trampoline /home/elmarco/src/qq/util/coroutine-ucontext.c:116
    #3 0x7f788a15d75f in __correctly_grouped_prefixwc (/lib64/libc.so.6+0x4c75f)

(Broken in commit 4c8158e359d.)

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-id: 20180809114417.28718-3-marcandre.lureau@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/test-bdrv-drain.c | 1 +
 1 file changed, 1 insertion(+)

From: John Snow <jsnow@redhat.com>

Presently we codify the entry point for a job as the "start" callback,
but a more apt name would be "run" to clarify the idea that when this
function returns we consider the job to have "finished," except for
any cleanup which occurs in separate callbacks later.

As part of this clarification, change the signature to include an error
object and a return code. The error ptr is not yet used, and the return
code while captured, will be overwritten by actions in the job_completed
function.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20180830015734.19765-2-jsnow@redhat.com
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 include/qemu/job.h        |  2 +-
 block/backup.c            |  7 ++++---
 block/commit.c            |  7 ++++---
 block/create.c            |  8 +++++---
 block/mirror.c            | 10 ++++++----
 block/stream.c            |  7 ++++---
 job.c                     |  6 +++---
 tests/test-bdrv-drain.c   |  7 ++++---
 tests/test-blockjob-txn.c | 16 ++++++++--------
 tests/test-blockjob.c     |  7 ++++---
 10 files changed, 43 insertions(+), 34 deletions(-)

diff --git a/include/qemu/job.h b/include/qemu/job.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -XXX,XX +XXX,XX @@ struct JobDriver {
     JobType job_type;
 
     /** Mandatory: Entrypoint for the Coroutine. */
-    CoroutineEntry *start;
+    int coroutine_fn (*run)(Job *job, Error **errp);
 
     /**
      * If the callback is not NULL, it will be invoked when the job transitions
diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)
     bdrv_dirty_iter_free(dbi);
 }
 
-static void coroutine_fn backup_run(void *opaque)
+static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
 {
-    BackupBlockJob *job = opaque;
+    BackupBlockJob *job = container_of(opaque_job, BackupBlockJob, common.job);
     BackupCompleteData *data;
     BlockDriverState *bs = blk_bs(job->common.blk);
     int64_t offset, nb_clusters;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn backup_run(void *opaque)
     data = g_malloc(sizeof(*data));
     data->ret = ret;
     job_defer_to_main_loop(&job->common.job, backup_complete, data);
+    return ret;
 }
 
 static const BlockJobDriver backup_job_driver = {
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver backup_job_driver = {
         .free                   = block_job_free,
         .user_resume            = block_job_user_resume,
         .drain                  = block_job_drain,
-        .start                  = backup_run,
+        .run                    = backup_run,
         .commit                 = backup_commit,
         .abort                  = backup_abort,
         .clean                  = backup_clean,
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 void commit_complete(Job *job, void *opaque)
     bdrv_unref(top);
 }
 
-static void coroutine_fn commit_run(void *opaque)
+static int coroutine_fn commit_run(Job *job, Error **errp)
 {
-    CommitBlockJob *s = opaque;
+    CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
     CommitCompleteData *data;
     int64_t offset;
     uint64_t delay_ns = 0;
@@ -XXX,XX +XXX,XX @@ out:
     data = g_malloc(sizeof(*data));
     data->ret = ret;
     job_defer_to_main_loop(&s->common.job, commit_complete, data);
+    return ret;
 }
 
 static const BlockJobDriver commit_job_driver = {
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_job_driver = {
         .free          = block_job_free,
         .user_resume   = block_job_user_resume,
         .drain         = block_job_drain,
-        .start         = commit_run,
+        .run           = commit_run,
     },
 };
 
diff --git a/block/create.c b/block/create.c
index XXXXXXX..XXXXXXX 100644
--- a/block/create.c
+++ b/block/create.c
@@ -XXX,XX +XXX,XX @@ static void blockdev_create_complete(Job *job, void *opaque)
     job_completed(job, s->ret, s->err);
 }
 
-static void coroutine_fn blockdev_create_run(void *opaque)
+static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
 {
-    BlockdevCreateJob *s = opaque;
+    BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
 
     job_progress_set_remaining(&s->common, 1);
     s->ret = s->drv->bdrv_co_create(s->opts, &s->err);
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn blockdev_create_run(void *opaque)
 
     qapi_free_BlockdevCreateOptions(s->opts);
     job_defer_to_main_loop(&s->common, blockdev_create_complete, NULL);
+
+    return s->ret;
 }
 
 static const JobDriver blockdev_create_job_driver = {
     .instance_size = sizeof(BlockdevCreateJob),
     .job_type      = JOB_TYPE_CREATE,
-    .start         = blockdev_create_run,
+    .run           = blockdev_create_run,
 };
 
 void qmp_blockdev_create(const char *job_id, BlockdevCreateOptions *options,
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 mirror_flush(MirrorBlockJob *s)
     return ret;
 }
 
-static void coroutine_fn mirror_run(void *opaque)
+static int coroutine_fn mirror_run(Job *job, Error **errp)
 {
-    MirrorBlockJob *s = opaque;
+    MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
     MirrorExitData *data;
     BlockDriverState *bs = s->mirror_top_bs->backing->bs;
     BlockDriverState *target_bs = blk_bs(s->target);
@@ -XXX,XX +XXX,XX @@ immediate_exit:
     if (need_drain) {
         bdrv_drained_begin(bs);
     }
+
     job_defer_to_main_loop(&s->common.job, mirror_exit, data);
+    return ret;
 }
 
 static void mirror_complete(Job *job, Error **errp)
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver mirror_job_driver = {
         .free                   = block_job_free,
         .user_resume            = block_job_user_resume,
         .drain                  = block_job_drain,
-        .start                  = mirror_run,
+        .run                    = mirror_run,
         .pause                  = mirror_pause,
         .complete               = mirror_complete,
     },
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_active_job_driver = {
         .free                   = block_job_free,
         .user_resume            = block_job_user_resume,
         .drain                  = block_job_drain,
-        .start                  = mirror_run,
+        .run                    = mirror_run,
         .pause                  = mirror_pause,
         .complete               = mirror_complete,
     },
diff --git a/block/stream.c b/block/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/block/stream.c
+++ b/block/stream.c
@@ -XXX,XX +XXX,XX @@ out:
     g_free(data);
 }
 
-static void coroutine_fn stream_run(void *opaque)
+static int coroutine_fn stream_run(Job *job, Error **errp)
 {
-    StreamBlockJob *s = opaque;
+    StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
     StreamCompleteData *data;
     BlockBackend *blk = s->common.blk;
     BlockDriverState *bs = blk_bs(blk);
@@ -XXX,XX +XXX,XX @@ out:
     data = g_malloc(sizeof(*data));
     data->ret = ret;
     job_defer_to_main_loop(&s->common.job, stream_complete, data);
+    return ret;
 }
 
 static const BlockJobDriver stream_job_driver = {
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver stream_job_driver = {
         .instance_size = sizeof(StreamBlockJob),
         .job_type      = JOB_TYPE_STREAM,
         .free          = block_job_free,
-        .start         = stream_run,
+        .run           = stream_run,
         .user_resume   = block_job_user_resume,
         .drain         = block_job_drain,
     },
diff --git a/job.c b/job.c
index XXXXXXX..XXXXXXX 100644
--- a/job.c
+++ b/job.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn job_co_entry(void *opaque)
 {
     Job *job = opaque;
 
-    assert(job && job->driver && job->driver->start);
+    assert(job && job->driver && job->driver->run);
     job_pause_point(job);
-    job->driver->start(job);
+    job->ret = job->driver->run(job, NULL);
 }
 
 
 void job_start(Job *job)
 {
     assert(job && !job_started(job) && job->paused &&
-           job->driver && job->driver->start);
+           job->driver && job->driver->run);
     job->co = qemu_coroutine_create(job_co_entry, job);
     job->pause_count--;
     job->busy = true;
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_job_completed(Job *job, void *opaque)
     job_completed(job, 0, NULL);
 }
 
-static void coroutine_fn test_job_start(void *opaque)
+static int coroutine_fn test_job_run(Job *job, Error **errp)
 {
-    TestBlockJob *s = opaque;
+    TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 
     job_transition_to_ready(&s->common.job);
     while (!s->should_complete) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_job_start(void *opaque)
     }
 
     job_defer_to_main_loop(&s->common.job, test_job_completed, NULL);
+    return 0;
 }
 
 static void test_job_complete(Job *job, Error **errp)
@@ -XXX,XX +XXX,XX @@ BlockJobDriver test_job_driver = {
         .free           = block_job_free,
         .user_resume    = block_job_user_resume,
         .drain          = block_job_drain,
-        .start          = test_job_start,
+        .run            = test_job_run,
         .complete       = test_job_complete,
     },
 };
diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob-txn.c
+++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static void test_block_job_complete(Job *job, void *opaque)
     bdrv_unref(bs);
 }
 
-static void coroutine_fn test_block_job_run(void *opaque)
+static int coroutine_fn test_block_job_run(Job *job, Error **errp)
 {
-    TestBlockJob *s = opaque;
-    BlockJob *job = &s->common;
+    TestBlockJob *s = container_of(job, TestBlockJob, common.job);
 
     while (s->iterations--) {
         if (s->use_timer) {
-            job_sleep_ns(&job->job, 0);
+            job_sleep_ns(job, 0);
         } else {
-            job_yield(&job->job);
+            job_yield(job);
         }
 
-        if (job_is_cancelled(&job->job)) {
+        if (job_is_cancelled(job)) {
             break;
         }
     }
 
-    job_defer_to_main_loop(&job->job, test_block_job_complete,
+    job_defer_to_main_loop(job, test_block_job_complete,
                            (void *)(intptr_t)s->rc);
+    return s->rc;
 }
 
 typedef struct {
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_block_job_driver = {
         .free          = block_job_free,
         .user_resume   = block_job_user_resume,
         .drain         = block_job_drain,
-        .start         = test_block_job_run,
+        .run           = test_block_job_run,
     },
 };
 
diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob.c
+++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static void cancel_job_complete(Job *job, Error **errp)
     s->should_complete = true;
 }
 
-static void coroutine_fn cancel_job_start(void *opaque)
+static int coroutine_fn cancel_job_run(Job *job, Error **errp)
 {
-    CancelJob *s = opaque;
+    CancelJob *s = container_of(job, CancelJob, common.job);
 
     while (!s->should_complete) {
         if (job_is_cancelled(&s->common.job)) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn cancel_job_start(void *opaque)
 
  defer:
     job_defer_to_main_loop(&s->common.job, cancel_job_completed, s);
+    return 0;
 }
 
 static const BlockJobDriver test_cancel_driver = {
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_cancel_driver = {
         .free          = block_job_free,
         .user_resume   = block_job_user_resume,
         .drain         = block_job_drain,
-        .start         = cancel_job_start,
+        .run           = cancel_job_run,
         .complete      = cancel_job_complete,
     },
 };
-- 
2.17.1

From: John Snow <jsnow@redhat.com>

Jobs presently use both an Error object in the case of the create job,
and char strings in the case of generic errors elsewhere.

Unify the two paths as just j->err, and remove the extra argument from
job_completed. The integer error code for job_completed is kept for now,
to be removed shortly in a separate patch.

Signed-off-by: John Snow <jsnow@redhat.com>
Message-id: 20180830015734.19765-3-jsnow@redhat.com
[mreitz: Dropped a superfluous g_strdup()]
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 include/qemu/job.h        | 14 ++++++++------
 block/backup.c            |  2 +-
 block/commit.c            |  2 +-
 block/create.c            |  5 ++---
 block/mirror.c            |  2 +-
 block/stream.c            |  2 +-
 job-qmp.c                 |  5 +++--
 job.c                     | 18 ++++++------------
 tests/test-bdrv-drain.c   |  2 +-
 tests/test-blockjob-txn.c |  2 +-
 tests/test-blockjob.c     |  2 +-
 11 files changed, 26 insertions(+), 30 deletions(-)

diff --git a/include/qemu/job.h b/include/qemu/job.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -XXX,XX +XXX,XX @@ typedef struct Job {
     /** Estimated progress_current value at the completion of the job */
     int64_t progress_total;
 
-    /** Error string for a failed job (NULL if, and only if, job->ret == 0) */
-    char *error;
-
     /** ret code passed to job_completed. */
     int ret;
 
+    /**
+     * Error object for a failed job.
+     * If job->ret is nonzero and an error object was not set, it will be set
+     * to strerror(-job->ret) during job_completed.
+     */
+    Error *err;
+
     /** The completion function that will be called when the job completes.  */
     BlockCompletionFunc *cb;
 
@@ -XXX,XX +XXX,XX @@ void job_transition_to_ready(Job *job);
 /**
  * @job: The job being completed.
  * @ret: The status code.
- * @error: The error message for a failing job (only with @ret < 0). If @ret is
- *         negative, but NULL is given for @error, strerror() is used.
  *
  * Marks @job as completed. If @ret is non-zero, the job transaction it is part
  * of is aborted. If @ret is zero, the job moves into the WAITING state. If it
  * is the last job to complete in its transaction, all jobs in the transaction
  * move from WAITING to PENDING.
  */
-void job_completed(Job *job, int ret, Error *error);
+void job_completed(Job *job, int ret);
 
 /** Asynchronously complete the specified @job. */
 void job_complete(Job *job, Error **errp);
diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void backup_complete(Job *job, void *opaque)
 {
     BackupCompleteData *data = opaque;
 
-    job_completed(job, data->ret, NULL);
+    job_completed(job, data->ret);
     g_free(data);
 }
 
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 void commit_complete(Job *job, void *opaque)
      * bdrv_set_backing_hd() to fail. */
     block_job_remove_all_bdrv(bjob);
 
-    job_completed(job, ret, NULL);
+    job_completed(job, ret);
     g_free(data);
 
     /* If bdrv_drop_intermediate() didn't already do that, remove the commit
diff --git a/block/create.c b/block/create.c
index XXXXXXX..XXXXXXX 100644
--- a/block/create.c
+++ b/block/create.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlockdevCreateJob {
     BlockDriver *drv;
     BlockdevCreateOptions *opts;
     int ret;
-    Error *err;
 } BlockdevCreateJob;
 
 static void blockdev_create_complete(Job *job, void *opaque)
 {
     BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
 
-    job_completed(job, s->ret, s->err);
+    job_completed(job, s->ret);
 }
 
 static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
     BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
 
     job_progress_set_remaining(&s->common, 1);
-    s->ret = s->drv->bdrv_co_create(s->opts, &s->err);
+    s->ret = s->drv->bdrv_co_create(s->opts, errp);
     job_progress_update(&s->common, 1);
 
     qapi_free_BlockdevCreateOptions(s->opts);
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 void mirror_exit(Job *job, void *opaque)
     blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);
 
     bs_opaque->job = NULL;
-    job_completed(job, data->ret, NULL);
+    job_completed(job, data->ret);
 
     g_free(data);
     bdrv_drained_end(src);
diff --git a/block/stream.c b/block/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/block/stream.c
+++ b/block/stream.c
@@ -XXX,XX +XXX,XX @@ out:
     }
 
     g_free(s->backing_file_str);
-    job_completed(job, data->ret, NULL);
+    job_completed(job, data->ret);
     g_free(data);
 }
 
diff --git a/job-qmp.c b/job-qmp.c
index XXXXXXX..XXXXXXX 100644
--- a/job-qmp.c
+++ b/job-qmp.c
@@ -XXX,XX +XXX,XX @@ static JobInfo *job_query_single(Job *job, Error **errp)
         .status             = job->status,
         .current_progress   = job->progress_current,
         .total_progress     = job->progress_total,
-        .has_error          = !!job->error,
-        .error              = g_strdup(job->error),
+        .has_error          = !!job->err,
+        .error              = job->err ? \
+                              g_strdup(error_get_pretty(job->err)) : NULL,
     };
 
     return info;
diff --git a/job.c b/job.c
index XXXXXXX..XXXXXXX 100644
--- a/job.c
+++ b/job.c
@@ -XXX,XX +XXX,XX @@ void job_unref(Job *job)
 
         QLIST_REMOVE(job, job_list);
 
-        g_free(job->error);
+        error_free(job->err);
         g_free(job->id);
         g_free(job);
     }
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn job_co_entry(void *opaque)
 
     assert(job && job->driver && job->driver->run);
     job_pause_point(job);
-    job->ret = job->driver->run(job, NULL);
+    job->ret = job->driver->run(job, &job->err);
 }
 
 
@@ -XXX,XX +XXX,XX @@ static void job_update_rc(Job *job)
         job->ret = -ECANCELED;
     }
     if (job->ret) {
-        if (!job->error) {
-            job->error = g_strdup(strerror(-job->ret));
+        if (!job->err) {
+            error_setg(&job->err, "%s", strerror(-job->ret));
         }
         job_state_transition(job, JOB_STATUS_ABORTING);
     }
@@ -XXX,XX +XXX,XX @@ static void job_completed_txn_success(Job *job)
     }
 }
 
-void job_completed(Job *job, int ret, Error *error)
+void job_completed(Job *job, int ret)
 {
     assert(job && job->txn && !job_is_completed(job));
 
     job->ret = ret;
-    if (error) {
-        assert(job->ret < 0);
-        job->error = g_strdup(error_get_pretty(error));
-        error_free(error);
-    }
-
     job_update_rc(job);
     trace_job_completed(job, ret, job->ret);
     if (job->ret) {
@@ -XXX,XX +XXX,XX @@ void job_cancel(Job *job, bool force)
     }
     job_cancel_async(job, force);
     if (!job_started(job)) {
-        job_completed(job, -ECANCELED, NULL);
+        job_completed(job, -ECANCELED);
     } else if (job->deferred_to_main_loop) {
         job_completed_txn_abort(job);
     } else {
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ typedef struct TestBlockJob {
 
 static void test_job_completed(Job *job, void *opaque)
 {
-    job_completed(job, 0, NULL);
+    job_completed(job, 0);
 }
 
 static int coroutine_fn test_job_run(Job *job, Error **errp)
diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob-txn.c
+++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static void test_block_job_complete(Job *job, void *opaque)
         rc = -ECANCELED;
     }
 
-    job_completed(job, rc, NULL);
+    job_completed(job, rc);
     bdrv_unref(bs);
 }
 
diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob.c
+++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static void cancel_job_completed(Job *job, void *opaque)
 {
     CancelJob *s = opaque;
     s->completed = true;
-    job_completed(job, 0, NULL);
+    job_completed(job, 0);
 }
 
 static void cancel_job_complete(Job *job, Error **errp)
-- 
2.17.1

From: John Snow <jsnow@redhat.com>

All jobs do the same thing when they leave their running loop:
- Store the return code in a structure
- wait to receive this structure in the main thread
- signal job completion via job_completed

Few jobs do anything beyond exactly this. Consolidate this exit
logic for a net reduction in SLOC.

More seriously, when we utilize job_defer_to_main_loop_bh to call
a function that calls job_completed, job_finalize_single will run
in a context where it has recursively taken the aio_context lock,
which can cause hangs if it puts down a reference that causes a flush.

You can observe this in practice by looking at mirror_exit's careful
placement of job_completed and bdrv_unref calls.

If we centralize job exiting, we can signal job completion from outside
of the aio_context, which should allow for job cleanup code to run with
only one lock, which makes cleanup callbacks less tricky to write.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20180830015734.19765-4-jsnow@redhat.com
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 include/qemu/job.h | 11 +++++++++++
 job.c              | 18 ++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/include/qemu/job.h b/include/qemu/job.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -XXX,XX +XXX,XX @@ struct JobDriver {
      */
     void (*drain)(Job *job);
 
+    /**
+     * If the callback is not NULL, exit will be invoked from the main thread
+     * when the job's coroutine has finished, but before transactional
+     * convergence; before @prepare or @abort.
+     *
+     * FIXME TODO: This callback is only temporary to transition remaining jobs
+     * to prepare/commit/abort/clean callbacks and will be removed before 3.1.
+     * is released.
+     */
+    void (*exit)(Job *job);
+
     /**
      * If the callback is not NULL, prepare will be invoked when all the jobs
      * belonging to the same transaction complete; or upon this job's completion
diff --git a/job.c b/job.c
index XXXXXXX..XXXXXXX 100644
--- a/job.c
+++ b/job.c
@@ -XXX,XX +XXX,XX @@ void job_drain(Job *job)
     }
 }
 
+static void job_exit(void *opaque)
+{
+    Job *job = (Job *)opaque;
+    AioContext *aio_context = job->aio_context;
+
+    if (job->driver->exit) {
+        aio_context_acquire(aio_context);
+        job->driver->exit(job);
+        aio_context_release(aio_context);
+    }
+    job_completed(job, job->ret);
+}
 
 /**
  * All jobs must allow a pause point before entering their job proper. This
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn job_co_entry(void *opaque)
     assert(job && job->driver && job->driver->run);
     job_pause_point(job);
     job->ret = job->driver->run(job, &job->err);
+    if (!job->deferred_to_main_loop) {
+        job->deferred_to_main_loop = true;
+        aio_bh_schedule_oneshot(qemu_get_aio_context(),
+                                job_exit,
+                                job);
+    }
 }
 
 
-- 
2.17.1

From: John Snow <jsnow@redhat.com>

Change the manual deferment to commit_complete into the implicit
callback to job_exit, renaming commit_complete to commit_exit.

This conversion does change the timing of when job_completed is
called to after the bdrv_replace_node and bdrv_unref calls, which
could have implications for bjob->blk which will now be put down
after this cleanup.

Kevin highlights that we did not take any permissions for that backend
at job creation time, so it is safe to reorder these operations.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20180830015734.19765-5-jsnow@redhat.com
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/commit.c | 22 +++++-----------------
 1 file changed, 5 insertions(+), 17 deletions(-)

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_populate(BlockBackend *bs, BlockBackend *base,
     return 0;
 }
 
-typedef struct {
-    int ret;
-} CommitCompleteData;
-
-static void commit_complete(Job *job, void *opaque)
+static void commit_exit(Job *job)
 {
     CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
     BlockJob *bjob = &s->common;
-    CommitCompleteData *data = opaque;
     BlockDriverState *top = blk_bs(s->top);
     BlockDriverState *base = blk_bs(s->base);
     BlockDriverState *commit_top_bs = s->commit_top_bs;
-    int ret = data->ret;
     bool remove_commit_top_bs = false;
 
     /* Make sure commit_top_bs and top stay around until bdrv_replace_node() */
@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)
      * the normal backing chain can be restored. */
     blk_unref(s->base);
 
-    if (!job_is_cancelled(job) && ret == 0) {
+    if (!job_is_cancelled(job) && job->ret == 0) {
         /* success */
-        ret = bdrv_drop_intermediate(s->commit_top_bs, base,
-                                     s->backing_file_str);
+        job->ret = bdrv_drop_intermediate(s->commit_top_bs, base,
+                                          s->backing_file_str);
     } else {
         /* XXX Can (or should) we somehow keep 'consistent read' blocked even
          * after the failed/cancelled commit job is gone? If we already wrote
@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)
      * bdrv_set_backing_hd() to fail. */
     block_job_remove_all_bdrv(bjob);
 
-    job_completed(job, ret);
-    g_free(data);
-
     /* If bdrv_drop_intermediate() didn't already do that, remove the commit
      * filter driver from the backing chain. Do this as the final step so that
      * the 'consistent read' permission can be granted.  */
@@ -XXX,XX +XXX,XX @@ static void commit_complete(Job *job, void *opaque)
 static int coroutine_fn commit_run(Job *job, Error **errp)
 {
     CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
-    CommitCompleteData *data;
     int64_t offset;
     uint64_t delay_ns = 0;
     int ret = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
 out:
     qemu_vfree(buf);
 
-    data = g_malloc(sizeof(*data));
-    data->ret = ret;
-    job_defer_to_main_loop(&s->common.job, commit_complete, data);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_job_driver = {
         .user_resume   = block_job_user_resume,
         .drain         = block_job_drain,
         .run           = commit_run,
+        .exit          = commit_exit,
     },
 };
 
-- 
2.17.1

From: John Snow <jsnow@redhat.com>

Change the manual deferment to mirror_exit into the implicit
callback to job_exit and the mirror_exit callback.

This does change the order of some bdrv_unref calls and job_completed,
but thanks to the new context in which we call .exit, this is safe to
defer the possible flushing of any nodes to the job_finalize_single
cleanup stage.

Signed-off-by: John Snow <jsnow@redhat.com>
Message-id: 20180830015734.19765-6-jsnow@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/mirror.c | 29 +++++++++++------------------
 1 file changed, 11 insertions(+), 18 deletions(-)

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 void mirror_wait_for_all_io(MirrorBlockJob *s)
     }
 }
 
-typedef struct {
-    int ret;
-} MirrorExitData;
-
-static void mirror_exit(Job *job, void *opaque)
+static void mirror_exit(Job *job)
 {
     MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
     BlockJob *bjob = &s->common;
-    MirrorExitData *data = opaque;
     MirrorBDSOpaque *bs_opaque = s->mirror_top_bs->opaque;
     AioContext *replace_aio_context = NULL;
     BlockDriverState *src = s->mirror_top_bs->backing->bs;
     BlockDriverState *target_bs = blk_bs(s->target);
     BlockDriverState *mirror_top_bs = s->mirror_top_bs;
     Error *local_err = NULL;
+    int ret = job->ret;
 
     bdrv_release_dirty_bitmap(src, s->dirty_bitmap);
 
-    /* Make sure that the source BDS doesn't go away before we called
-     * job_completed(). */
+    /* Make sure that the source BDS doesn't go away during bdrv_replace_node,
+     * before we can call bdrv_drained_end */
     bdrv_ref(src);
     bdrv_ref(mirror_top_bs);
     bdrv_ref(target_bs);
@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)
             bdrv_set_backing_hd(target_bs, backing, &local_err);
             if (local_err) {
                 error_report_err(local_err);
-                data->ret = -EPERM;
+                ret = -EPERM;
             }
         }
     }
@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)
         aio_context_acquire(replace_aio_context);
     }
 
-    if (s->should_complete && data->ret == 0) {
+    if (s->should_complete && ret == 0) {
         BlockDriverState *to_replace = src;
         if (s->to_replace) {
             to_replace = s->to_replace;
@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)
         bdrv_drained_end(target_bs);
         if (local_err) {
             error_report_err(local_err);
-            data->ret = -EPERM;
+            ret = -EPERM;
         }
     }
     if (s->to_replace) {
@@ -XXX,XX +XXX,XX @@ static void mirror_exit(Job *job, void *opaque)
     blk_insert_bs(bjob->blk, mirror_top_bs, &error_abort);
 
     bs_opaque->job = NULL;
-    job_completed(job, data->ret);
 
-    g_free(data);
     bdrv_drained_end(src);
     bdrv_unref(mirror_top_bs);
     bdrv_unref(src);
+
+    job->ret = ret;
 }
 
 static void mirror_throttle(MirrorBlockJob *s)
@@ -XXX,XX +XXX,XX @@ static int mirror_flush(MirrorBlockJob *s)
 static int coroutine_fn mirror_run(Job *job, Error **errp)
 {
     MirrorBlockJob *s = container_of(job, MirrorBlockJob, common.job);
-    MirrorExitData *data;
     BlockDriverState *bs = s->mirror_top_bs->backing->bs;
     BlockDriverState *target_bs = blk_bs(s->target);
     bool need_drain = true;
@@ -XXX,XX +XXX,XX @@ immediate_exit:
     g_free(s->in_flight_bitmap);
     bdrv_dirty_iter_free(s->dbi);
 
-    data = g_malloc(sizeof(*data));
-    data->ret = ret;
-
     if (need_drain) {
         bdrv_drained_begin(bs);
     }
 
-    job_defer_to_main_loop(&s->common.job, mirror_exit, data);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver mirror_job_driver = {
         .user_resume            = block_job_user_resume,
         .drain                  = block_job_drain,
         .run                    = mirror_run,
+        .exit                   = mirror_exit,
         .pause                  = mirror_pause,
         .complete               = mirror_complete,
     },
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver commit_active_job_driver = {
         .user_resume            = block_job_user_resume,
         .drain                  = block_job_drain,
         .run                    = mirror_run,
+        .exit                   = mirror_exit,
         .pause                  = mirror_pause,
         .complete               = mirror_complete,
     },
-- 
2.17.1

From: John Snow <jsnow@redhat.com>

Utilize the job_exit shim by not calling job_defer_to_main_loop, and
where applicable, converting the deferred callback into the job_exit
callback.

This converts backup, stream, create, and the unit tests all at once.
Most of these jobs do not see any changes to the order in which they
clean up their resources, except the test-blockjob-txn test, which
now puts down its bs before job_completed is called.

This is safe for the same reason the reordering in the mirror job is
safe, because job_completed no longer runs under two locks, making
the unref safe even if it causes a flush.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20180830015734.19765-7-jsnow@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/backup.c            | 16 ----------------
 block/create.c            | 14 +++-----------
 block/stream.c            | 22 +++++++---------------
 tests/test-bdrv-drain.c   |  6 ------
 tests/test-blockjob-txn.c | 11 ++---------
 tests/test-blockjob.c     | 10 ++++------
 6 files changed, 16 insertions(+), 63 deletions(-)

diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static BlockErrorAction backup_error_action(BackupBlockJob *job,
     }
 }
 
-typedef struct {
-    int ret;
-} BackupCompleteData;
-
-static void backup_complete(Job *job, void *opaque)
-{
-    BackupCompleteData *data = opaque;
-
-    job_completed(job, data->ret);
-    g_free(data);
-}
-
 static bool coroutine_fn yield_and_check(BackupBlockJob *job)
 {
     uint64_t delay_ns;
@@ -XXX,XX +XXX,XX @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)
 static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
 {
     BackupBlockJob *job = container_of(opaque_job, BackupBlockJob, common.job);
-    BackupCompleteData *data;
     BlockDriverState *bs = blk_bs(job->common.blk);
     int64_t offset, nb_clusters;
     int ret = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
     qemu_co_rwlock_unlock(&job->flush_rwlock);
     hbitmap_free(job->copy_bitmap);
 
-    data = g_malloc(sizeof(*data));
-    data->ret = ret;
-    job_defer_to_main_loop(&job->common.job, backup_complete, data);
     return ret;
 }
 
diff --git a/block/create.c b/block/create.c
index XXXXXXX..XXXXXXX 100644
--- a/block/create.c
+++ b/block/create.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlockdevCreateJob {
     Job common;
     BlockDriver *drv;
     BlockdevCreateOptions *opts;
-    int ret;
 } BlockdevCreateJob;
 
-static void blockdev_create_complete(Job *job, void *opaque)
-{
-    BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
-
-    job_completed(job, s->ret);
-}
-
 static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
 {
     BlockdevCreateJob *s = container_of(job, BlockdevCreateJob, common);
+    int ret;
 
     job_progress_set_remaining(&s->common, 1);
-    s->ret = s->drv->bdrv_co_create(s->opts, errp);
+    ret = s->drv->bdrv_co_create(s->opts, errp);
     job_progress_update(&s->common, 1);
 
     qapi_free_BlockdevCreateOptions(s->opts);
-    job_defer_to_main_loop(&s->common, blockdev_create_complete, NULL);
 
-    return s->ret;
+    return ret;
 }
 
 static const JobDriver blockdev_create_job_driver = {
diff --git a/block/stream.c b/block/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/block/stream.c
+++ b/block/stream.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_populate(BlockBackend *blk,
     return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ);
 }
 
-typedef struct {
-    int ret;
-} StreamCompleteData;
-
-static void stream_complete(Job *job, void *opaque)
+static void stream_exit(Job *job)
 {
     StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
     BlockJob *bjob = &s->common;
-    StreamCompleteData *data = opaque;
     BlockDriverState *bs = blk_bs(bjob->blk);
     BlockDriverState *base = s->base;
     Error *local_err = NULL;
+    int ret = job->ret;
 
-    if (!job_is_cancelled(job) && bs->backing && data->ret == 0) {
+    if (!job_is_cancelled(job) && bs->backing && ret == 0) {
         const char *base_id = NULL, *base_fmt = NULL;
         if (base) {
             base_id = s->backing_file_str;
@@ -XXX,XX +XXX,XX @@ static void stream_complete(Job *job, void *opaque)
                 base_fmt = base->drv->format_name;
             }
         }
-        data->ret = bdrv_change_backing_file(bs, base_id, base_fmt);
+        ret = bdrv_change_backing_file(bs, base_id, base_fmt);
         bdrv_set_backing_hd(bs, base, &local_err);
         if (local_err) {
             error_report_err(local_err);
-            data->ret = -EPERM;
+            ret = -EPERM;
             goto out;
         }
     }
@@ -XXX,XX +XXX,XX @@ out:
     }
 
     g_free(s->backing_file_str);
-    job_completed(job, data->ret);
-    g_free(data);
+    job->ret = ret;
 }
 
 static int coroutine_fn stream_run(Job *job, Error **errp)
 {
     StreamBlockJob *s = container_of(job, StreamBlockJob, common.job);
-    StreamCompleteData *data;
     BlockBackend *blk = s->common.blk;
     BlockDriverState *bs = blk_bs(blk);
     BlockDriverState *base = s->base;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_run(Job *job, Error **errp)
 
 out:
     /* Modify backing chain and close BDSes in main loop */
-    data = g_malloc(sizeof(*data));
-    data->ret = ret;
-    job_defer_to_main_loop(&s->common.job, stream_complete, data);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver stream_job_driver = {
         .job_type      = JOB_TYPE_STREAM,
         .free          = block_job_free,
         .run           = stream_run,
+        .exit          = stream_exit,
         .user_resume   = block_job_user_resume,
         .drain         = block_job_drain,
     },
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ typedef struct TestBlockJob {
     bool should_complete;
 } TestBlockJob;
 
-static void test_job_completed(Job *job, void *opaque)
-{
-    job_completed(job, 0);
-}
-
 static int coroutine_fn test_job_run(Job *job, Error **errp)
 {
     TestBlockJob *s = container_of(job, TestBlockJob, common.job);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn test_job_run(Job *job, Error **errp)
         job_pause_point(&s->common.job);
     }
 
-    job_defer_to_main_loop(&s->common.job, test_job_completed, NULL);
     return 0;
 }
 
diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob-txn.c
+++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ typedef struct {
     int *result;
 } TestBlockJob;
 
-static void test_block_job_complete(Job *job, void *opaque)
+static void test_block_job_exit(Job *job)
 {
     BlockJob *bjob = container_of(job, BlockJob, job);
     BlockDriverState *bs = blk_bs(bjob->blk);
-    int rc = (intptr_t)opaque;
 
-    if (job_is_cancelled(job)) {
-        rc = -ECANCELED;
-    }
-
-    job_completed(job, rc);
     bdrv_unref(bs);
 }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn test_block_job_run(Job *job, Error **errp)
         }
     }
 
-    job_defer_to_main_loop(job, test_block_job_complete,
-                           (void *)(intptr_t)s->rc);
     return s->rc;
 }
 
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_block_job_driver = {
         .user_resume   = block_job_user_resume,
         .drain         = block_job_drain,
         .run           = test_block_job_run,
+        .exit          = test_block_job_exit,
     },
 };
 
diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob.c
+++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ typedef struct CancelJob {
     bool completed;
 } CancelJob;
 
-static void cancel_job_completed(Job *job, void *opaque)
+static void cancel_job_exit(Job *job)
 {
-    CancelJob *s = opaque;
+    CancelJob *s = container_of(job, CancelJob, common.job);
     s->completed = true;
-    job_completed(job, 0);
 }
 
 static void cancel_job_complete(Job *job, Error **errp)
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn cancel_job_run(Job *job, Error **errp)
 
     while (!s->should_complete) {
         if (job_is_cancelled(&s->common.job)) {
-            goto defer;
+            return 0;
         }
 
         if (!job_is_ready(&s->common.job) && s->should_converge) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn cancel_job_run(Job *job, Error **errp)
         job_sleep_ns(&s->common.job, 100000);
     }
 
- defer:
-    job_defer_to_main_loop(&s->common.job, cancel_job_completed, s);
     return 0;
 }
 
@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver test_cancel_driver = {
         .user_resume   = block_job_user_resume,
         .drain         = block_job_drain,
         .run           = cancel_job_run,
+        .exit          = cancel_job_exit,
         .complete      = cancel_job_complete,
     },
 };
-- 
2.17.1

From: John Snow <jsnow@redhat.com>

Rename opaque_job to job to be consistent with other job implementations.
Rename 'job', the BackupBlockJob object, to 's' to also be consistent.

Suggested-by: Eric Blake <eblake@redhat.com>
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20180830015734.19765-8-jsnow@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/backup.c | 62 +++++++++++++++++++++++++-------------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void backup_incremental_init_copy_bitmap(BackupBlockJob *job)
     bdrv_dirty_iter_free(dbi);
 }
 
-static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
+static int coroutine_fn backup_run(Job *job, Error **errp)
 {
-    BackupBlockJob *job = container_of(opaque_job, BackupBlockJob, common.job);
-    BlockDriverState *bs = blk_bs(job->common.blk);
+    BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
+    BlockDriverState *bs = blk_bs(s->common.blk);
     int64_t offset, nb_clusters;
     int ret = 0;
 
-    QLIST_INIT(&job->inflight_reqs);
-    qemu_co_rwlock_init(&job->flush_rwlock);
+    QLIST_INIT(&s->inflight_reqs);
+    qemu_co_rwlock_init(&s->flush_rwlock);
 
-    nb_clusters = DIV_ROUND_UP(job->len, job->cluster_size);
-    job_progress_set_remaining(&job->common.job, job->len);
+    nb_clusters = DIV_ROUND_UP(s->len, s->cluster_size);
+    job_progress_set_remaining(job, s->len);
 
-    job->copy_bitmap = hbitmap_alloc(nb_clusters, 0);
-    if (job->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
-        backup_incremental_init_copy_bitmap(job);
+    s->copy_bitmap = hbitmap_alloc(nb_clusters, 0);
+    if (s->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
+        backup_incremental_init_copy_bitmap(s);
     } else {
-        hbitmap_set(job->copy_bitmap, 0, nb_clusters);
+        hbitmap_set(s->copy_bitmap, 0, nb_clusters);
     }
 
 
-    job->before_write.notify = backup_before_write_notify;
-    bdrv_add_before_write_notifier(bs, &job->before_write);
+    s->before_write.notify = backup_before_write_notify;
+    bdrv_add_before_write_notifier(bs, &s->before_write);
 
-    if (job->sync_mode == MIRROR_SYNC_MODE_NONE) {
+    if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {
         /* All bits are set in copy_bitmap to allow any cluster to be copied.
          * This does not actually require them to be copied. */
-        while (!job_is_cancelled(&job->common.job)) {
+        while (!job_is_cancelled(job)) {
             /* Yield until the job is cancelled.  We just let our before_write
              * notify callback service CoW requests. */
-            job_yield(&job->common.job);
+            job_yield(job);
         }
-    } else if (job->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
-        ret = backup_run_incremental(job);
+    } else if (s->sync_mode == MIRROR_SYNC_MODE_INCREMENTAL) {
+        ret = backup_run_incremental(s);
     } else {
         /* Both FULL and TOP SYNC_MODE's require copying.. */
-        for (offset = 0; offset < job->len;
-             offset += job->cluster_size) {
+        for (offset = 0; offset < s->len;
+             offset += s->cluster_size) {
             bool error_is_read;
             int alloced = 0;
 
-            if (yield_and_check(job)) {
+            if (yield_and_check(s)) {
                 break;
             }
 
-            if (job->sync_mode == MIRROR_SYNC_MODE_TOP) {
+            if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {
                 int i;
                 int64_t n;
 
                 /* Check to see if these blocks are already in the
                  * backing file. */
 
-                for (i = 0; i < job->cluster_size;) {
+                for (i = 0; i < s->cluster_size;) {
                     /* bdrv_is_allocated() only returns true/false based
                      * on the first set of sectors it comes across that
                      * are are all in the same state.
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
                      * needed but at some point that is always the case. */
                     alloced =
                         bdrv_is_allocated(bs, offset + i,
-                                          job->cluster_size - i, &n);
+                                          s->cluster_size - i, &n);
                     i += n;
 
                     if (alloced || n == 0) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *opaque_job, Error **errp)
             if (alloced < 0) {
                 ret = alloced;
             } else {
-                ret = backup_do_cow(job, offset, job->cluster_size,
+                ret = backup_do_cow(s, offset, s->cluster_size,
                                     &error_is_read, false);
             }
             if (ret < 0) {
                 /* Depending on error action, fail now or retry cluster */
                 BlockErrorAction action =
-                    backup_error_action(job, error_is_read, -ret);
+                    backup_error_action(s, error_is_read, -ret);
                 if (action == BLOCK_ERROR_ACTION_REPORT) {
                     break;
                 } else {
-                    offset -= job->cluster_size;
+                    offset -= s->cluster_size;
                     continue;
                 }
             }
         }
     }
 
-    notifier_with_return_remove(&job->before_write);
+    notifier_with_return_remove(&s->before_write);
 
     /* wait until pending backup_do_cow() calls have completed */
-    qemu_co_rwlock_wrlock(&job->flush_rwlock);
-    qemu_co_rwlock_unlock(&job->flush_rwlock);
-    hbitmap_free(job->copy_bitmap);
+    qemu_co_rwlock_wrlock(&s->flush_rwlock);
+    qemu_co_rwlock_unlock(&s->flush_rwlock);
+    hbitmap_free(s->copy_bitmap);
 
     return ret;
 }
-- 
2.17.1

From: John Snow <jsnow@redhat.com>

Jobs are now expected to return their retcode on the stack, from the
.run callback, so we can remove that argument.

job_cancel does not need to set -ECANCELED because job_completed will
update the return code itself if the job was canceled.

While we're here, make job_completed static to job.c and remove it from
job.h; move the documentation of return code to the .run() callback and
to the job->ret property, accordingly.

Signed-off-by: John Snow <jsnow@redhat.com>
Message-id: 20180830015734.19765-9-jsnow@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 include/qemu/job.h | 28 +++++++++++++++-------------
 job.c              | 11 ++++++-----
 trace-events       |  2 +-
 3 files changed, 22 insertions(+), 19 deletions(-)

From: John Snow <jsnow@redhat.com>

Now that the job infrastructure is handling the job_completed call for
all implemented jobs, we can remove the interface that allowed jobs to
schedule their own completion.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20180830015734.19765-10-jsnow@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 include/qemu/job.h | 17 -----------------
 job.c              | 40 ++--------------------------------------
 2 files changed, 2 insertions(+), 55 deletions(-)

diff --git a/include/qemu/job.h b/include/qemu/job.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -XXX,XX +XXX,XX @@ void job_finalize(Job *job, Error **errp);
  */
 void job_dismiss(Job **job, Error **errp);
 
-typedef void JobDeferToMainLoopFn(Job *job, void *opaque);
-
-/**
- * @job: The job
- * @fn: The function to run in the main loop
- * @opaque: The opaque value that is passed to @fn
- *
- * This function must be called by the main job coroutine just before it
- * returns.  @fn is executed in the main loop with the job AioContext acquired.
- *
- * Block jobs must call bdrv_unref(), bdrv_close(), and anything that uses
- * bdrv_drain_all() in the main loop.
- *
- * The @job AioContext is held while @fn executes.
- */
-void job_defer_to_main_loop(Job *job, JobDeferToMainLoopFn *fn, void *opaque);
-
 /**
  * Synchronously finishes the given @job. If @finish is given, it is called to
  * trigger completion or cancellation of the job.
diff --git a/job.c b/job.c
index XXXXXXX..XXXXXXX 100644
--- a/job.c
+++ b/job.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn job_co_entry(void *opaque)
     assert(job && job->driver && job->driver->run);
     job_pause_point(job);
     job->ret = job->driver->run(job, &job->err);
-    if (!job->deferred_to_main_loop) {
-        job->deferred_to_main_loop = true;
-        aio_bh_schedule_oneshot(qemu_get_aio_context(),
-                                job_exit,
-                                job);
-    }
+    job->deferred_to_main_loop = true;
+    aio_bh_schedule_oneshot(qemu_get_aio_context(), job_exit, job);
 }
 
 
@@ -XXX,XX +XXX,XX @@ void job_complete(Job *job, Error **errp)
     job->driver->complete(job, errp);
 }
 
-
-typedef struct {
-    Job *job;
-    JobDeferToMainLoopFn *fn;
-    void *opaque;
-} JobDeferToMainLoopData;
-
-static void job_defer_to_main_loop_bh(void *opaque)
-{
-    JobDeferToMainLoopData *data = opaque;
-    Job *job = data->job;
-    AioContext *aio_context = job->aio_context;
-
-    aio_context_acquire(aio_context);
-    data->fn(data->job, data->opaque);
-    aio_context_release(aio_context);
-
-    g_free(data);
-}
-
-void job_defer_to_main_loop(Job *job, JobDeferToMainLoopFn *fn, void *opaque)
-{
-    JobDeferToMainLoopData *data = g_malloc(sizeof(*data));
-    data->job = job;
-    data->fn = fn;
-    data->opaque = opaque;
-    job->deferred_to_main_loop = true;
-
-    aio_bh_schedule_oneshot(qemu_get_aio_context(),
-                            job_defer_to_main_loop_bh, data);
-}
-
 int job_finish_sync(Job *job, void (*finish)(Job *, Error **errp), Error **errp)
 {
     Error *local_err = NULL;
-- 
2.17.1

The following changes since commit fc3dbb90f2eb069801bfb4cfe9cbc83cf9c5f4a9:

Merge remote-tracking branch 'remotes/jnsnow/tags/bitmaps-pull-request' into staging (2019-02-21 13:09:33 +0000)

are available in the Git repository at:

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

for you to fetch changes up to 9a9f4b74fa547b68edb38fa414999836770a4735:

tests/virtio-blk: add test for DISCARD command (2019-02-22 09:42:17 +0000)

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

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

Stefano Garzarella (10):
  virtio-blk: add acct_failed param to virtio_blk_handle_rw_error()
  virtio-blk: add host_features field in VirtIOBlock
  virtio-blk: add "discard" and "write-zeroes" properties
  virtio-net: make VirtIOFeature usable for other virtio devices
  virtio-blk: set config size depending on the features enabled
  virtio-blk: add DISCARD and WRITE_ZEROES features
  tests/virtio-blk: change assert on data_size in virtio_blk_request()
  tests/virtio-blk: add virtio_blk_fix_dwz_hdr() function
  tests/virtio-blk: add test for WRITE_ZEROES command
  tests/virtio-blk: add test for DISCARD command

Vladimir Sementsov-Ogievskiy (17):
  block: enhance QEMUIOVector structure
  block/io: use qemu_iovec_init_buf
  block/block-backend: use QEMU_IOVEC_INIT_BUF
  block/backup: use qemu_iovec_init_buf
  block/commit: use QEMU_IOVEC_INIT_BUF
  block/stream: use QEMU_IOVEC_INIT_BUF
  block/parallels: use QEMU_IOVEC_INIT_BUF
  block/qcow: use qemu_iovec_init_buf
  block/qcow2: use qemu_iovec_init_buf
  block/qed: use qemu_iovec_init_buf
  block/vmdk: use qemu_iovec_init_buf
  qemu-img: use qemu_iovec_init_buf
  migration/block: use qemu_iovec_init_buf
  tests/test-bdrv-drain: use QEMU_IOVEC_INIT_BUF
  hw/ide: drop iov field from IDEState
  hw/ide: drop iov field from IDEBufferedRequest
  hw/ide: drop iov field from IDEDMA

-- 
2.20.1

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

Add a possibility of embedded iovec, for cases when we need only one
local iov.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20190218140926.333779-2-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-2-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/iov.h | 64 ++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 62 insertions(+), 2 deletions(-)

diff --git a/include/qemu/iov.h b/include/qemu/iov.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/iov.h
+++ b/include/qemu/iov.h
@@ -XXX,XX +XXX,XX @@ size_t iov_discard_back(struct iovec *iov, unsigned int *iov_cnt,
 typedef struct QEMUIOVector {
     struct iovec *iov;
     int niov;
-    int nalloc;
-    size_t size;
+
+    /*
+     * For external @iov (qemu_iovec_init_external()) or allocated @iov
+     * (qemu_iovec_init()), @size is the cumulative size of iovecs and
+     * @local_iov is invalid and unused.
+     *
+     * For embedded @iov (QEMU_IOVEC_INIT_BUF() or qemu_iovec_init_buf()),
+     * @iov is equal to &@local_iov, and @size is valid, as it has same
+     * offset and type as @local_iov.iov_len, which is guaranteed by
+     * static assertion below.
+     *
+     * @nalloc is always valid and is -1 both for embedded and external
+     * cases. It is included in the union only to ensure the padding prior
+     * to the @size field will not result in a 0-length array.
+     */
+    union {
+        struct {
+            int nalloc;
+            struct iovec local_iov;
+        };
+        struct {
+            char __pad[sizeof(int) + offsetof(struct iovec, iov_len)];
+            size_t size;
+        };
+    };
 } QEMUIOVector;
 
+QEMU_BUILD_BUG_ON(offsetof(QEMUIOVector, size) !=
+                  offsetof(QEMUIOVector, local_iov.iov_len));
+
+#define QEMU_IOVEC_INIT_BUF(self, buf, len)              \
+{                                                        \
+    .iov = &(self).local_iov,                            \
+    .niov = 1,                                           \
+    .nalloc = -1,                                        \
+    .local_iov = {                                       \
+        .iov_base = (void *)(buf), /* cast away const */ \
+        .iov_len = (len),                                \
+    },                                                   \
+}
+
+/*
+ * qemu_iovec_init_buf
+ *
+ * Initialize embedded QEMUIOVector.
+ *
+ * Note: "const" is used over @buf pointer to make it simple to pass
+ * const pointers, appearing in read functions. Then this "const" is
+ * cast away by QEMU_IOVEC_INIT_BUF().
+ */
+static inline void qemu_iovec_init_buf(QEMUIOVector *qiov,
+                                       const void *buf, size_t len)
+{
+    *qiov = (QEMUIOVector) QEMU_IOVEC_INIT_BUF(*qiov, buf, len);
+}
+
+static inline void *qemu_iovec_buf(QEMUIOVector *qiov)
+{
+    /* Only supports embedded iov */
+    assert(qiov->nalloc == -1 && qiov->iov == &qiov->local_iov);
+
+    return qiov->local_iov.iov_base;
+}
+
 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
-- 
2.20.1

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

Use new qemu_iovec_init_buf() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

While being here, use qemu_try_blockalign0 as well.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-3-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-3-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 89 ++++++++++++------------------------------------------
 1 file changed, 20 insertions(+), 69 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static int bdrv_prwv_co(BdrvChild *child, int64_t offset,
 static int bdrv_rw_co(BdrvChild *child, int64_t sector_num, uint8_t *buf,
                       int nb_sectors, bool is_write, BdrvRequestFlags flags)
 {
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base = (void *)buf,
-        .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
-    };
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf,
+                                            nb_sectors * BDRV_SECTOR_SIZE);
 
     if (nb_sectors < 0 || nb_sectors > BDRV_REQUEST_MAX_SECTORS) {
         return -EINVAL;
     }
 
-    qemu_iovec_init_external(&qiov, &iov, 1);
     return bdrv_prwv_co(child, sector_num << BDRV_SECTOR_BITS,
                         &qiov, is_write, flags);
 }
@@ -XXX,XX +XXX,XX @@ int bdrv_write(BdrvChild *child, int64_t sector_num,
 int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
                        int bytes, BdrvRequestFlags flags)
 {
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base = NULL,
-        .iov_len = bytes,
-    };
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, bytes);
 
-    qemu_iovec_init_external(&qiov, &iov, 1);
     return bdrv_prwv_co(child, offset, &qiov, true,
                         BDRV_REQ_ZERO_WRITE | flags);
 }
@@ -XXX,XX +XXX,XX @@ int bdrv_preadv(BdrvChild *child, int64_t offset, QEMUIOVector *qiov)
 
 int bdrv_pread(BdrvChild *child, int64_t offset, void *buf, int bytes)
 {
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base = (void *)buf,
-        .iov_len = bytes,
-    };
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
 
     if (bytes < 0) {
         return -EINVAL;
     }
 
-    qemu_iovec_init_external(&qiov, &iov, 1);
     return bdrv_preadv(child, offset, &qiov);
 }
 
@@ -XXX,XX +XXX,XX @@ int bdrv_pwritev(BdrvChild *child, int64_t offset, QEMUIOVector *qiov)
 
 int bdrv_pwrite(BdrvChild *child, int64_t offset, const void *buf, int bytes)
 {
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base   = (void *) buf,
-        .iov_len    = bytes,
-    };
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
 
     if (bytes < 0) {
         return -EINVAL;
     }
 
-    qemu_iovec_init_external(&qiov, &iov, 1);
     return bdrv_pwritev(child, offset, &qiov);
 }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
     void *bounce_buffer;
 
     BlockDriver *drv = bs->drv;
-    struct iovec iov;
     QEMUIOVector local_qiov;
     int64_t cluster_offset;
     int64_t cluster_bytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
 
         if (ret <= 0) {
             /* Must copy-on-read; use the bounce buffer */
-            iov.iov_base = bounce_buffer;
-            iov.iov_len = pnum = MIN(pnum, MAX_BOUNCE_BUFFER);
-            qemu_iovec_init_external(&local_qiov, &iov, 1);
+            pnum = MIN(pnum, MAX_BOUNCE_BUFFER);
+            qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);
 
             ret = bdrv_driver_preadv(bs, cluster_offset, pnum,
                                      &local_qiov, 0);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
 {
     BlockDriver *drv = bs->drv;
     QEMUIOVector qiov;
-    struct iovec iov = {0};
+    void *buf = NULL;
     int ret = 0;
     bool need_flush = false;
     int head = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
                 need_flush = true;
             }
             num = MIN(num, max_transfer);
-            iov.iov_len = num;
-            if (iov.iov_base == NULL) {
-                iov.iov_base = qemu_try_blockalign(bs, num);
-                if (iov.iov_base == NULL) {
+            if (buf == NULL) {
+                buf = qemu_try_blockalign0(bs, num);
+                if (buf == NULL) {
                     ret = -ENOMEM;
                     goto fail;
                 }
-                memset(iov.iov_base, 0, num);
             }
-            qemu_iovec_init_external(&qiov, &iov, 1);
+            qemu_iovec_init_buf(&qiov, buf, num);
 
             ret = bdrv_driver_pwritev(bs, offset, num, &qiov, write_flags);
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
              * all future requests.
              */
             if (num < max_transfer) {
-                qemu_vfree(iov.iov_base);
-                iov.iov_base = NULL;
+                qemu_vfree(buf);
+                buf = NULL;
             }
         }
 
@@ -XXX,XX +XXX,XX @@ fail:
     if (ret == 0 && need_flush) {
         ret = bdrv_co_flush(bs);
     }
-    qemu_vfree(iov.iov_base);
+    qemu_vfree(buf);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
     BlockDriverState *bs = child->bs;
     uint8_t *buf = NULL;
     QEMUIOVector local_qiov;
-    struct iovec iov;
     uint64_t align = bs->bl.request_alignment;
     unsigned int head_padding_bytes, tail_padding_bytes;
     int ret = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
     assert(flags & BDRV_REQ_ZERO_WRITE);
     if (head_padding_bytes || tail_padding_bytes) {
         buf = qemu_blockalign(bs, align);
-        iov = (struct iovec) {
-            .iov_base   = buf,
-            .iov_len    = align,
-        };
-        qemu_iovec_init_external(&local_qiov, &iov, 1);
+        qemu_iovec_init_buf(&local_qiov, buf, align);
     }
     if (head_padding_bytes) {
         uint64_t zero_bytes = MIN(bytes, align - head_padding_bytes);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
 
     if (offset & (align - 1)) {
         QEMUIOVector head_qiov;
-        struct iovec head_iov;
 
         mark_request_serialising(&req, align);
         wait_serialising_requests(&req);
 
         head_buf = qemu_blockalign(bs, align);
-        head_iov = (struct iovec) {
-            .iov_base   = head_buf,
-            .iov_len    = align,
-        };
-        qemu_iovec_init_external(&head_qiov, &head_iov, 1);
+        qemu_iovec_init_buf(&head_qiov, head_buf, align);
 
         bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
         ret = bdrv_aligned_preadv(child, &req, offset & ~(align - 1), align,
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
 
     if ((offset + bytes) & (align - 1)) {
         QEMUIOVector tail_qiov;
-        struct iovec tail_iov;
         size_t tail_bytes;
         bool waited;
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
         assert(!waited || !use_local_qiov);
 
         tail_buf = qemu_blockalign(bs, align);
-        tail_iov = (struct iovec) {
-            .iov_base   = tail_buf,
-            .iov_len    = align,
-        };
-        qemu_iovec_init_external(&tail_qiov, &tail_iov, 1);
+        qemu_iovec_init_buf(&tail_qiov, tail_buf, align);
 
         bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
         ret = bdrv_aligned_preadv(child, &req, (offset + bytes) & ~(align - 1),
@@ -XXX,XX +XXX,XX @@ bdrv_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos,
 int bdrv_save_vmstate(BlockDriverState *bs, const uint8_t *buf,
                       int64_t pos, int size)
 {
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base   = (void *) buf,
-        .iov_len    = size,
-    };
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, size);
     int ret;
 
-    qemu_iovec_init_external(&qiov, &iov, 1);
-
     ret = bdrv_writev_vmstate(bs, &qiov, pos);
     if (ret < 0) {
         return ret;
@@ -XXX,XX +XXX,XX @@ int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
 int bdrv_load_vmstate(BlockDriverState *bs, uint8_t *buf,
                       int64_t pos, int size)
 {
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base   = buf,
-        .iov_len    = size,
-    };
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, size);
     int ret;
 
-    qemu_iovec_init_external(&qiov, &iov, 1);
     ret = bdrv_readv_vmstate(bs, &qiov, pos);
     if (ret < 0) {
         return ret;
-- 
2.20.1

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

Use new QEMU_IOVEC_INIT_BUF() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-4-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-4-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/block-backend.c | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
                    int64_t bytes, CoroutineEntry co_entry,
                    BdrvRequestFlags flags)
 {
-    QEMUIOVector qiov;
-    struct iovec iov;
-    BlkRwCo rwco;
-
-    iov = (struct iovec) {
-        .iov_base = buf,
-        .iov_len = bytes,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
-
-    rwco = (BlkRwCo) {
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
+    BlkRwCo rwco = {
         .blk    = blk,
         .offset = offset,
         .iobuf  = &qiov,
-- 
2.20.1

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

Use new qemu_iovec_init_buf() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-5-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-5-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/backup.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job,
                                                       void **bounce_buffer)
 {
     int ret;
-    struct iovec iov;
     QEMUIOVector qiov;
     BlockBackend *blk = job->common.blk;
     int nbytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_cow_with_bounce_buffer(BackupBlockJob *job,
     if (!*bounce_buffer) {
         *bounce_buffer = blk_blockalign(blk, job->cluster_size);
     }
-    iov.iov_base = *bounce_buffer;
-    iov.iov_len = nbytes;
-    qemu_iovec_init_external(&qiov, &iov, 1);
+    qemu_iovec_init_buf(&qiov, *bounce_buffer, nbytes);
 
     ret = blk_co_preadv(blk, start, qiov.size, &qiov, read_flags);
     if (ret < 0) {
-- 
2.20.1

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

Use new QEMU_IOVEC_INIT_BUF() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-6-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-6-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/commit.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

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_populate(BlockBackend *bs, BlockBackend *base,
                                         void *buf)
 {
     int ret = 0;
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base = buf,
-        .iov_len = bytes,
-    };
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
 
     assert(bytes < SIZE_MAX);
-    qemu_iovec_init_external(&qiov, &iov, 1);
 
     ret = blk_co_preadv(bs, offset, qiov.size, &qiov, 0);
     if (ret < 0) {
-- 
2.20.1

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

Use new QEMU_IOVEC_INIT_BUF() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-7-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-7-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/stream.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/block/stream.c b/block/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/block/stream.c
+++ b/block/stream.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_populate(BlockBackend *blk,
                                         int64_t offset, uint64_t bytes,
                                         void *buf)
 {
-    struct iovec iov = {
-        .iov_base = buf,
-        .iov_len  = bytes,
-    };
-    QEMUIOVector qiov;
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buf, bytes);
 
     assert(bytes < SIZE_MAX);
-    qemu_iovec_init_external(&qiov, &iov, 1);
 
     /* Copy-on-read the unallocated clusters */
     return blk_co_preadv(blk, offset, qiov.size, &qiov, BDRV_REQ_COPY_ON_READ);
-- 
2.20.1

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

Use new QEMU_IOVEC_INIT_BUF() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-8-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-8-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/parallels.c | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
     if (bs->backing) {
         int64_t nb_cow_sectors = to_allocate * s->tracks;
         int64_t nb_cow_bytes = nb_cow_sectors << BDRV_SECTOR_BITS;
-        QEMUIOVector qiov;
-        struct iovec iov = {
-            .iov_len = nb_cow_bytes,
-            .iov_base = qemu_blockalign(bs, nb_cow_bytes)
-        };
-        qemu_iovec_init_external(&qiov, &iov, 1);
+        QEMUIOVector qiov =
+            QEMU_IOVEC_INIT_BUF(qiov, qemu_blockalign(bs, nb_cow_bytes),
+                                nb_cow_bytes);
 
         ret = bdrv_co_preadv(bs->backing, idx * s->tracks * BDRV_SECTOR_SIZE,
                              nb_cow_bytes, &qiov, 0);
         if (ret < 0) {
-            qemu_vfree(iov.iov_base);
+            qemu_vfree(qemu_iovec_buf(&qiov));
             return ret;
         }
 
         ret = bdrv_co_pwritev(bs->file, s->data_end * BDRV_SECTOR_SIZE,
                               nb_cow_bytes, &qiov, 0);
-        qemu_vfree(iov.iov_base);
+        qemu_vfree(qemu_iovec_buf(&qiov));
         if (ret < 0) {
             return ret;
         }
-- 
2.20.1

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

Use new qemu_iovec_init_buf() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-9-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-9-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow.c | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

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 coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
     int offset_in_cluster;
     int ret = 0, n;
     uint64_t cluster_offset;
-    struct iovec hd_iov;
     QEMUIOVector hd_qiov;
     uint8_t *buf;
     void *orig_buf;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
         if (!cluster_offset) {
             if (bs->backing) {
                 /* read from the base image */
-                hd_iov.iov_base = (void *)buf;
-                hd_iov.iov_len = n;
-                qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
+                qemu_iovec_init_buf(&hd_qiov, buf, n);
                 qemu_co_mutex_unlock(&s->lock);
                 /* qcow2 emits this on bs->file instead of bs->backing */
                 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_preadv(BlockDriverState *bs, uint64_t offset,
                 ret = -EIO;
                 break;
             }
-            hd_iov.iov_base = (void *)buf;
-            hd_iov.iov_len = n;
-            qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
+            qemu_iovec_init_buf(&hd_qiov, buf, n);
             qemu_co_mutex_unlock(&s->lock);
             BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
             ret = bdrv_co_preadv(bs->file, cluster_offset + offset_in_cluster,
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_pwritev(BlockDriverState *bs, uint64_t offset,
     int offset_in_cluster;
     uint64_t cluster_offset;
     int ret = 0, n;
-    struct iovec hd_iov;
     QEMUIOVector hd_qiov;
     uint8_t *buf;
     void *orig_buf;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_pwritev(BlockDriverState *bs, uint64_t offset,
             }
         }
 
-        hd_iov.iov_base = (void *)buf;
-        hd_iov.iov_len = n;
-        qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
+        qemu_iovec_init_buf(&hd_qiov, buf, n);
         qemu_co_mutex_unlock(&s->lock);
         BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
         ret = bdrv_co_pwritev(bs->file, cluster_offset + offset_in_cluster,
@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
 {
     BDRVQcowState *s = bs->opaque;
     QEMUIOVector hd_qiov;
-    struct iovec iov;
     z_stream strm;
     int ret, out_len;
     uint8_t *buf, *out_buf;
@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
     }
     cluster_offset &= s->cluster_offset_mask;
 
-    iov = (struct iovec) {
-        .iov_base   = out_buf,
-        .iov_len    = out_len,
-    };
-    qemu_iovec_init_external(&hd_qiov, &iov, 1);
+    qemu_iovec_init_buf(&hd_qiov, out_buf, out_len);
     BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
     ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);
     if (ret < 0) {
-- 
2.20.1

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

Use new qemu_iovec_init_buf() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-10-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-10-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow2.c | 12 ++----------
 1 file changed, 2 insertions(+), 10 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 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
 {
     BDRVQcow2State *s = bs->opaque;
     QEMUIOVector hd_qiov;
-    struct iovec iov;
     int ret;
     size_t out_len;
     uint8_t *buf, *out_buf;
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
         goto fail;
     }
 
-    iov = (struct iovec) {
-        .iov_base   = out_buf,
-        .iov_len    = out_len,
-    };
-    qemu_iovec_init_external(&hd_qiov, &iov, 1);
+    qemu_iovec_init_buf(&hd_qiov, out_buf, out_len);
 
     BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
     ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
     int ret = 0, csize, nb_csectors;
     uint64_t coffset;
     uint8_t *buf, *out_buf;
-    struct iovec iov;
     QEMUIOVector local_qiov;
     int offset_in_cluster = offset_into_cluster(s, offset);
 
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
     if (!buf) {
         return -ENOMEM;
     }
-    iov.iov_base = buf;
-    iov.iov_len = csize;
-    qemu_iovec_init_external(&local_qiov, &iov, 1);
+    qemu_iovec_init_buf(&local_qiov, buf, csize);
 
     out_buf = qemu_blockalign(bs, s->cluster_size);
 
-- 
2.20.1

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

Use new qemu_iovec_init_buf() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-11-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-11-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qed-table.c | 16 +++-------------
 block/qed.c       | 31 +++++++++----------------------
 2 files changed, 12 insertions(+), 35 deletions(-)

diff --git a/block/qed-table.c b/block/qed-table.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed-table.c
+++ b/block/qed-table.c
@@ -XXX,XX +XXX,XX @@
 /* Called with table_lock held.  */
 static int qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table)
 {
-    QEMUIOVector qiov;
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(
+        qiov, table->offsets, s->header.cluster_size * s->header.table_size);
     int noffsets;
     int i, ret;
 
-    struct iovec iov = {
-        .iov_base = table->offsets,
-        .iov_len = s->header.cluster_size * s->header.table_size,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
-
     trace_qed_read_table(s, offset, table);
 
     qemu_co_mutex_unlock(&s->table_lock);
@@ -XXX,XX +XXX,XX @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
     unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;
     unsigned int start, end, i;
     QEDTable *new_table;
-    struct iovec iov;
     QEMUIOVector qiov;
     size_t len_bytes;
     int ret;
@@ -XXX,XX +XXX,XX @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,
     len_bytes = (end - start) * sizeof(uint64_t);
 
     new_table = qemu_blockalign(s->bs, len_bytes);
-    iov = (struct iovec) {
-        .iov_base = new_table->offsets,
-        .iov_len = len_bytes,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
+    qemu_iovec_init_buf(&qiov, new_table->offsets, len_bytes);
 
     /* Byteswap table */
     for (i = start; i < end; i++) {
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 qed_write_header(BDRVQEDState *s)
     int nsectors = DIV_ROUND_UP(sizeof(QEDHeader), BDRV_SECTOR_SIZE);
     size_t len = nsectors * BDRV_SECTOR_SIZE;
     uint8_t *buf;
-    struct iovec iov;
     QEMUIOVector qiov;
     int ret;
 
     assert(s->allocating_acb || s->allocating_write_reqs_plugged);
 
     buf = qemu_blockalign(s->bs, len);
-    iov = (struct iovec) {
-        .iov_base = buf,
-        .iov_len = len,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
+    qemu_iovec_init_buf(&qiov, buf, len);
 
     ret = bdrv_co_preadv(s->bs->file, 0, qiov.size, &qiov, 0);
     if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,
 {
     QEMUIOVector qiov;
     QEMUIOVector *backing_qiov = NULL;
-    struct iovec iov;
     int ret;
 
     /* Skip copy entirely if there is no work to do */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,
         return 0;
     }
 
-    iov = (struct iovec) {
-        .iov_base = qemu_blockalign(s->bs, len),
-        .iov_len = len,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
+    qemu_iovec_init_buf(&qiov, qemu_blockalign(s->bs, len), len);
 
     ret = qed_read_backing_file(s, pos, &qiov, &backing_qiov);
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_copy_from_backing_file(BDRVQEDState *s,
     }
     ret = 0;
 out:
-    qemu_vfree(iov.iov_base);
+    qemu_vfree(qemu_iovec_buf(&qiov));
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_pwrite_zeroes(BlockDriverState *bs,
                                                   BdrvRequestFlags flags)
 {
     BDRVQEDState *s = bs->opaque;
-    QEMUIOVector qiov;
-    struct iovec iov;
+
+    /*
+     * Zero writes start without an I/O buffer.  If a buffer becomes necessary
+     * then it will be allocated during request processing.
+     */
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, bytes);
 
     /* Fall back if the request is not aligned */
     if (qed_offset_into_cluster(s, offset) ||
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_pwrite_zeroes(BlockDriverState *bs,
         return -ENOTSUP;
     }
 
-    /* Zero writes start without an I/O buffer.  If a buffer becomes necessary
-     * then it will be allocated during request processing.
-     */
-    iov.iov_base = NULL;
-    iov.iov_len = bytes;
-
-    qemu_iovec_init_external(&qiov, &iov, 1);
     return qed_co_request(bs, offset >> BDRV_SECTOR_BITS, &qiov,
                           bytes >> BDRV_SECTOR_BITS,
                           QED_AIOCB_WRITE | QED_AIOCB_ZERO);
-- 
2.20.1

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

Use new qemu_iovec_init_buf() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-12-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-12-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/vmdk.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

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_write_extent(VmdkExtent *extent, int64_t cluster_offset,
     VmdkGrainMarker *data = NULL;
     uLongf buf_len;
     QEMUIOVector local_qiov;
-    struct iovec iov;
     int64_t write_offset;
     int64_t write_end_sector;
 
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
         data->size = cpu_to_le32(buf_len);
 
         n_bytes = buf_len + sizeof(VmdkGrainMarker);
-        iov = (struct iovec) {
-            .iov_base   = data,
-            .iov_len    = n_bytes,
-        };
-        qemu_iovec_init_external(&local_qiov, &iov, 1);
+        qemu_iovec_init_buf(&local_qiov, data, n_bytes);
 
         BLKDBG_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED);
     } else {
-- 
2.20.1

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

Use new qemu_iovec_init_buf() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-13-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-13-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qemu-img.c | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

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 coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
 {
     int n, ret;
     QEMUIOVector qiov;
-    struct iovec iov;
 
     assert(nb_sectors <= s->buf_sectors);
     while (nb_sectors > 0) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_read(ImgConvertState *s, int64_t sector_num,
         bs_sectors = s->src_sectors[src_cur];
 
         n = MIN(nb_sectors, bs_sectors - (sector_num - src_cur_offset));
-        iov.iov_base = buf;
-        iov.iov_len = n << BDRV_SECTOR_BITS;
-        qemu_iovec_init_external(&qiov, &iov, 1);
+        qemu_iovec_init_buf(&qiov, buf, n << BDRV_SECTOR_BITS);
 
         ret = blk_co_preadv(
                 blk, (sector_num - src_cur_offset) << BDRV_SECTOR_BITS,
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
 {
     int ret;
     QEMUIOVector qiov;
-    struct iovec iov;
 
     while (nb_sectors > 0) {
         int n = nb_sectors;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn convert_co_write(ImgConvertState *s, int64_t sector_num,
                 (s->compressed &&
                  !buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)))
             {
-                iov.iov_base = buf;
-                iov.iov_len = n << BDRV_SECTOR_BITS;
-                qemu_iovec_init_external(&qiov, &iov, 1);
+                qemu_iovec_init_buf(&qiov, buf, n << BDRV_SECTOR_BITS);
 
                 ret = blk_co_pwritev(s->target, sector_num << BDRV_SECTOR_BITS,
                                      n << BDRV_SECTOR_BITS, &qiov, flags);
-- 
2.20.1

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

Use new qemu_iovec_init_buf() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-14-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-14-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 migration/block.c | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/migration/block.c b/migration/block.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/block.c
+++ b/migration/block.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlkMigBlock {
     BlkMigDevState *bmds;
     int64_t sector;
     int nr_sectors;
-    struct iovec iov;
     QEMUIOVector qiov;
     BlockAIOCB *aiocb;
 
@@ -XXX,XX +XXX,XX @@ static int mig_save_device_bulk(QEMUFile *f, BlkMigDevState *bmds)
     blk->sector = cur_sector;
     blk->nr_sectors = nr_sectors;
 
-    blk->iov.iov_base = blk->buf;
-    blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
-    qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
+    qemu_iovec_init_buf(&blk->qiov, blk->buf, nr_sectors * BDRV_SECTOR_SIZE);
 
     blk_mig_lock();
     block_mig_state.submitted++;
@@ -XXX,XX +XXX,XX @@ static int mig_save_device_dirty(QEMUFile *f, BlkMigDevState *bmds,
             blk->nr_sectors = nr_sectors;
 
             if (is_async) {
-                blk->iov.iov_base = blk->buf;
-                blk->iov.iov_len = nr_sectors * BDRV_SECTOR_SIZE;
-                qemu_iovec_init_external(&blk->qiov, &blk->iov, 1);
+                qemu_iovec_init_buf(&blk->qiov, blk->buf,
+                                    nr_sectors * BDRV_SECTOR_SIZE);
 
                 blk->aiocb = blk_aio_preadv(bmds->blk,
                                             sector * BDRV_SECTOR_SIZE,
-- 
2.20.1

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

Use new QEMU_IOVEC_INIT_BUF() instead of
qemu_iovec_init_external( ... , 1), which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-15-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-15-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/test-bdrv-drain.c | 29 ++++-------------------------
 1 file changed, 4 insertions(+), 25 deletions(-)

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
     BlockAIOCB *acb;
     int aio_ret;
 
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base = NULL,
-        .iov_len = 0,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
 
     blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
     bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
@@ -XXX,XX +XXX,XX @@ static void test_iothread_common(enum drain_type drain_type, int drain_thread)
     AioContext *ctx_a = iothread_get_aio_context(a);
     AioContext *ctx_b = iothread_get_aio_context(b);
 
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base = NULL,
-        .iov_len = 0,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
 
     /* bdrv_drain_all() may only be called from the main loop thread */
     if (drain_type == BDRV_DRAIN_ALL && drain_thread != 0) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_co_delete_by_drain(void *opaque)
     BlockDriverState *bs = blk_bs(blk);
     BDRVTestTopState *tts = bs->opaque;
     void *buffer = g_malloc(65536);
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base = buffer,
-        .iov_len  = 65536,
-    };
-
-    qemu_iovec_init_external(&qiov, &iov, 1);
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buffer, 65536);
 
     /* Pretend some internal write operation from parent to child.
      * Important: We have to read from the child, not from the parent!
@@ -XXX,XX +XXX,XX @@ static void test_detach_indirect(bool by_parent_cb)
     BdrvChild *child_a, *child_b;
     BlockAIOCB *acb;
 
-    QEMUIOVector qiov;
-    struct iovec iov = {
-        .iov_base = NULL,
-        .iov_len = 0,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
+    QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, NULL, 0);
 
     if (!by_parent_cb) {
         detach_by_driver_cb_role = child_file;
-- 
2.20.1

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

@iov is used only to initialize @qiov. Let's use new
qemu_iovec_init_buf() instead, which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-16-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-16-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/ide/internal.h | 1 -
 hw/ide/atapi.c            | 9 ++++-----
 hw/ide/core.c             | 8 ++------
 3 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/include/hw/ide/internal.h b/include/hw/ide/internal.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/ide/internal.h
+++ b/include/hw/ide/internal.h
@@ -XXX,XX +XXX,XX @@ struct IDEState {
     int atapi_dma; /* true if dma is requested for the packet cmd */
     BlockAcctCookie acct;
     BlockAIOCB *pio_aiocb;
-    struct iovec iov;
     QEMUIOVector qiov;
     QLIST_HEAD(, IDEBufferedRequest) buffered_requests;
     /* ATA DMA state */
diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ide/atapi.c
+++ b/hw/ide/atapi.c
@@ -XXX,XX +XXX,XX @@ static void cd_read_sector_cb(void *opaque, int ret)
 
 static int cd_read_sector(IDEState *s)
 {
+    void *buf;
+
     if (s->cd_sector_size != 2048 && s->cd_sector_size != 2352) {
         block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_READ);
         return -EINVAL;
     }
 
-    s->iov.iov_base = (s->cd_sector_size == 2352) ?
-                      s->io_buffer + 16 : s->io_buffer;
-
-    s->iov.iov_len = ATAPI_SECTOR_SIZE;
-    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
+    buf = (s->cd_sector_size == 2352) ? s->io_buffer + 16 : s->io_buffer;
+    qemu_iovec_init_buf(&s->qiov, buf, ATAPI_SECTOR_SIZE);
 
     trace_cd_read_sector(s->lba);
 
diff --git a/hw/ide/core.c b/hw/ide/core.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ide/core.c
+++ b/hw/ide/core.c
@@ -XXX,XX +XXX,XX @@ static void ide_sector_read(IDEState *s)
         return;
     }
 
-    s->iov.iov_base = s->io_buffer;
-    s->iov.iov_len  = n * BDRV_SECTOR_SIZE;
-    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
+    qemu_iovec_init_buf(&s->qiov, s->io_buffer, n * BDRV_SECTOR_SIZE);
 
     block_acct_start(blk_get_stats(s->blk), &s->acct,
                      n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
@@ -XXX,XX +XXX,XX @@ static void ide_sector_write(IDEState *s)
         return;
     }
 
-    s->iov.iov_base = s->io_buffer;
-    s->iov.iov_len  = n * BDRV_SECTOR_SIZE;
-    qemu_iovec_init_external(&s->qiov, &s->iov, 1);
+    qemu_iovec_init_buf(&s->qiov, s->io_buffer, n * BDRV_SECTOR_SIZE);
 
     block_acct_start(blk_get_stats(s->blk), &s->acct,
                      n * BDRV_SECTOR_SIZE, BLOCK_ACCT_WRITE);
-- 
2.20.1

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

@iov is used only to initialize @qiov. Let's use new
qemu_iovec_init_buf() instead, which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-17-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-17-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/ide/internal.h |  1 -
 hw/ide/core.c             | 11 ++++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/hw/ide/internal.h b/include/hw/ide/internal.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/ide/internal.h
+++ b/include/hw/ide/internal.h
@@ -XXX,XX +XXX,XX @@ extern const char *IDE_DMA_CMD_lookup[IDE_DMA__COUNT];
 
 typedef struct IDEBufferedRequest {
     QLIST_ENTRY(IDEBufferedRequest) list;
-    struct iovec iov;
     QEMUIOVector qiov;
     QEMUIOVector *original_qiov;
     BlockCompletionFunc *original_cb;
diff --git a/hw/ide/core.c b/hw/ide/core.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ide/core.c
+++ b/hw/ide/core.c
@@ -XXX,XX +XXX,XX @@ static void ide_buffered_readv_cb(void *opaque, int ret)
     IDEBufferedRequest *req = opaque;
     if (!req->orphaned) {
         if (!ret) {
-            qemu_iovec_from_buf(req->original_qiov, 0, req->iov.iov_base,
+            assert(req->qiov.size == req->original_qiov->size);
+            qemu_iovec_from_buf(req->original_qiov, 0,
+                                req->qiov.local_iov.iov_base,
                                 req->original_qiov->size);
         }
         req->original_cb(req->original_opaque, ret);
     }
     QLIST_REMOVE(req, list);
-    qemu_vfree(req->iov.iov_base);
+    qemu_vfree(qemu_iovec_buf(&req->qiov));
     g_free(req);
 }
 
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *ide_buffered_readv(IDEState *s, int64_t sector_num,
     req->original_qiov = iov;
     req->original_cb = cb;
     req->original_opaque = opaque;
-    req->iov.iov_base = qemu_blockalign(blk_bs(s->blk), iov->size);
-    req->iov.iov_len = iov->size;
-    qemu_iovec_init_external(&req->qiov, &req->iov, 1);
+    qemu_iovec_init_buf(&req->qiov, blk_blockalign(s->blk, iov->size),
+                        iov->size);
 
     aioreq = blk_aio_preadv(s->blk, sector_num << BDRV_SECTOR_BITS,
                             &req->qiov, 0, ide_buffered_readv_cb, req);
-- 
2.20.1

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

@iov is used only to initialize @qiov. Let's use new
qemu_iovec_init_buf() instead, which simplifies the code.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190218140926.333779-18-vsementsov@virtuozzo.com
Message-Id: <20190218140926.333779-18-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/ide/internal.h | 1 -
 hw/ide/atapi.c            | 5 ++---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/include/hw/ide/internal.h b/include/hw/ide/internal.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/ide/internal.h
+++ b/include/hw/ide/internal.h
@@ -XXX,XX +XXX,XX @@ struct IDEDMAOps {
 
 struct IDEDMA {
     const struct IDEDMAOps *ops;
-    struct iovec iov;
     QEMUIOVector qiov;
     BlockAIOCB *aiocb;
 };
diff --git a/hw/ide/atapi.c b/hw/ide/atapi.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ide/atapi.c
+++ b/hw/ide/atapi.c
@@ -XXX,XX +XXX,XX @@ static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
         data_offset = 0;
     }
     trace_ide_atapi_cmd_read_dma_cb_aio(s, s->lba, n);
-    s->bus->dma->iov.iov_base = (void *)(s->io_buffer + data_offset);
-    s->bus->dma->iov.iov_len = n * ATAPI_SECTOR_SIZE;
-    qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1);
+    qemu_iovec_init_buf(&s->bus->dma->qiov, s->io_buffer + data_offset,
+                        n * ATAPI_SECTOR_SIZE);
 
     s->bus->dma->aiocb = ide_buffered_readv(s, (int64_t)s->lba << 2,
                                             &s->bus->dma->qiov, n * 4,
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

We add acct_failed param in order to use virtio_blk_handle_rw_error()
also when is not required to call block_acct_failed(). (eg. a discard
operation is failed)

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-2-sgarzare@redhat.com
Message-Id: <20190221103314.58500-2-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/block/virtio-blk.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status)
 }
 
 static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
-    bool is_read)
+    bool is_read, bool acct_failed)
 {
     VirtIOBlock *s = req->dev;
     BlockErrorAction action = blk_get_error_action(s->blk, is_read, error);
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
         s->rq = req;
     } else if (action == BLOCK_ERROR_ACTION_REPORT) {
         virtio_blk_req_complete(req, VIRTIO_BLK_S_IOERR);
-        block_acct_failed(blk_get_stats(s->blk), &req->acct);
+        if (acct_failed) {
+            block_acct_failed(blk_get_stats(s->blk), &req->acct);
+        }
         virtio_blk_free_request(req);
     }
 
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_rw_complete(void *opaque, int ret)
              * the memory until the request is completed (which will
              * happen on the other side of the migration).
              */
-            if (virtio_blk_handle_rw_error(req, -ret, is_read)) {
+            if (virtio_blk_handle_rw_error(req, -ret, is_read, true)) {
                 continue;
             }
         }
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_flush_complete(void *opaque, int ret)
 
     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
     if (ret) {
-        if (virtio_blk_handle_rw_error(req, -ret, 0)) {
+        if (virtio_blk_handle_rw_error(req, -ret, 0, true)) {
             goto out;
         }
     }
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

Since configurable features for virtio-blk are growing, this patch
adds host_features field in the struct VirtIOBlock. (as in virtio-net)
In this way, we can avoid to add new fields for new properties and
we can directly set VIRTIO_BLK_F* flags in the host_features.

We update "config-wce" and "scsi" property definition to use the new
host_features field without change the behaviour.

Suggested-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-3-sgarzare@redhat.com
Message-Id: <20190221103314.58500-3-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/virtio/virtio-blk.h |  3 +--
 hw/block/virtio-blk.c          | 16 +++++++++-------
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/virtio/virtio-blk.h
+++ b/include/hw/virtio/virtio-blk.h
@@ -XXX,XX +XXX,XX @@ struct VirtIOBlkConf
     BlockConf conf;
     IOThread *iothread;
     char *serial;
-    uint32_t scsi;
-    uint32_t config_wce;
     uint32_t request_merging;
     uint16_t num_queues;
     uint16_t queue_size;
@@ -XXX,XX +XXX,XX @@ typedef struct VirtIOBlock {
     bool dataplane_disabled;
     bool dataplane_started;
     struct VirtIOBlockDataPlane *dataplane;
+    uint64_t host_features;
 } VirtIOBlock;
 
 typedef struct VirtIOBlockReq {
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_scsi_req(VirtIOBlockReq *req)
      */
     scsi = (void *)elem->in_sg[elem->in_num - 2].iov_base;
 
-    if (!blk->conf.scsi) {
+    if (!virtio_has_feature(blk->host_features, VIRTIO_BLK_F_SCSI)) {
         status = VIRTIO_BLK_S_UNSUPP;
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static uint64_t virtio_blk_get_features(VirtIODevice *vdev, uint64_t features,
 {
     VirtIOBlock *s = VIRTIO_BLK(vdev);
 
+    /* Firstly sync all virtio-blk possible supported features */
+    features |= s->host_features;
+
     virtio_add_feature(&features, VIRTIO_BLK_F_SEG_MAX);
     virtio_add_feature(&features, VIRTIO_BLK_F_GEOMETRY);
     virtio_add_feature(&features, VIRTIO_BLK_F_TOPOLOGY);
     virtio_add_feature(&features, VIRTIO_BLK_F_BLK_SIZE);
     if (virtio_has_feature(features, VIRTIO_F_VERSION_1)) {
-        if (s->conf.scsi) {
+        if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_SCSI)) {
             error_setg(errp, "Please set scsi=off for virtio-blk devices in order to use virtio 1.0");
             return 0;
         }
@@ -XXX,XX +XXX,XX @@ static uint64_t virtio_blk_get_features(VirtIODevice *vdev, uint64_t features,
         virtio_add_feature(&features, VIRTIO_BLK_F_SCSI);
     }
 
-    if (s->conf.config_wce) {
-        virtio_add_feature(&features, VIRTIO_BLK_F_CONFIG_WCE);
-    }
     if (blk_enable_write_cache(s->blk)) {
         virtio_add_feature(&features, VIRTIO_BLK_F_WCE);
     }
@@ -XXX,XX +XXX,XX @@ static Property virtio_blk_properties[] = {
     DEFINE_BLOCK_ERROR_PROPERTIES(VirtIOBlock, conf.conf),
     DEFINE_BLOCK_CHS_PROPERTIES(VirtIOBlock, conf.conf),
     DEFINE_PROP_STRING("serial", VirtIOBlock, conf.serial),
-    DEFINE_PROP_BIT("config-wce", VirtIOBlock, conf.config_wce, 0, true),
+    DEFINE_PROP_BIT64("config-wce", VirtIOBlock, host_features,
+                      VIRTIO_BLK_F_CONFIG_WCE, true),
 #ifdef __linux__
-    DEFINE_PROP_BIT("scsi", VirtIOBlock, conf.scsi, 0, false),
+    DEFINE_PROP_BIT64("scsi", VirtIOBlock, host_features,
+                      VIRTIO_BLK_F_SCSI, false),
 #endif
     DEFINE_PROP_BIT("request-merging", VirtIOBlock, conf.request_merging, 0,
                     true),
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

In order to avoid migration issues, we enable DISCARD and
WRITE_ZEROES features only for machine type >= 4.0

As discussed with Michael S. Tsirkin and Stefan Hajnoczi on the
list [1], DISCARD operation should not have security implications
(eg. page cache attacks), so we can enable it by default.

[1] https://lists.gnu.org/archive/html/qemu-devel/2019-02/msg00504.html

Suggested-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-4-sgarzare@redhat.com
Message-Id: <20190221103314.58500-4-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/block/virtio-blk.c | 4 ++++
 hw/core/machine.c     | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static Property virtio_blk_properties[] = {
     DEFINE_PROP_UINT16("queue-size", VirtIOBlock, conf.queue_size, 128),
     DEFINE_PROP_LINK("iothread", VirtIOBlock, conf.iothread, TYPE_IOTHREAD,
                      IOThread *),
+    DEFINE_PROP_BIT64("discard", VirtIOBlock, host_features,
+                      VIRTIO_BLK_F_DISCARD, true),
+    DEFINE_PROP_BIT64("write-zeroes", VirtIOBlock, host_features,
+                      VIRTIO_BLK_F_WRITE_ZEROES, true),
     DEFINE_PROP_END_OF_LIST(),
 };
 
diff --git a/hw/core/machine.c b/hw/core/machine.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/core/machine.c
+++ b/hw/core/machine.c
@@ -XXX,XX +XXX,XX @@ GlobalProperty hw_compat_3_1[] = {
     { "usb-kbd", "serial", "42" },
     { "usb-mouse", "serial", "42" },
     { "usb-kbd", "serial", "42" },
+    { "virtio-blk-device", "discard", "false" },
+    { "virtio-blk-device", "write-zeroes", "false" },
 };
 const size_t hw_compat_3_1_len = G_N_ELEMENTS(hw_compat_3_1);
 
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

In order to use VirtIOFeature also in other virtio devices, we move
its declaration and the endof() macro (renamed in virtio_endof())
in virtio.h.
We add virtio_feature_get_config_size() function to iterate the array
of VirtIOFeature and to return the config size depending on the
features enabled. (as virtio_net_set_config_size() did)

Suggested-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-5-sgarzare@redhat.com
Message-Id: <20190221103314.58500-5-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/virtio/virtio.h | 15 +++++++++++++++
 hw/net/virtio-net.c        | 31 +++++++------------------------
 hw/virtio/virtio.c         | 15 +++++++++++++++
 3 files changed, 37 insertions(+), 24 deletions(-)

diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/virtio/virtio.h
+++ b/include/hw/virtio/virtio.h
@@ -XXX,XX +XXX,XX @@ static inline hwaddr vring_align(hwaddr addr,
     return QEMU_ALIGN_UP(addr, align);
 }
 
+/*
+ * Calculate the number of bytes up to and including the given 'field' of
+ * 'container'.
+ */
+#define virtio_endof(container, field) \
+    (offsetof(container, field) + sizeof_field(container, field))
+
+typedef struct VirtIOFeature {
+    uint64_t flags;
+    size_t end;
+} VirtIOFeature;
+
+size_t virtio_feature_get_config_size(VirtIOFeature *features,
+                                      uint64_t host_features);
+
 typedef struct VirtQueue VirtQueue;
 
 #define VIRTQUEUE_MAX_SIZE 1024
diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/net/virtio-net.c
+++ b/hw/net/virtio-net.c
@@ -XXX,XX +XXX,XX @@ static inline __virtio16 *virtio_net_rsc_ext_num_dupacks(
 
 #endif
 
-/*
- * Calculate the number of bytes up to and including the given 'field' of
- * 'container'.
- */
-#define endof(container, field) \
-    (offsetof(container, field) + sizeof_field(container, field))
-
-typedef struct VirtIOFeature {
-    uint64_t flags;
-    size_t end;
-} VirtIOFeature;
-
 static VirtIOFeature feature_sizes[] = {
     {.flags = 1ULL << VIRTIO_NET_F_MAC,
-     .end = endof(struct virtio_net_config, mac)},
+     .end = virtio_endof(struct virtio_net_config, mac)},
     {.flags = 1ULL << VIRTIO_NET_F_STATUS,
-     .end = endof(struct virtio_net_config, status)},
+     .end = virtio_endof(struct virtio_net_config, status)},
     {.flags = 1ULL << VIRTIO_NET_F_MQ,
-     .end = endof(struct virtio_net_config, max_virtqueue_pairs)},
+     .end = virtio_endof(struct virtio_net_config, max_virtqueue_pairs)},
     {.flags = 1ULL << VIRTIO_NET_F_MTU,
-     .end = endof(struct virtio_net_config, mtu)},
+     .end = virtio_endof(struct virtio_net_config, mtu)},
     {.flags = 1ULL << VIRTIO_NET_F_SPEED_DUPLEX,
-     .end = endof(struct virtio_net_config, duplex)},
+     .end = virtio_endof(struct virtio_net_config, duplex)},
     {}
 };
 
@@ -XXX,XX +XXX,XX @@ static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
 
 static void virtio_net_set_config_size(VirtIONet *n, uint64_t host_features)
 {
-    int i, config_size = 0;
     virtio_add_feature(&host_features, VIRTIO_NET_F_MAC);
 
-    for (i = 0; feature_sizes[i].flags != 0; i++) {
-        if (host_features & feature_sizes[i].flags) {
-            config_size = MAX(feature_sizes[i].end, config_size);
-        }
-    }
-    n->config_size = config_size;
+    n->config_size = virtio_feature_get_config_size(feature_sizes,
+                                                    host_features);
 }
 
 void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/virtio.c
+++ b/hw/virtio/virtio.c
@@ -XXX,XX +XXX,XX @@ int virtio_set_features(VirtIODevice *vdev, uint64_t val)
     return ret;
 }
 
+size_t virtio_feature_get_config_size(VirtIOFeature *feature_sizes,
+                                      uint64_t host_features)
+{
+    size_t config_size = 0;
+    int i;
+
+    for (i = 0; feature_sizes[i].flags != 0; i++) {
+        if (host_features & feature_sizes[i].flags) {
+            config_size = MAX(feature_sizes[i].end, config_size);
+        }
+    }
+
+    return config_size;
+}
+
 int virtio_load(VirtIODevice *vdev, QEMUFile *f, int version_id)
 {
     int i, ret;
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

Starting from DISABLE and WRITE_ZEROES features, we use an array of
VirtIOFeature (as virtio-net) to properly set the config size
depending on the features enabled.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-6-sgarzare@redhat.com
Message-Id: <20190221103314.58500-6-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/virtio/virtio-blk.h |  1 +
 hw/block/virtio-blk.c          | 31 +++++++++++++++++++++++++------
 2 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/virtio/virtio-blk.h
+++ b/include/hw/virtio/virtio-blk.h
@@ -XXX,XX +XXX,XX @@ typedef struct VirtIOBlock {
     bool dataplane_started;
     struct VirtIOBlockDataPlane *dataplane;
     uint64_t host_features;
+    size_t config_size;
 } VirtIOBlock;
 
 typedef struct VirtIOBlockReq {
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@
 #include "hw/virtio/virtio-bus.h"
 #include "hw/virtio/virtio-access.h"
 
-/* We don't support discard yet, hide associated config fields. */
+/* Config size before the discard support (hide associated config fields) */
 #define VIRTIO_BLK_CFG_SIZE offsetof(struct virtio_blk_config, \
                                      max_discard_sectors)
+/*
+ * Starting from the discard feature, we can use this array to properly
+ * set the config size depending on the features enabled.
+ */
+static VirtIOFeature feature_sizes[] = {
+    {.flags = 1ULL << VIRTIO_BLK_F_DISCARD,
+     .end = virtio_endof(struct virtio_blk_config, discard_sector_alignment)},
+    {.flags = 1ULL << VIRTIO_BLK_F_WRITE_ZEROES,
+     .end = virtio_endof(struct virtio_blk_config, write_zeroes_may_unmap)},
+    {}
+};
+
+static void virtio_blk_set_config_size(VirtIOBlock *s, uint64_t host_features)
+{
+    s->config_size = MAX(VIRTIO_BLK_CFG_SIZE,
+        virtio_feature_get_config_size(feature_sizes, host_features));
+
+    assert(s->config_size <= sizeof(struct virtio_blk_config));
+}
 
 static void virtio_blk_init_request(VirtIOBlock *s, VirtQueue *vq,
                                     VirtIOBlockReq *req)
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
     blkcfg.alignment_offset = 0;
     blkcfg.wce = blk_enable_write_cache(s->blk);
     virtio_stw_p(vdev, &blkcfg.num_queues, s->conf.num_queues);
-    memcpy(config, &blkcfg, VIRTIO_BLK_CFG_SIZE);
-    QEMU_BUILD_BUG_ON(VIRTIO_BLK_CFG_SIZE > sizeof(blkcfg));
+    memcpy(config, &blkcfg, s->config_size);
 }
 
 static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_set_config(VirtIODevice *vdev, const uint8_t *config)
     VirtIOBlock *s = VIRTIO_BLK(vdev);
     struct virtio_blk_config blkcfg;
 
-    memcpy(&blkcfg, config, VIRTIO_BLK_CFG_SIZE);
-    QEMU_BUILD_BUG_ON(VIRTIO_BLK_CFG_SIZE > sizeof(blkcfg));
+    memcpy(&blkcfg, config, s->config_size);
 
     aio_context_acquire(blk_get_aio_context(s->blk));
     blk_set_enable_write_cache(s->blk, blkcfg.wce != 0);
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
         return;
     }
 
-    virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, VIRTIO_BLK_CFG_SIZE);
+    virtio_blk_set_config_size(s, s->host_features);
+
+    virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, s->config_size);
 
     s->blk = conf->conf.blk;
     s->rq = NULL;
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

This patch adds the support of DISCARD and WRITE_ZEROES commands,
that have been introduced in the virtio-blk protocol to have
better performance when using SSD backend.

We support only one segment per request since multiple segments
are not widely used and there are no userspace APIs that allow
applications to submit multiple segments in a single call.

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-7-sgarzare@redhat.com
Message-Id: <20190221103314.58500-7-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/virtio/virtio-blk.h |   2 +
 hw/block/virtio-blk.c          | 184 +++++++++++++++++++++++++++++++++
 2 files changed, 186 insertions(+)

diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/virtio/virtio-blk.h
+++ b/include/hw/virtio/virtio-blk.h
@@ -XXX,XX +XXX,XX @@ struct VirtIOBlkConf
     uint32_t request_merging;
     uint16_t num_queues;
     uint16_t queue_size;
+    uint32_t max_discard_sectors;
+    uint32_t max_write_zeroes_sectors;
 };
 
 struct VirtIOBlockDataPlane;
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ out:
     aio_context_release(blk_get_aio_context(s->conf.conf.blk));
 }
 
+static void virtio_blk_discard_write_zeroes_complete(void *opaque, int ret)
+{
+    VirtIOBlockReq *req = opaque;
+    VirtIOBlock *s = req->dev;
+    bool is_write_zeroes = (virtio_ldl_p(VIRTIO_DEVICE(s), &req->out.type) &
+                            ~VIRTIO_BLK_T_BARRIER) == VIRTIO_BLK_T_WRITE_ZEROES;
+
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
+    if (ret) {
+        if (virtio_blk_handle_rw_error(req, -ret, false, is_write_zeroes)) {
+            goto out;
+        }
+    }
+
+    virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
+    if (is_write_zeroes) {
+        block_acct_done(blk_get_stats(s->blk), &req->acct);
+    }
+    virtio_blk_free_request(req);
+
+out:
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
+}
+
 #ifdef __linux__
 
 typedef struct {
@@ -XXX,XX +XXX,XX @@ static bool virtio_blk_sect_range_ok(VirtIOBlock *dev,
     return true;
 }
 
+static uint8_t virtio_blk_handle_discard_write_zeroes(VirtIOBlockReq *req,
+    struct virtio_blk_discard_write_zeroes *dwz_hdr, bool is_write_zeroes)
+{
+    VirtIOBlock *s = req->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
+    uint64_t sector;
+    uint32_t num_sectors, flags, max_sectors;
+    uint8_t err_status;
+    int bytes;
+
+    sector = virtio_ldq_p(vdev, &dwz_hdr->sector);
+    num_sectors = virtio_ldl_p(vdev, &dwz_hdr->num_sectors);
+    flags = virtio_ldl_p(vdev, &dwz_hdr->flags);
+    max_sectors = is_write_zeroes ? s->conf.max_write_zeroes_sectors :
+                  s->conf.max_discard_sectors;
+
+    /*
+     * max_sectors is at most BDRV_REQUEST_MAX_SECTORS, this check
+     * make us sure that "num_sectors << BDRV_SECTOR_BITS" can fit in
+     * the integer variable.
+     */
+    if (unlikely(num_sectors > max_sectors)) {
+        err_status = VIRTIO_BLK_S_IOERR;
+        goto err;
+    }
+
+    bytes = num_sectors << BDRV_SECTOR_BITS;
+
+    if (unlikely(!virtio_blk_sect_range_ok(s, sector, bytes))) {
+        err_status = VIRTIO_BLK_S_IOERR;
+        goto err;
+    }
+
+    /*
+     * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for discard
+     * and write zeroes commands if any unknown flag is set.
+     */
+    if (unlikely(flags & ~VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
+        err_status = VIRTIO_BLK_S_UNSUPP;
+        goto err;
+    }
+
+    if (is_write_zeroes) { /* VIRTIO_BLK_T_WRITE_ZEROES */
+        int blk_aio_flags = 0;
+
+        if (flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP) {
+            blk_aio_flags |= BDRV_REQ_MAY_UNMAP;
+        }
+
+        block_acct_start(blk_get_stats(s->blk), &req->acct, bytes,
+                         BLOCK_ACCT_WRITE);
+
+        blk_aio_pwrite_zeroes(s->blk, sector << BDRV_SECTOR_BITS,
+                              bytes, blk_aio_flags,
+                              virtio_blk_discard_write_zeroes_complete, req);
+    } else { /* VIRTIO_BLK_T_DISCARD */
+        /*
+         * The device MUST set the status byte to VIRTIO_BLK_S_UNSUPP for
+         * discard commands if the unmap flag is set.
+         */
+        if (unlikely(flags & VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP)) {
+            err_status = VIRTIO_BLK_S_UNSUPP;
+            goto err;
+        }
+
+        blk_aio_pdiscard(s->blk, sector << BDRV_SECTOR_BITS, bytes,
+                         virtio_blk_discard_write_zeroes_complete, req);
+    }
+
+    return VIRTIO_BLK_S_OK;
+
+err:
+    if (is_write_zeroes) {
+        block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_WRITE);
+    }
+    return err_status;
+}
+
 static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
 {
     uint32_t type;
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
         virtio_blk_free_request(req);
         break;
     }
+    /*
+     * VIRTIO_BLK_T_DISCARD and VIRTIO_BLK_T_WRITE_ZEROES are defined with
+     * VIRTIO_BLK_T_OUT flag set. We masked this flag in the switch statement,
+     * so we must mask it for these requests, then we will check if it is set.
+     */
+    case VIRTIO_BLK_T_DISCARD & ~VIRTIO_BLK_T_OUT:
+    case VIRTIO_BLK_T_WRITE_ZEROES & ~VIRTIO_BLK_T_OUT:
+    {
+        struct virtio_blk_discard_write_zeroes dwz_hdr;
+        size_t out_len = iov_size(out_iov, out_num);
+        bool is_write_zeroes = (type & ~VIRTIO_BLK_T_BARRIER) ==
+                               VIRTIO_BLK_T_WRITE_ZEROES;
+        uint8_t err_status;
+
+        /*
+         * Unsupported if VIRTIO_BLK_T_OUT is not set or the request contains
+         * more than one segment.
+         */
+        if (unlikely(!(type & VIRTIO_BLK_T_OUT) ||
+                     out_len > sizeof(dwz_hdr))) {
+            virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
+            virtio_blk_free_request(req);
+            return 0;
+        }
+
+        if (unlikely(iov_to_buf(out_iov, out_num, 0, &dwz_hdr,
+                                sizeof(dwz_hdr)) != sizeof(dwz_hdr))) {
+            virtio_error(vdev, "virtio-blk discard/write_zeroes header"
+                         " too short");
+            return -1;
+        }
+
+        err_status = virtio_blk_handle_discard_write_zeroes(req, &dwz_hdr,
+                                                            is_write_zeroes);
+        if (err_status != VIRTIO_BLK_S_OK) {
+            virtio_blk_req_complete(req, err_status);
+            virtio_blk_free_request(req);
+        }
+
+        break;
+    }
     default:
         virtio_blk_req_complete(req, VIRTIO_BLK_S_UNSUPP);
         virtio_blk_free_request(req);
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
     blkcfg.alignment_offset = 0;
     blkcfg.wce = blk_enable_write_cache(s->blk);
     virtio_stw_p(vdev, &blkcfg.num_queues, s->conf.num_queues);
+    if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD)) {
+        virtio_stl_p(vdev, &blkcfg.max_discard_sectors,
+                     s->conf.max_discard_sectors);
+        virtio_stl_p(vdev, &blkcfg.discard_sector_alignment,
+                     blk_size >> BDRV_SECTOR_BITS);
+        /*
+         * We support only one segment per request since multiple segments
+         * are not widely used and there are no userspace APIs that allow
+         * applications to submit multiple segments in a single call.
+         */
+        virtio_stl_p(vdev, &blkcfg.max_discard_seg, 1);
+    }
+    if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES)) {
+        virtio_stl_p(vdev, &blkcfg.max_write_zeroes_sectors,
+                     s->conf.max_write_zeroes_sectors);
+        blkcfg.write_zeroes_may_unmap = 1;
+        virtio_stl_p(vdev, &blkcfg.max_write_zeroes_seg, 1);
+    }
     memcpy(config, &blkcfg, s->config_size);
 }
 
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
         return;
     }
 
+    if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD) &&
+        (!conf->max_discard_sectors ||
+         conf->max_discard_sectors > BDRV_REQUEST_MAX_SECTORS)) {
+        error_setg(errp, "invalid max-discard-sectors property (%" PRIu32 ")"
+                   ", must be between 1 and %d",
+                   conf->max_discard_sectors, (int)BDRV_REQUEST_MAX_SECTORS);
+        return;
+    }
+
+    if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_WRITE_ZEROES) &&
+        (!conf->max_write_zeroes_sectors ||
+         conf->max_write_zeroes_sectors > BDRV_REQUEST_MAX_SECTORS)) {
+        error_setg(errp, "invalid max-write-zeroes-sectors property (%" PRIu32
+                   "), must be between 1 and %d",
+                   conf->max_write_zeroes_sectors,
+                   (int)BDRV_REQUEST_MAX_SECTORS);
+        return;
+    }
+
     virtio_blk_set_config_size(s, s->host_features);
 
     virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, s->config_size);
@@ -XXX,XX +XXX,XX @@ static Property virtio_blk_properties[] = {
                       VIRTIO_BLK_F_DISCARD, true),
     DEFINE_PROP_BIT64("write-zeroes", VirtIOBlock, host_features,
                       VIRTIO_BLK_F_WRITE_ZEROES, true),
+    DEFINE_PROP_UINT32("max-discard-sectors", VirtIOBlock,
+                       conf.max_discard_sectors, BDRV_REQUEST_MAX_SECTORS),
+    DEFINE_PROP_UINT32("max-write-zeroes-sectors", VirtIOBlock,
+                       conf.max_write_zeroes_sectors, BDRV_REQUEST_MAX_SECTORS),
     DEFINE_PROP_END_OF_LIST(),
 };
 
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

The size of data in the virtio_blk_request must be a multiple
of 512 bytes for IN and OUT requests, or a multiple of the size
of struct virtio_blk_discard_write_zeroes for DISCARD and
WRITE_ZEROES requests.

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-8-sgarzare@redhat.com
Message-Id: <20190221103314.58500-8-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/virtio-blk-test.c | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/virtio-blk-test.c
+++ b/tests/virtio-blk-test.c
@@ -XXX,XX +XXX,XX @@ static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d,
     uint64_t addr;
     uint8_t status = 0xFF;
 
-    g_assert_cmpuint(data_size % 512, ==, 0);
+    switch (req->type) {
+    case VIRTIO_BLK_T_IN:
+    case VIRTIO_BLK_T_OUT:
+        g_assert_cmpuint(data_size % 512, ==, 0);
+        break;
+    case VIRTIO_BLK_T_DISCARD:
+    case VIRTIO_BLK_T_WRITE_ZEROES:
+        g_assert_cmpuint(data_size %
+                         sizeof(struct virtio_blk_discard_write_zeroes), ==, 0);
+        break;
+    default:
+        g_assert_cmpuint(data_size, ==, 0);
+    }
+
     addr = guest_alloc(alloc, sizeof(*req) + data_size);
 
     virtio_blk_fix_request(d, req);
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

This function is useful to fix the endianness of struct
virtio_blk_discard_write_zeroes headers.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-9-sgarzare@redhat.com
Message-Id: <20190221103314.58500-9-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/virtio-blk-test.c | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/virtio-blk-test.c
+++ b/tests/virtio-blk-test.c
@@ -XXX,XX +XXX,XX @@ typedef struct QVirtioBlkReq {
     uint8_t status;
 } QVirtioBlkReq;
 
+#ifdef HOST_WORDS_BIGENDIAN
+const bool host_is_big_endian = true;
+#else
+const bool host_is_big_endian; /* false */
+#endif
+
 static char *drive_create(void)
 {
     int fd, ret;
@@ -XXX,XX +XXX,XX @@ static QVirtioPCIDevice *virtio_blk_pci_init(QPCIBus *bus, int slot)
 
 static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req)
 {
-#ifdef HOST_WORDS_BIGENDIAN
-    const bool host_is_big_endian = true;
-#else
-    const bool host_is_big_endian = false;
-#endif
-
     if (qvirtio_is_big_endian(d) != host_is_big_endian) {
         req->type = bswap32(req->type);
         req->ioprio = bswap32(req->ioprio);
@@ -XXX,XX +XXX,XX @@ static inline void virtio_blk_fix_request(QVirtioDevice *d, QVirtioBlkReq *req)
     }
 }
 
+
+static inline void virtio_blk_fix_dwz_hdr(QVirtioDevice *d,
+    struct virtio_blk_discard_write_zeroes *dwz_hdr)
+{
+    if (qvirtio_is_big_endian(d) != host_is_big_endian) {
+        dwz_hdr->sector = bswap64(dwz_hdr->sector);
+        dwz_hdr->num_sectors = bswap32(dwz_hdr->num_sectors);
+        dwz_hdr->flags = bswap32(dwz_hdr->flags);
+    }
+}
+
 static uint64_t virtio_blk_request(QGuestAllocator *alloc, QVirtioDevice *d,
                                    QVirtioBlkReq *req, uint64_t data_size)
 {
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

If the WRITE_ZEROES feature is enabled, we check this command
in the test_basic().

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-10-sgarzare@redhat.com
Message-Id: <20190221103314.58500-10-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/virtio-blk-test.c | 62 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/virtio-blk-test.c
+++ b/tests/virtio-blk-test.c
@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
 
     guest_free(alloc, req_addr);
 
+    if (features & (1u << VIRTIO_BLK_F_WRITE_ZEROES)) {
+        struct virtio_blk_discard_write_zeroes dwz_hdr;
+        void *expected;
+
+        /*
+         * WRITE_ZEROES request on the same sector of previous test where
+         * we wrote "TEST".
+         */
+        req.type = VIRTIO_BLK_T_WRITE_ZEROES;
+        req.data = (char *) &dwz_hdr;
+        dwz_hdr.sector = 0;
+        dwz_hdr.num_sectors = 1;
+        dwz_hdr.flags = 0;
+
+        virtio_blk_fix_dwz_hdr(dev, &dwz_hdr);
+
+        req_addr = virtio_blk_request(alloc, dev, &req, sizeof(dwz_hdr));
+
+        free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
+        qvirtqueue_add(vq, req_addr + 16, sizeof(dwz_hdr), false, true);
+        qvirtqueue_add(vq, req_addr + 16 + sizeof(dwz_hdr), 1, true, false);
+
+        qvirtqueue_kick(dev, vq, free_head);
+
+        qvirtio_wait_used_elem(dev, vq, free_head, NULL,
+                               QVIRTIO_BLK_TIMEOUT_US);
+        status = readb(req_addr + 16 + sizeof(dwz_hdr));
+        g_assert_cmpint(status, ==, 0);
+
+        guest_free(alloc, req_addr);
+
+        /* Read request to check if the sector contains all zeroes */
+        req.type = VIRTIO_BLK_T_IN;
+        req.ioprio = 1;
+        req.sector = 0;
+        req.data = g_malloc0(512);
+
+        req_addr = virtio_blk_request(alloc, dev, &req, 512);
+
+        g_free(req.data);
+
+        free_head = qvirtqueue_add(vq, req_addr, 16, false, true);
+        qvirtqueue_add(vq, req_addr + 16, 512, true, true);
+        qvirtqueue_add(vq, req_addr + 528, 1, true, false);
+
+        qvirtqueue_kick(dev, vq, free_head);
+
+        qvirtio_wait_used_elem(dev, vq, free_head, NULL,
+                               QVIRTIO_BLK_TIMEOUT_US);
+        status = readb(req_addr + 528);
+        g_assert_cmpint(status, ==, 0);
+
+        data = g_malloc(512);
+        expected = g_malloc0(512);
+        memread(req_addr + 16, data, 512);
+        g_assert_cmpmem(data, 512, expected, 512);
+        g_free(expected);
+        g_free(data);
+
+        guest_free(alloc, req_addr);
+    }
+
     if (features & (1u << VIRTIO_F_ANY_LAYOUT)) {
         /* Write and read with 2 descriptor layout */
         /* Write request */
-- 
2.20.1

From: Stefano Garzarella <sgarzare@redhat.com>

If the DISCARD feature is enabled, we try this command in the
test_basic(), checking only the status returned by the request.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20190221103314.58500-11-sgarzare@redhat.com
Message-Id: <20190221103314.58500-11-sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/virtio-blk-test.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)