Series comparison

-[Qemu-devel] [PULL 0/2] Block patches
+[PULL 00/11] Block patches
-The following changes since commit 577caa2672ccde7352fda3ef17e44993de862f0e:
+The following changes since commit 88afdc92b644120e0182c8567e1b1d236e471b12:
-  Merge remote-tracking branch 'remotes/edgar/tags/edgar/mmio-exec-v2.for-upstream' into staging (2017-06-27 16:56:55 +0100)
+  Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging (2021-09-05 15:48:42 +0100)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 439778e6b4a20c8fe6a6a92a17013b09c4ae55d0:
+for you to fetch changes up to 9bd2788f49c331b02372cc257b11e4c984d39708:
-  virtio-pci: use ioeventfd even when KVM is disabled (2017-06-28 13:18:53 +0100)
+  block/nvme: Only report VFIO error on failed retry (2021-09-07 09:08:24 +0100)
 ----------------------------------------------------------------
 Pull request
 Userspace NVMe driver patches.
 ----------------------------------------------------------------
-----------------------------------------------------------------
+Philippe Mathieu-Daudé (11):
   block/nvme: Use safer trace format string
   util/vfio-helpers: Let qemu_vfio_verify_mappings() use error_report()
   util/vfio-helpers: Replace qemu_mutex_lock() calls with
     QEMU_LOCK_GUARD
   util/vfio-helpers: Remove unreachable code in qemu_vfio_dma_map()
   block/nvme: Have nvme_create_queue_pair() report errors consistently
   util/vfio-helpers: Pass Error handle to qemu_vfio_dma_map()
   util/vfio-helpers: Extract qemu_vfio_water_mark_reached()
   util/vfio-helpers: Use error_setg in qemu_vfio_find_[fixed/temp]_iova
   util/vfio-helpers: Simplify qemu_vfio_dma_map() returning directly
   util/vfio-helpers: Let qemu_vfio_do_mapping() propagate Error
   block/nvme: Only report VFIO error on failed retry
-Stefan Hajnoczi (2):
+ include/qemu/vfio-helpers.h |  2 +-
-  virtio-blk: trace vdev so devices can be distinguished
+ block/nvme.c                | 29 +++++++----
-  virtio-pci: use ioeventfd even when KVM is disabled
+ util/vfio-helpers.c         | 99 ++++++++++++++++++++-----------------
+ block/trace-events          |  2 +-
- hw/block/virtio-blk.c  | 12 +++++++-----
+files changed, 76 insertions(+), 56 deletions(-)
  hw/virtio/virtio-pci.c |  2 +-
  hw/block/trace-events  | 10 +++++-----
 files changed, 13 insertions(+), 11 deletions(-)
 --
-.9.4
+.31.1

-New patch
+[PULL 01/11] block/nvme: Use safer trace format string
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+Fix when building with -Wshorten-64-to-32:
+  warning: implicit conversion loses integer precision: 'unsigned long' to 'int' [-Wshorten-64-to-32]
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-2-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/trace-events | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+diff --git a/block/trace-events b/block/trace-events
+index XXXXXXX..XXXXXXX 100644
+--- a/block/trace-events
++++ b/block/trace-events
+@@ -XXX,XX +XXX,XX @@ nvme_dsm(void *s, uint64_t offset, uint64_t bytes) "s %p offset 0x%"PRIx64" byte
+ nvme_dsm_done(void *s, uint64_t offset, uint64_t bytes, int ret) "s %p offset 0x%"PRIx64" bytes %"PRId64" ret %d"
+ nvme_dma_map_flush(void *s) "s %p"
+ nvme_free_req_queue_wait(void *s, unsigned q_index) "s %p q #%u"
+-nvme_create_queue_pair(unsigned q_index, void *q, unsigned size, void *aio_context, int fd) "index %u q %p size %u aioctx %p fd %d"
++nvme_create_queue_pair(unsigned q_index, void *q, size_t size, void *aio_context, int fd) "index %u q %p size %zu aioctx %p fd %d"
+ nvme_free_queue_pair(unsigned q_index, void *q) "index %u q %p"
+ nvme_cmd_map_qiov(void *s, void *cmd, void *req, void *qiov, int entries) "s %p cmd %p req %p qiov %p entries %d"
+ nvme_cmd_map_qiov_pages(void *s, int i, uint64_t page) "s %p page[%d] 0x%"PRIx64
+--
+.31.1

-New patch
+[PULL 02/11] util/vfio-helpers: Let qemu_vfio_verify_mappings() use error_report()
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+Instead of displaying the error on stderr, use error_report()
+which also report to the monitor.
+Reviewed-by: Fam Zheng <fam@euphon.net>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-3-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vfio-helpers.c | 4 ++--
+file changed, 2 insertions(+), 2 deletions(-)
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/vfio-helpers.c
++++ b/util/vfio-helpers.c
+@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
+     if (QEMU_VFIO_DEBUG) {
+         for (i = 0; i < s->nr_mappings - 1; ++i) {
+             if (!(s->mappings[i].host < s->mappings[i + 1].host)) {
+-                fprintf(stderr, "item %d not sorted!\n", i);
++                error_report("item %d not sorted!", i);
+                 qemu_vfio_dump_mappings(s);
+                 return false;
+             }
+             if (!(s->mappings[i].host + s->mappings[i].size <=
+                   s->mappings[i + 1].host)) {
+-                fprintf(stderr, "item %d overlap with next!\n", i);
++                error_report("item %d overlap with next!", i);
+                 qemu_vfio_dump_mappings(s);
+                 return false;
+             }
+--
+.31.1

-New patch
+[PULL 03/11] util/vfio-helpers: Replace qemu_mutex_lock() calls with QEMU_LOCK_GUARD
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+Simplify qemu_vfio_dma_[un]map() handlers by replacing a pair of
+qemu_mutex_lock/qemu_mutex_unlock calls by the WITH_QEMU_LOCK_GUARD
+macro.
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-4-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vfio-helpers.c | 9 +++------
+file changed, 3 insertions(+), 6 deletions(-)
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/vfio-helpers.c
++++ b/util/vfio-helpers.c
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+     assert(QEMU_PTR_IS_ALIGNED(host, qemu_real_host_page_size));
+     assert(QEMU_IS_ALIGNED(size, qemu_real_host_page_size));
+     trace_qemu_vfio_dma_map(s, host, size, temporary, iova);
+-    qemu_mutex_lock(&s->lock);
++    QEMU_LOCK_GUARD(&s->lock);
+     mapping = qemu_vfio_find_mapping(s, host, &index);
+     if (mapping) {
+         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+         *iova = iova0;
+     }
+ out:
+-    qemu_mutex_unlock(&s->lock);
+     return ret;
+ }
+@@ -XXX,XX +XXX,XX @@ void qemu_vfio_dma_unmap(QEMUVFIOState *s, void *host)
+     }
+     trace_qemu_vfio_dma_unmap(s, host);
+-    qemu_mutex_lock(&s->lock);
++    QEMU_LOCK_GUARD(&s->lock);
+     m = qemu_vfio_find_mapping(s, host, &index);
+     if (!m) {
+-        goto out;
++        return;
+     }
+     qemu_vfio_undo_mapping(s, m, NULL);
+-out:
+-    qemu_mutex_unlock(&s->lock);
+ }
+ static void qemu_vfio_reset(QEMUVFIOState *s)
+--
+.31.1

-New patch
+[PULL 04/11] util/vfio-helpers: Remove unreachable code in qemu_vfio_dma_map()
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+qemu_vfio_add_mapping() returns a pointer to an indexed entry
+in pre-allocated QEMUVFIOState::mappings[], thus can not be NULL.
+Remove the pointless check.
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-5-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vfio-helpers.c | 4 ----
+file changed, 4 deletions(-)
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/vfio-helpers.c
++++ b/util/vfio-helpers.c
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+             }
+             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
+-            if (!mapping) {
+-                ret = -ENOMEM;
+-                goto out;
+-            }
+             assert(qemu_vfio_verify_mappings(s));
+             ret = qemu_vfio_do_mapping(s, host, size, iova0);
+             if (ret) {
+--
+.31.1

-New patch
+[PULL 05/11] block/nvme: Have nvme_create_queue_pair() report errors consistently
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+nvme_create_queue_pair() does not return a boolean value (indicating
+eventual error) but a pointer, and is inconsistent in how it fills the
+error handler. To fulfill callers expectations, always set an error
+message on failure.
+Reported-by: Auger Eric <eric.auger@redhat.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-6-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/nvme.c | 3 +++
+file changed, 3 insertions(+)
+diff --git a/block/nvme.c b/block/nvme.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/nvme.c
++++ b/block/nvme.c
+@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
+     q = g_try_new0(NVMeQueuePair, 1);
+     if (!q) {
++        error_setg(errp, "Cannot allocate queue pair");
+         return NULL;
+     }
+     trace_nvme_create_queue_pair(idx, q, size, aio_context,
+@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
+                           qemu_real_host_page_size);
+     q->prp_list_pages = qemu_try_memalign(qemu_real_host_page_size, bytes);
+     if (!q->prp_list_pages) {
++        error_setg(errp, "Cannot allocate PRP page list");
+         goto fail;
+     }
+     memset(q->prp_list_pages, 0, bytes);
+@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
+     r = qemu_vfio_dma_map(s->vfio, q->prp_list_pages, bytes,
+                           false, &prp_list_iova);
+     if (r) {
++        error_setg_errno(errp, -r, "Cannot map buffer for DMA");
+         goto fail;
+     }
+     q->free_req_head = -1;
+--
+.31.1

-New patch
+[PULL 06/11] util/vfio-helpers: Pass Error handle to qemu_vfio_dma_map()
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+Currently qemu_vfio_dma_map() displays errors on stderr.
+When using management interface, this information is simply
+lost. Pass qemu_vfio_dma_map() an Error** handle so it can
+propagate the error to callers.
+Reviewed-by: Fam Zheng <fam@euphon.net>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-7-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ include/qemu/vfio-helpers.h |  2 +-
+ block/nvme.c                | 22 +++++++++++-----------
+ util/vfio-helpers.c         | 10 ++++++----
+files changed, 18 insertions(+), 16 deletions(-)
+diff --git a/include/qemu/vfio-helpers.h b/include/qemu/vfio-helpers.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/qemu/vfio-helpers.h
++++ b/include/qemu/vfio-helpers.h
+@@ -XXX,XX +XXX,XX @@ typedef struct QEMUVFIOState QEMUVFIOState;
+ QEMUVFIOState *qemu_vfio_open_pci(const char *device, Error **errp);
+ void qemu_vfio_close(QEMUVFIOState *s);
+ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+-                      bool temporary, uint64_t *iova_list);
++                      bool temporary, uint64_t *iova_list, Error **errp);
+ int qemu_vfio_dma_reset_temporary(QEMUVFIOState *s);
+ void qemu_vfio_dma_unmap(QEMUVFIOState *s, void *host);
+ void *qemu_vfio_pci_map_bar(QEMUVFIOState *s, int index,
+diff --git a/block/nvme.c b/block/nvme.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/nvme.c
++++ b/block/nvme.c
+@@ -XXX,XX +XXX,XX @@ static bool nvme_init_queue(BDRVNVMeState *s, NVMeQueue *q,
+         return false;
+     }
+     memset(q->queue, 0, bytes);
+-    r = qemu_vfio_dma_map(s->vfio, q->queue, bytes, false, &q->iova);
++    r = qemu_vfio_dma_map(s->vfio, q->queue, bytes, false, &q->iova, errp);
+     if (r) {
+-        error_setg(errp, "Cannot map queue");
+-        return false;
++        error_prepend(errp, "Cannot map queue: ");
+     }
+-    return true;
++    return r == 0;
+ }
+ static void nvme_free_queue_pair(NVMeQueuePair *q)
+@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
+     qemu_co_queue_init(&q->free_req_queue);
+     q->completion_bh = aio_bh_new(aio_context, nvme_process_completion_bh, q);
+     r = qemu_vfio_dma_map(s->vfio, q->prp_list_pages, bytes,
+-                          false, &prp_list_iova);
++                          false, &prp_list_iova, errp);
+     if (r) {
+-        error_setg_errno(errp, -r, "Cannot map buffer for DMA");
++        error_prepend(errp, "Cannot map buffer for DMA: ");
+         goto fail;
+     }
+     q->free_req_head = -1;
+@@ -XXX,XX +XXX,XX @@ static bool nvme_identify(BlockDriverState *bs, int namespace, Error **errp)
+         error_setg(errp, "Cannot allocate buffer for identify response");
+         goto out;
+     }
+-    r = qemu_vfio_dma_map(s->vfio, id, id_size, true, &iova);
++    r = qemu_vfio_dma_map(s->vfio, id, id_size, true, &iova, errp);
+     if (r) {
+-        error_setg(errp, "Cannot map buffer for DMA");
++        error_prepend(errp, "Cannot map buffer for DMA: ");
+         goto out;
+     }
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
+ try_map:
+         r = qemu_vfio_dma_map(s->vfio,
+                               qiov->iov[i].iov_base,
+-                              len, true, &iova);
++                              len, true, &iova, NULL);
+         if (r == -ENOSPC) {
+             /*
+              * In addition to the -ENOMEM error, the VFIO_IOMMU_MAP_DMA
+@@ -XXX,XX +XXX,XX @@ static void nvme_aio_unplug(BlockDriverState *bs)
+ static void nvme_register_buf(BlockDriverState *bs, void *host, size_t size)
+ {
+     int ret;
++    Error *local_err = NULL;
+     BDRVNVMeState *s = bs->opaque;
+-    ret = qemu_vfio_dma_map(s->vfio, host, size, false, NULL);
++    ret = qemu_vfio_dma_map(s->vfio, host, size, false, NULL, &local_err);
+     if (ret) {
+         /* FIXME: we may run out of IOVA addresses after repeated
+          * bdrv_register_buf/bdrv_unregister_buf, because nvme_vfio_dma_unmap
+          * doesn't reclaim addresses for fixed mappings. */
+-        error_report("nvme_register_buf failed: %s", strerror(-ret));
++        error_reportf_err(local_err, "nvme_register_buf failed: ");
+     }
+ }
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/vfio-helpers.c
++++ b/util/vfio-helpers.c
+@@ -XXX,XX +XXX,XX @@ static void qemu_vfio_ram_block_added(RAMBlockNotifier *n, void *host,
+                                       size_t size, size_t max_size)
+ {
+     QEMUVFIOState *s = container_of(n, QEMUVFIOState, ram_notifier);
++    Error *local_err = NULL;
+     int ret;
+     trace_qemu_vfio_ram_block_added(s, host, max_size);
+-    ret = qemu_vfio_dma_map(s, host, max_size, false, NULL);
++    ret = qemu_vfio_dma_map(s, host, max_size, false, NULL, &local_err);
+     if (ret) {
+-        error_report("qemu_vfio_dma_map(%p, %zu) failed: %s", host, max_size,
+-                     strerror(-ret));
++        error_reportf_err(local_err,
++                          "qemu_vfio_dma_map(%p, %zu) failed: ",
++                          host, max_size);
+     }
+ }
+@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
+  * mapping status within this area is not allowed).
+  */
+ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+-                      bool temporary, uint64_t *iova)
++                      bool temporary, uint64_t *iova, Error **errp)
+ {
+     int ret = 0;
+     int index;
+--
+.31.1

-New patch
+[PULL 07/11] util/vfio-helpers: Extract qemu_vfio_water_mark_reached()
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+Extract qemu_vfio_water_mark_reached() for readability,
+and have it provide an error hint it its Error* handle.
+Suggested-by: Klaus Jensen <k.jensen@samsung.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-8-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vfio-helpers.c | 17 ++++++++++++++++-
+file changed, 16 insertions(+), 1 deletion(-)
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/vfio-helpers.c
++++ b/util/vfio-helpers.c
+@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
+     return -ENOMEM;
+ }
++/**
++ * qemu_vfio_water_mark_reached:
++ *
++ * Returns %true if high watermark has been reached, %false otherwise.
++ */
++static bool qemu_vfio_water_mark_reached(QEMUVFIOState *s, size_t size,
++                                         Error **errp)
++{
++    if (s->high_water_mark - s->low_water_mark + 1 < size) {
++        error_setg(errp, "iova exhausted (water mark reached)");
++        return true;
++    }
++    return false;
++}
++
+ /* Map [host, host + size) area into a contiguous IOVA address space, and store
+  * the result in @iova if not NULL. The caller need to make sure the area is
+  * aligned to page size, and mustn't overlap with existing mapping areas (split
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+     if (mapping) {
+         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
+     } else {
+-        if (s->high_water_mark - s->low_water_mark + 1 < size) {
++        if (qemu_vfio_water_mark_reached(s, size, errp)) {
+             ret = -ENOMEM;
+             goto out;
+         }
+--
+.31.1

-New patch
+[PULL 08/11] util/vfio-helpers: Use error_setg in qemu_vfio_find_[fixed/temp]_iova
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+Both qemu_vfio_find_fixed_iova() and qemu_vfio_find_temp_iova()
+return an errno which is unused (or overwritten). Have them propagate
+eventual errors to callers, returning a boolean (which is what the
+Error API recommends, see commit e3fe3988d78 "error: Document Error
+API usage rules" for rationale).
+Suggested-by: Klaus Jensen <k.jensen@samsung.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-9-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vfio-helpers.c | 24 ++++++++++++++----------
+file changed, 14 insertions(+), 10 deletions(-)
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/vfio-helpers.c
++++ b/util/vfio-helpers.c
+@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
+     return true;
+ }
+-static int
+-qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
++static bool qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size,
++                                      uint64_t *iova, Error **errp)
+ {
+     int i;
+@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
+             s->usable_iova_ranges[i].end - s->low_water_mark + 1 == 0) {
+             *iova = s->low_water_mark;
+             s->low_water_mark += size;
+-            return 0;
++            return true;
+         }
+     }
+-    return -ENOMEM;
++    error_setg(errp, "fixed iova range not found");
++
++    return false;
+ }
+-static int
+-qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
++static bool qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size,
++                                     uint64_t *iova, Error **errp)
+ {
+     int i;
+@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
+             s->high_water_mark - s->usable_iova_ranges[i].start + 1 == 0) {
+             *iova = s->high_water_mark - size;
+             s->high_water_mark = *iova;
+-            return 0;
++            return true;
+         }
+     }
+-    return -ENOMEM;
++    error_setg(errp, "temporary iova range not found");
++
++    return false;
+ }
+ /**
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+             goto out;
+         }
+         if (!temporary) {
+-            if (qemu_vfio_find_fixed_iova(s, size, &iova0)) {
++            if (!qemu_vfio_find_fixed_iova(s, size, &iova0, errp)) {
+                 ret = -ENOMEM;
+                 goto out;
+             }
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+             }
+             qemu_vfio_dump_mappings(s);
+         } else {
+-            if (qemu_vfio_find_temp_iova(s, size, &iova0)) {
++            if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
+                 ret = -ENOMEM;
+                 goto out;
+             }
+--
+.31.1

-New patch
+[PULL 09/11] util/vfio-helpers: Simplify qemu_vfio_dma_map() returning directly
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
+To simplify qemu_vfio_dma_map():
+- reduce 'ret' (returned value) scope by returning errno directly,
+- remove the goto 'out' label.
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-id: 20210902070025.197072-10-philmd@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vfio-helpers.c | 23 ++++++++++-------------
+file changed, 10 insertions(+), 13 deletions(-)
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
+index XXXXXXX..XXXXXXX 100644
+--- a/util/vfio-helpers.c
++++ b/util/vfio-helpers.c
+@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_water_mark_reached(QEMUVFIOState *s, size_t size,
+ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+                       bool temporary, uint64_t *iova, Error **errp)
+ {
+-    int ret = 0;
+     int index;
+     IOVAMapping *mapping;
+     uint64_t iova0;
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+     if (mapping) {
+         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
+     } else {
++        int ret;
++
+         if (qemu_vfio_water_mark_reached(s, size, errp)) {
+-            ret = -ENOMEM;
+-            goto out;
++            return -ENOMEM;
+         }
+         if (!temporary) {
+             if (!qemu_vfio_find_fixed_iova(s, size, &iova0, errp)) {
+-                ret = -ENOMEM;
+-                goto out;
++                return -ENOMEM;
+             }
+             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
+             assert(qemu_vfio_verify_mappings(s));
+             ret = qemu_vfio_do_mapping(s, host, size, iova0);
+-            if (ret) {
++            if (ret < 0) {
+                 qemu_vfio_undo_mapping(s, mapping, NULL);
+-                goto out;
++                return ret;
+             }
+             qemu_vfio_dump_mappings(s);
+         } else {
+             if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
+-                ret = -ENOMEM;
+-                goto out;
++                return -ENOMEM;
+             }
+             ret = qemu_vfio_do_mapping(s, host, size, iova0);
+-            if (ret) {
+-                goto out;
++            if (ret < 0) {
++                return ret;
+             }
+         }
+     }
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+     if (iova) {
+         *iova = iova0;
+     }
+-out:
+-    return ret;
++    return 0;
+ }
+ /* Reset the high watermark and free all "temporary" mappings. */
+--
+.31.1

-[Qemu-devel] [PULL 1/2] virtio-blk: trace vdev so devices can be distinguished
+[PULL 10/11] util/vfio-helpers: Let qemu_vfio_do_mapping() propagate Error
-It is hard to analyze trace logs with multiple virtio-blk devices
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 because none of the trace events include the VirtIODevice *vdev.
-This patch adds vdev so it's clear which device a request is associated
+Pass qemu_vfio_do_mapping() an Error* argument so it can propagate
-with.
+any error to callers. Replace error_report() which only report
 to the monitor by the more generic error_setg_errno().
-I considered using VirtIOBlock *s instead but VirtIODevice *vdev is more
+Reviewed-by: Fam Zheng <fam@euphon.net>
-general and may be correlated with generic virtio trace events like
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-virtio_set_status.
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20210902070025.197072-11-philmd@redhat.com
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Message-id: 20170614092930.11234-1-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/block/virtio-blk.c | 12 +++++++-----
+ util/vfio-helpers.c | 8 ++++----
- hw/block/trace-events | 10 +++++-----
+file changed, 4 insertions(+), 4 deletions(-)
 files changed, 12 insertions(+), 10 deletions(-)
-diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/virtio-blk.c
+--- a/util/vfio-helpers.c
-+++ b/hw/block/virtio-blk.c
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@ static void virtio_blk_req_complete(VirtIOBlockReq *req, unsigned char status)
+@@ -XXX,XX +XXX,XX @@ static IOVAMapping *qemu_vfio_add_mapping(QEMUVFIOState *s,
-     VirtIOBlock *s = req->dev;
-     VirtIODevice *vdev = VIRTIO_DEVICE(s);
+ /* Do the DMA mapping with VFIO. */
+ static int qemu_vfio_do_mapping(QEMUVFIOState *s, void *host, size_t size,
--    trace_virtio_blk_req_complete(req, status);
+-                                uint64_t iova)
-+    trace_virtio_blk_req_complete(vdev, req, status);
++                                uint64_t iova, Error **errp)
      stb_p(&req->in->status, status);
      virtqueue_push(req->vq, &req->elem, req->in_len);
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_rw_complete(void *opaque, int ret)
  {
-     VirtIOBlockReq *next = opaque;
+     struct vfio_iommu_type1_dma_map dma_map = {
-     VirtIOBlock *s = next->dev;
+         .argsz = sizeof(dma_map),
-+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
+@@ -XXX,XX +XXX,XX @@ static int qemu_vfio_do_mapping(QEMUVFIOState *s, void *host, size_t size,
+     trace_qemu_vfio_do_mapping(s, host, iova, size);
-     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
-     while (next) {
+     if (ioctl(s->container, VFIO_IOMMU_MAP_DMA, &dma_map)) {
-         VirtIOBlockReq *req = next;
+-        error_report("VFIO_MAP_DMA failed: %s", strerror(errno));
-         next = req->mr_next;
++        error_setg_errno(errp, errno, "VFIO_MAP_DMA failed");
--        trace_virtio_blk_rw_complete(req, ret);
+         return -errno;
-+        trace_virtio_blk_rw_complete(vdev, req, ret);
+     }
+     return 0;
-         if (req->qiov.nalloc != -1) {
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
-             /* If nalloc is != 1 req->qiov is a local copy of the original
-@@ -XXX,XX +XXX,XX @@ static inline void submit_requests(BlockBackend *blk, MultiReqBuffer *mrb,
+             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
-             mrb->reqs[i - 1]->mr_next = mrb->reqs[i];
+             assert(qemu_vfio_verify_mappings(s));
-         }
+-            ret = qemu_vfio_do_mapping(s, host, size, iova0);
++            ret = qemu_vfio_do_mapping(s, host, size, iova0, errp);
--        trace_virtio_blk_submit_multireq(mrb, start, num_reqs,
+             if (ret < 0) {
-+        trace_virtio_blk_submit_multireq(VIRTIO_DEVICE(mrb->reqs[start]->dev),
+                 qemu_vfio_undo_mapping(s, mapping, NULL);
-+                                         mrb, start, num_reqs,
+                 return ret;
-                                          sector_num << BDRV_SECTOR_BITS,
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
-                                          qiov->size, is_write);
+             if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
-         block_acct_merge_done(blk_get_stats(blk),
+                 return -ENOMEM;
-@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
+             }
+-            ret = qemu_vfio_do_mapping(s, host, size, iova0);
-         if (is_write) {
++            ret = qemu_vfio_do_mapping(s, host, size, iova0, errp);
-             qemu_iovec_init_external(&req->qiov, iov, out_num);
+             if (ret < 0) {
--            trace_virtio_blk_handle_write(req, req->sector_num,
+                 return ret;
-+            trace_virtio_blk_handle_write(vdev, req, req->sector_num,
+             }
                                            req->qiov.size / BDRV_SECTOR_SIZE);
          } else {
              qemu_iovec_init_external(&req->qiov, in_iov, in_num);
 -            trace_virtio_blk_handle_read(req, req->sector_num,
 +            trace_virtio_blk_handle_read(vdev, req, req->sector_num,
                                           req->qiov.size / BDRV_SECTOR_SIZE);
          }
 diff --git a/hw/block/trace-events b/hw/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/trace-events
 +++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@
  # See docs/tracing.txt for syntax documentation.
  # hw/block/virtio-blk.c
 -virtio_blk_req_complete(void *req, int status) "req %p status %d"
 -virtio_blk_rw_complete(void *req, int ret) "req %p ret %d"
 -virtio_blk_handle_write(void *req, uint64_t sector, size_t nsectors) "req %p sector %"PRIu64" nsectors %zu"
 -virtio_blk_handle_read(void *req, uint64_t sector, size_t nsectors) "req %p sector %"PRIu64" nsectors %zu"
 -virtio_blk_submit_multireq(void *mrb, int start, int num_reqs, uint64_t offset, size_t size, bool is_write) "mrb %p start %d num_reqs %d offset %"PRIu64" size %zu is_write %d"
 +virtio_blk_req_complete(void *vdev, void *req, int status) "vdev %p req %p status %d"
 +virtio_blk_rw_complete(void *vdev, void *req, int ret) "vdev %p req %p ret %d"
 +virtio_blk_handle_write(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
 +virtio_blk_handle_read(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
 +virtio_blk_submit_multireq(void *vdev, void *mrb, int start, int num_reqs, uint64_t offset, size_t size, bool is_write) "vdev %p mrb %p start %d num_reqs %d offset %"PRIu64" size %zu is_write %d"
  # hw/block/hd-geometry.c
  hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d"
 --
-.9.4
+.31.1

-[Qemu-devel] [PULL 2/2] virtio-pci: use ioeventfd even when KVM is disabled
+[PULL 11/11] block/nvme: Only report VFIO error on failed retry
-Old kvm.ko versions only supported a tiny number of ioeventfds so
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 virtio-pci avoids ioeventfds when kvm_has_many_ioeventfds() returns 0.
-Do not check kvm_has_many_ioeventfds() when KVM is disabled since it
+We expect the first qemu_vfio_dma_map() to fail (indicating
-always returns 0.  Since commit 8c56c1a592b5092d91da8d8943c17777d6462a6f
+DMA mappings exhaustion, see commit 15a730e7a3a). Do not
-("memory: emulate ioeventfd") it has been possible to use ioeventfds in
+report the first failure as error, since we are going to
-qtest or TCG mode.
+flush the mappings and retry.
-This patch makes -device virtio-blk-pci,iothread=iothread0 work even
+This removes spurious error message displayed on the monitor:
 when KVM is disabled.
-I have tested that virtio-blk-pci works under TCG both with and without
+  (qemu) c
-iothread.
+  (qemu) qemu-kvm: VFIO_MAP_DMA failed: No space left on device
   (qemu) info status
   VM status: running
-This patch fixes qemu-iotests 068, which was accidentally merged early
+Reported-by: Tingting Mao <timao@redhat.com>
-despite the dependency on ioeventfd.
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Cc: Michael S. Tsirkin <mst@redhat.com>
+Message-id: 20210902070025.197072-12-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Message-id: 20170615163813.7255-2-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/virtio/virtio-pci.c | 2 +-
+ block/nvme.c | 8 +++++++-
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 7 insertions(+), 1 deletion(-)
-diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c
+diff --git a/block/nvme.c b/block/nvme.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/virtio/virtio-pci.c
+--- a/block/nvme.c
-+++ b/hw/virtio/virtio-pci.c
++++ b/block/nvme.c
-@@ -XXX,XX +XXX,XX @@ static void virtio_pci_realize(PCIDevice *pci_dev, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
-     bool pcie_port = pci_bus_is_express(pci_dev->bus) &&
+     uint64_t *pagelist = req->prp_list_page;
-                      !pci_bus_is_root(pci_dev->bus);
+     int i, j, r;
+     int entries = 0;
--    if (!kvm_has_many_ioeventfds()) {
++    Error *local_err = NULL, **errp = NULL;
-+    if (kvm_enabled() && !kvm_has_many_ioeventfds()) {
-         proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
+     assert(qiov->size);
-     }
+     assert(QEMU_IS_ALIGNED(qiov->size, s->page_size));
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
  try_map:
          r = qemu_vfio_dma_map(s->vfio,
                                qiov->iov[i].iov_base,
 -                              len, true, &iova, NULL);
 +                              len, true, &iova, errp);
          if (r == -ENOSPC) {
              /*
               * In addition to the -ENOMEM error, the VFIO_IOMMU_MAP_DMA
@@ -XXX,XX +XXX,XX @@ try_map:
                      goto fail;
                  }
              }
 +            errp = &local_err;
 +
              goto try_map;
          }
          if (r) {
@@ -XXX,XX +XXX,XX @@ fail:
       * because they are already mapped before calling this function; for
       * temporary mappings, a later nvme_cmd_(un)map_qiov will reclaim by
       * calling qemu_vfio_dma_reset_temporary when necessary. */
 +    if (local_err) {
 +        error_reportf_err(local_err, "Cannot map buffer for DMA: ");
 +    }
      return r;
  }
 --
-.9.4
+.31.1

It is hard to analyze trace logs with multiple virtio-blk devices
because none of the trace events include the VirtIODevice *vdev.

This patch adds vdev so it's clear which device a request is associated
with.

I considered using VirtIOBlock *s instead but VirtIODevice *vdev is more
general and may be correlated with generic virtio trace events like
virtio_set_status.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170614092930.11234-1-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/block/virtio-blk.c | 12 +++++++-----
 hw/block/trace-events | 10 +++++-----
 2 files changed, 12 insertions(+), 10 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)
     VirtIOBlock *s = req->dev;
     VirtIODevice *vdev = VIRTIO_DEVICE(s);
 
-    trace_virtio_blk_req_complete(req, status);
+    trace_virtio_blk_req_complete(vdev, req, status);
 
     stb_p(&req->in->status, status);
     virtqueue_push(req->vq, &req->elem, req->in_len);
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_rw_complete(void *opaque, int ret)
 {
     VirtIOBlockReq *next = opaque;
     VirtIOBlock *s = next->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
 
     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
     while (next) {
         VirtIOBlockReq *req = next;
         next = req->mr_next;
-        trace_virtio_blk_rw_complete(req, ret);
+        trace_virtio_blk_rw_complete(vdev, req, ret);
 
         if (req->qiov.nalloc != -1) {
             /* If nalloc is != 1 req->qiov is a local copy of the original
@@ -XXX,XX +XXX,XX @@ static inline void submit_requests(BlockBackend *blk, MultiReqBuffer *mrb,
             mrb->reqs[i - 1]->mr_next = mrb->reqs[i];
         }
 
-        trace_virtio_blk_submit_multireq(mrb, start, num_reqs,
+        trace_virtio_blk_submit_multireq(VIRTIO_DEVICE(mrb->reqs[start]->dev),
+                                         mrb, start, num_reqs,
                                          sector_num << BDRV_SECTOR_BITS,
                                          qiov->size, is_write);
         block_acct_merge_done(blk_get_stats(blk),
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
 
         if (is_write) {
             qemu_iovec_init_external(&req->qiov, iov, out_num);
-            trace_virtio_blk_handle_write(req, req->sector_num,
+            trace_virtio_blk_handle_write(vdev, req, req->sector_num,
                                           req->qiov.size / BDRV_SECTOR_SIZE);
         } else {
             qemu_iovec_init_external(&req->qiov, in_iov, in_num);
-            trace_virtio_blk_handle_read(req, req->sector_num,
+            trace_virtio_blk_handle_read(vdev, req, req->sector_num,
                                          req->qiov.size / BDRV_SECTOR_SIZE);
         }
 
diff --git a/hw/block/trace-events b/hw/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/trace-events
+++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@
 # See docs/tracing.txt for syntax documentation.
 
 # hw/block/virtio-blk.c
-virtio_blk_req_complete(void *req, int status) "req %p status %d"
-virtio_blk_rw_complete(void *req, int ret) "req %p ret %d"
-virtio_blk_handle_write(void *req, uint64_t sector, size_t nsectors) "req %p sector %"PRIu64" nsectors %zu"
-virtio_blk_handle_read(void *req, uint64_t sector, size_t nsectors) "req %p sector %"PRIu64" nsectors %zu"
-virtio_blk_submit_multireq(void *mrb, int start, int num_reqs, uint64_t offset, size_t size, bool is_write) "mrb %p start %d num_reqs %d offset %"PRIu64" size %zu is_write %d"
+virtio_blk_req_complete(void *vdev, void *req, int status) "vdev %p req %p status %d"
+virtio_blk_rw_complete(void *vdev, void *req, int ret) "vdev %p req %p ret %d"
+virtio_blk_handle_write(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
+virtio_blk_handle_read(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
+virtio_blk_submit_multireq(void *vdev, void *mrb, int start, int num_reqs, uint64_t offset, size_t size, bool is_write) "vdev %p mrb %p start %d num_reqs %d offset %"PRIu64" size %zu is_write %d"
 
 # hw/block/hd-geometry.c
 hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d"
-- 
2.9.4

Old kvm.ko versions only supported a tiny number of ioeventfds so
virtio-pci avoids ioeventfds when kvm_has_many_ioeventfds() returns 0.

Do not check kvm_has_many_ioeventfds() when KVM is disabled since it
always returns 0.  Since commit 8c56c1a592b5092d91da8d8943c17777d6462a6f
("memory: emulate ioeventfd") it has been possible to use ioeventfds in
qtest or TCG mode.

This patch makes -device virtio-blk-pci,iothread=iothread0 work even
when KVM is disabled.

I have tested that virtio-blk-pci works under TCG both with and without
iothread.

This patch fixes qemu-iotests 068, which was accidentally merged early
despite the dependency on ioeventfd.

Cc: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Message-id: 20170615163813.7255-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/virtio/virtio-pci.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/virtio-pci.c
+++ b/hw/virtio/virtio-pci.c
@@ -XXX,XX +XXX,XX @@ static void virtio_pci_realize(PCIDevice *pci_dev, Error **errp)
     bool pcie_port = pci_bus_is_express(pci_dev->bus) &&
                      !pci_bus_is_root(pci_dev->bus);
 
-    if (!kvm_has_many_ioeventfds()) {
+    if (kvm_enabled() && !kvm_has_many_ioeventfds()) {
         proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
     }
 
-- 
2.9.4

The following changes since commit 88afdc92b644120e0182c8567e1b1d236e471b12:

Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging (2021-09-05 15:48:42 +0100)

are available in the Git repository at:

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

for you to fetch changes up to 9bd2788f49c331b02372cc257b11e4c984d39708:

block/nvme: Only report VFIO error on failed retry (2021-09-07 09:08:24 +0100)

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

Userspace NVMe driver patches.

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

Philippe Mathieu-Daudé (11):
  block/nvme: Use safer trace format string
  util/vfio-helpers: Let qemu_vfio_verify_mappings() use error_report()
  util/vfio-helpers: Replace qemu_mutex_lock() calls with
    QEMU_LOCK_GUARD
  util/vfio-helpers: Remove unreachable code in qemu_vfio_dma_map()
  block/nvme: Have nvme_create_queue_pair() report errors consistently
  util/vfio-helpers: Pass Error handle to qemu_vfio_dma_map()
  util/vfio-helpers: Extract qemu_vfio_water_mark_reached()
  util/vfio-helpers: Use error_setg in qemu_vfio_find_[fixed/temp]_iova
  util/vfio-helpers: Simplify qemu_vfio_dma_map() returning directly
  util/vfio-helpers: Let qemu_vfio_do_mapping() propagate Error
  block/nvme: Only report VFIO error on failed retry

include/qemu/vfio-helpers.h |  2 +-
 block/nvme.c                | 29 +++++++----
 util/vfio-helpers.c         | 99 ++++++++++++++++++++-----------------
 block/trace-events          |  2 +-
 4 files changed, 76 insertions(+), 56 deletions(-)

-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Fix when building with -Wshorten-64-to-32:

warning: implicit conversion loses integer precision: 'unsigned long' to 'int' [-Wshorten-64-to-32]

Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-2-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/trace-events | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ nvme_dsm(void *s, uint64_t offset, uint64_t bytes) "s %p offset 0x%"PRIx64" byte
 nvme_dsm_done(void *s, uint64_t offset, uint64_t bytes, int ret) "s %p offset 0x%"PRIx64" bytes %"PRId64" ret %d"
 nvme_dma_map_flush(void *s) "s %p"
 nvme_free_req_queue_wait(void *s, unsigned q_index) "s %p q #%u"
-nvme_create_queue_pair(unsigned q_index, void *q, unsigned size, void *aio_context, int fd) "index %u q %p size %u aioctx %p fd %d"
+nvme_create_queue_pair(unsigned q_index, void *q, size_t size, void *aio_context, int fd) "index %u q %p size %zu aioctx %p fd %d"
 nvme_free_queue_pair(unsigned q_index, void *q) "index %u q %p"
 nvme_cmd_map_qiov(void *s, void *cmd, void *req, void *qiov, int entries) "s %p cmd %p req %p qiov %p entries %d"
 nvme_cmd_map_qiov_pages(void *s, int i, uint64_t page) "s %p page[%d] 0x%"PRIx64
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Instead of displaying the error on stderr, use error_report()
which also report to the monitor.

Reviewed-by: Fam Zheng <fam@euphon.net>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-3-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
     if (QEMU_VFIO_DEBUG) {
         for (i = 0; i < s->nr_mappings - 1; ++i) {
             if (!(s->mappings[i].host < s->mappings[i + 1].host)) {
-                fprintf(stderr, "item %d not sorted!\n", i);
+                error_report("item %d not sorted!", i);
                 qemu_vfio_dump_mappings(s);
                 return false;
             }
             if (!(s->mappings[i].host + s->mappings[i].size <=
                   s->mappings[i + 1].host)) {
-                fprintf(stderr, "item %d overlap with next!\n", i);
+                error_report("item %d overlap with next!", i);
                 qemu_vfio_dump_mappings(s);
                 return false;
             }
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Simplify qemu_vfio_dma_[un]map() handlers by replacing a pair of
qemu_mutex_lock/qemu_mutex_unlock calls by the WITH_QEMU_LOCK_GUARD
macro.

Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-4-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
     assert(QEMU_PTR_IS_ALIGNED(host, qemu_real_host_page_size));
     assert(QEMU_IS_ALIGNED(size, qemu_real_host_page_size));
     trace_qemu_vfio_dma_map(s, host, size, temporary, iova);
-    qemu_mutex_lock(&s->lock);
+    QEMU_LOCK_GUARD(&s->lock);
     mapping = qemu_vfio_find_mapping(s, host, &index);
     if (mapping) {
         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
         *iova = iova0;
     }
 out:
-    qemu_mutex_unlock(&s->lock);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ void qemu_vfio_dma_unmap(QEMUVFIOState *s, void *host)
     }
 
     trace_qemu_vfio_dma_unmap(s, host);
-    qemu_mutex_lock(&s->lock);
+    QEMU_LOCK_GUARD(&s->lock);
     m = qemu_vfio_find_mapping(s, host, &index);
     if (!m) {
-        goto out;
+        return;
     }
     qemu_vfio_undo_mapping(s, m, NULL);
-out:
-    qemu_mutex_unlock(&s->lock);
 }
 
 static void qemu_vfio_reset(QEMUVFIOState *s)
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

qemu_vfio_add_mapping() returns a pointer to an indexed entry
in pre-allocated QEMUVFIOState::mappings[], thus can not be NULL.
Remove the pointless check.

Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-5-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
             }
 
             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
-            if (!mapping) {
-                ret = -ENOMEM;
-                goto out;
-            }
             assert(qemu_vfio_verify_mappings(s));
             ret = qemu_vfio_do_mapping(s, host, size, iova0);
             if (ret) {
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

nvme_create_queue_pair() does not return a boolean value (indicating
eventual error) but a pointer, and is inconsistent in how it fills the
error handler. To fulfill callers expectations, always set an error
message on failure.

Reported-by: Auger Eric <eric.auger@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-6-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/nvme.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/block/nvme.c b/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
 
     q = g_try_new0(NVMeQueuePair, 1);
     if (!q) {
+        error_setg(errp, "Cannot allocate queue pair");
         return NULL;
     }
     trace_nvme_create_queue_pair(idx, q, size, aio_context,
@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
                           qemu_real_host_page_size);
     q->prp_list_pages = qemu_try_memalign(qemu_real_host_page_size, bytes);
     if (!q->prp_list_pages) {
+        error_setg(errp, "Cannot allocate PRP page list");
         goto fail;
     }
     memset(q->prp_list_pages, 0, bytes);
@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
     r = qemu_vfio_dma_map(s->vfio, q->prp_list_pages, bytes,
                           false, &prp_list_iova);
     if (r) {
+        error_setg_errno(errp, -r, "Cannot map buffer for DMA");
         goto fail;
     }
     q->free_req_head = -1;
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Currently qemu_vfio_dma_map() displays errors on stderr.
When using management interface, this information is simply
lost. Pass qemu_vfio_dma_map() an Error** handle so it can
propagate the error to callers.

Reviewed-by: Fam Zheng <fam@euphon.net>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-7-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/vfio-helpers.h |  2 +-
 block/nvme.c                | 22 +++++++++++-----------
 util/vfio-helpers.c         | 10 ++++++----
 3 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/include/qemu/vfio-helpers.h b/include/qemu/vfio-helpers.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/vfio-helpers.h
+++ b/include/qemu/vfio-helpers.h
@@ -XXX,XX +XXX,XX @@ typedef struct QEMUVFIOState QEMUVFIOState;
 QEMUVFIOState *qemu_vfio_open_pci(const char *device, Error **errp);
 void qemu_vfio_close(QEMUVFIOState *s);
 int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
-                      bool temporary, uint64_t *iova_list);
+                      bool temporary, uint64_t *iova_list, Error **errp);
 int qemu_vfio_dma_reset_temporary(QEMUVFIOState *s);
 void qemu_vfio_dma_unmap(QEMUVFIOState *s, void *host);
 void *qemu_vfio_pci_map_bar(QEMUVFIOState *s, int index,
diff --git a/block/nvme.c b/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static bool nvme_init_queue(BDRVNVMeState *s, NVMeQueue *q,
         return false;
     }
     memset(q->queue, 0, bytes);
-    r = qemu_vfio_dma_map(s->vfio, q->queue, bytes, false, &q->iova);
+    r = qemu_vfio_dma_map(s->vfio, q->queue, bytes, false, &q->iova, errp);
     if (r) {
-        error_setg(errp, "Cannot map queue");
-        return false;
+        error_prepend(errp, "Cannot map queue: ");
     }
-    return true;
+    return r == 0;
 }
 
 static void nvme_free_queue_pair(NVMeQueuePair *q)
@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
     qemu_co_queue_init(&q->free_req_queue);
     q->completion_bh = aio_bh_new(aio_context, nvme_process_completion_bh, q);
     r = qemu_vfio_dma_map(s->vfio, q->prp_list_pages, bytes,
-                          false, &prp_list_iova);
+                          false, &prp_list_iova, errp);
     if (r) {
-        error_setg_errno(errp, -r, "Cannot map buffer for DMA");
+        error_prepend(errp, "Cannot map buffer for DMA: ");
         goto fail;
     }
     q->free_req_head = -1;
@@ -XXX,XX +XXX,XX @@ static bool nvme_identify(BlockDriverState *bs, int namespace, Error **errp)
         error_setg(errp, "Cannot allocate buffer for identify response");
         goto out;
     }
-    r = qemu_vfio_dma_map(s->vfio, id, id_size, true, &iova);
+    r = qemu_vfio_dma_map(s->vfio, id, id_size, true, &iova, errp);
     if (r) {
-        error_setg(errp, "Cannot map buffer for DMA");
+        error_prepend(errp, "Cannot map buffer for DMA: ");
         goto out;
     }
 
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
 try_map:
         r = qemu_vfio_dma_map(s->vfio,
                               qiov->iov[i].iov_base,
-                              len, true, &iova);
+                              len, true, &iova, NULL);
         if (r == -ENOSPC) {
             /*
              * In addition to the -ENOMEM error, the VFIO_IOMMU_MAP_DMA
@@ -XXX,XX +XXX,XX @@ static void nvme_aio_unplug(BlockDriverState *bs)
 static void nvme_register_buf(BlockDriverState *bs, void *host, size_t size)
 {
     int ret;
+    Error *local_err = NULL;
     BDRVNVMeState *s = bs->opaque;
 
-    ret = qemu_vfio_dma_map(s->vfio, host, size, false, NULL);
+    ret = qemu_vfio_dma_map(s->vfio, host, size, false, NULL, &local_err);
     if (ret) {
         /* FIXME: we may run out of IOVA addresses after repeated
          * bdrv_register_buf/bdrv_unregister_buf, because nvme_vfio_dma_unmap
          * doesn't reclaim addresses for fixed mappings. */
-        error_report("nvme_register_buf failed: %s", strerror(-ret));
+        error_reportf_err(local_err, "nvme_register_buf failed: ");
     }
 }
 
diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static void qemu_vfio_ram_block_added(RAMBlockNotifier *n, void *host,
                                       size_t size, size_t max_size)
 {
     QEMUVFIOState *s = container_of(n, QEMUVFIOState, ram_notifier);
+    Error *local_err = NULL;
     int ret;
 
     trace_qemu_vfio_ram_block_added(s, host, max_size);
-    ret = qemu_vfio_dma_map(s, host, max_size, false, NULL);
+    ret = qemu_vfio_dma_map(s, host, max_size, false, NULL, &local_err);
     if (ret) {
-        error_report("qemu_vfio_dma_map(%p, %zu) failed: %s", host, max_size,
-                     strerror(-ret));
+        error_reportf_err(local_err,
+                          "qemu_vfio_dma_map(%p, %zu) failed: ",
+                          host, max_size);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
  * mapping status within this area is not allowed).
  */
 int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
-                      bool temporary, uint64_t *iova)
+                      bool temporary, uint64_t *iova, Error **errp)
 {
     int ret = 0;
     int index;
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Extract qemu_vfio_water_mark_reached() for readability,
and have it provide an error hint it its Error* handle.

Suggested-by: Klaus Jensen <k.jensen@samsung.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-8-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
     return -ENOMEM;
 }
 
+/**
+ * qemu_vfio_water_mark_reached:
+ *
+ * Returns %true if high watermark has been reached, %false otherwise.
+ */
+static bool qemu_vfio_water_mark_reached(QEMUVFIOState *s, size_t size,
+                                         Error **errp)
+{
+    if (s->high_water_mark - s->low_water_mark + 1 < size) {
+        error_setg(errp, "iova exhausted (water mark reached)");
+        return true;
+    }
+    return false;
+}
+
 /* Map [host, host + size) area into a contiguous IOVA address space, and store
  * the result in @iova if not NULL. The caller need to make sure the area is
  * aligned to page size, and mustn't overlap with existing mapping areas (split
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
     if (mapping) {
         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
     } else {
-        if (s->high_water_mark - s->low_water_mark + 1 < size) {
+        if (qemu_vfio_water_mark_reached(s, size, errp)) {
             ret = -ENOMEM;
             goto out;
         }
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Both qemu_vfio_find_fixed_iova() and qemu_vfio_find_temp_iova()
return an errno which is unused (or overwritten). Have them propagate
eventual errors to callers, returning a boolean (which is what the
Error API recommends, see commit e3fe3988d78 "error: Document Error
API usage rules" for rationale).

Suggested-by: Klaus Jensen <k.jensen@samsung.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-9-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
     return true;
 }
 
-static int
-qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
+static bool qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size,
+                                      uint64_t *iova, Error **errp)
 {
     int i;
 
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
             s->usable_iova_ranges[i].end - s->low_water_mark + 1 == 0) {
             *iova = s->low_water_mark;
             s->low_water_mark += size;
-            return 0;
+            return true;
         }
     }
-    return -ENOMEM;
+    error_setg(errp, "fixed iova range not found");
+
+    return false;
 }
 
-static int
-qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
+static bool qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size,
+                                     uint64_t *iova, Error **errp)
 {
     int i;
 
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
             s->high_water_mark - s->usable_iova_ranges[i].start + 1 == 0) {
             *iova = s->high_water_mark - size;
             s->high_water_mark = *iova;
-            return 0;
+            return true;
         }
     }
-    return -ENOMEM;
+    error_setg(errp, "temporary iova range not found");
+
+    return false;
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
             goto out;
         }
         if (!temporary) {
-            if (qemu_vfio_find_fixed_iova(s, size, &iova0)) {
+            if (!qemu_vfio_find_fixed_iova(s, size, &iova0, errp)) {
                 ret = -ENOMEM;
                 goto out;
             }
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
             }
             qemu_vfio_dump_mappings(s);
         } else {
-            if (qemu_vfio_find_temp_iova(s, size, &iova0)) {
+            if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
                 ret = -ENOMEM;
                 goto out;
             }
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

To simplify qemu_vfio_dma_map():
- reduce 'ret' (returned value) scope by returning errno directly,
- remove the goto 'out' label.

Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-10-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_water_mark_reached(QEMUVFIOState *s, size_t size,
 int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
                       bool temporary, uint64_t *iova, Error **errp)
 {
-    int ret = 0;
     int index;
     IOVAMapping *mapping;
     uint64_t iova0;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
     if (mapping) {
         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
     } else {
+        int ret;
+
         if (qemu_vfio_water_mark_reached(s, size, errp)) {
-            ret = -ENOMEM;
-            goto out;
+            return -ENOMEM;
         }
         if (!temporary) {
             if (!qemu_vfio_find_fixed_iova(s, size, &iova0, errp)) {
-                ret = -ENOMEM;
-                goto out;
+                return -ENOMEM;
             }
 
             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
             assert(qemu_vfio_verify_mappings(s));
             ret = qemu_vfio_do_mapping(s, host, size, iova0);
-            if (ret) {
+            if (ret < 0) {
                 qemu_vfio_undo_mapping(s, mapping, NULL);
-                goto out;
+                return ret;
             }
             qemu_vfio_dump_mappings(s);
         } else {
             if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
-                ret = -ENOMEM;
-                goto out;
+                return -ENOMEM;
             }
             ret = qemu_vfio_do_mapping(s, host, size, iova0);
-            if (ret) {
-                goto out;
+            if (ret < 0) {
+                return ret;
             }
         }
     }
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
     if (iova) {
         *iova = iova0;
     }
-out:
-    return ret;
+    return 0;
 }
 
 /* Reset the high watermark and free all "temporary" mappings. */
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Pass qemu_vfio_do_mapping() an Error* argument so it can propagate
any error to callers. Replace error_report() which only report
to the monitor by the more generic error_setg_errno().

Reviewed-by: Fam Zheng <fam@euphon.net>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-11-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static IOVAMapping *qemu_vfio_add_mapping(QEMUVFIOState *s,
 
 /* Do the DMA mapping with VFIO. */
 static int qemu_vfio_do_mapping(QEMUVFIOState *s, void *host, size_t size,
-                                uint64_t iova)
+                                uint64_t iova, Error **errp)
 {
     struct vfio_iommu_type1_dma_map dma_map = {
         .argsz = sizeof(dma_map),
@@ -XXX,XX +XXX,XX @@ static int qemu_vfio_do_mapping(QEMUVFIOState *s, void *host, size_t size,
     trace_qemu_vfio_do_mapping(s, host, iova, size);
 
     if (ioctl(s->container, VFIO_IOMMU_MAP_DMA, &dma_map)) {
-        error_report("VFIO_MAP_DMA failed: %s", strerror(errno));
+        error_setg_errno(errp, errno, "VFIO_MAP_DMA failed");
         return -errno;
     }
     return 0;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
 
             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
             assert(qemu_vfio_verify_mappings(s));
-            ret = qemu_vfio_do_mapping(s, host, size, iova0);
+            ret = qemu_vfio_do_mapping(s, host, size, iova0, errp);
             if (ret < 0) {
                 qemu_vfio_undo_mapping(s, mapping, NULL);
                 return ret;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
             if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
                 return -ENOMEM;
             }
-            ret = qemu_vfio_do_mapping(s, host, size, iova0);
+            ret = qemu_vfio_do_mapping(s, host, size, iova0, errp);
             if (ret < 0) {
                 return ret;
             }
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

We expect the first qemu_vfio_dma_map() to fail (indicating
DMA mappings exhaustion, see commit 15a730e7a3a). Do not
report the first failure as error, since we are going to
flush the mappings and retry.

This removes spurious error message displayed on the monitor:

(qemu) c
  (qemu) qemu-kvm: VFIO_MAP_DMA failed: No space left on device
  (qemu) info status
  VM status: running

Reported-by: Tingting Mao <timao@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-12-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/nvme.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/block/nvme.c b/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
     uint64_t *pagelist = req->prp_list_page;
     int i, j, r;
     int entries = 0;
+    Error *local_err = NULL, **errp = NULL;
 
     assert(qiov->size);
     assert(QEMU_IS_ALIGNED(qiov->size, s->page_size));
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
 try_map:
         r = qemu_vfio_dma_map(s->vfio,
                               qiov->iov[i].iov_base,
-                              len, true, &iova, NULL);
+                              len, true, &iova, errp);
         if (r == -ENOSPC) {
             /*
              * In addition to the -ENOMEM error, the VFIO_IOMMU_MAP_DMA
@@ -XXX,XX +XXX,XX @@ try_map:
                     goto fail;
                 }
             }
+            errp = &local_err;
+
             goto try_map;
         }
         if (r) {
@@ -XXX,XX +XXX,XX @@ fail:
      * because they are already mapped before calling this function; for
      * temporary mappings, a later nvme_cmd_(un)map_qiov will reclaim by
      * calling qemu_vfio_dma_reset_temporary when necessary. */
+    if (local_err) {
+        error_reportf_err(local_err, "Cannot map buffer for DMA: ");
+    }
     return r;
 }
 
-- 
2.31.1