Series comparison

-[Qemu-devel] [PULL 0/7] Block patches
+[Qemu-devel] [PULL 0/1] Block patches
-The following changes since commit 464588675455afda2899e20a0b120e4075de50c7:
+The following changes since commit 0b5e750bea635b167eb03d86c3d9a09bbd43bc06:
-  Merge remote-tracking branch 'remotes/sstabellini/tags/xen-20170627-tag' into staging (2017-06-29 11:45:01 +0100)
+  Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging (2019-02-12 10:53:37 +0000)
-are available in the git repository at:
+are available in the Git repository at:
   git://github.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to c324fd0a39cee43c13f6d1fb34f74fc5e2fb007b:
+for you to fetch changes up to 42824b4d16da56a50ff4027f6cd22378e0e2666e:
-  virtio-pci: use ioeventfd even when KVM is disabled (2017-06-30 11:03:45 +0100)
+  virtio-blk: set correct config size for the host driver (2019-02-13 16:18:17 +0800)
 ----------------------------------------------------------------
 Pull request
 Fix a virtio-blk migration regression.
 ----------------------------------------------------------------
-----------------------------------------------------------------
+Changpeng Liu (1):
   virtio-blk: set correct config size for the host driver
-Stefan Hajnoczi (7):
+ hw/block/virtio-blk.c | 13 +++++++++----
-  virtio-blk: trace vdev so devices can be distinguished
+file changed, 9 insertions(+), 4 deletions(-)
   libqos: fix typo in virtio.h QVirtQueue->used comment
   libqos: add virtio used ring support
   tests: fix virtio-scsi-test ISR dependence
   tests: fix virtio-blk-test ISR dependence
   tests: fix virtio-net-test ISR dependence
   virtio-pci: use ioeventfd even when KVM is disabled
  tests/libqos/virtio.h    |  8 ++++++-
  hw/block/virtio-blk.c    | 12 ++++++----
  hw/virtio/virtio-pci.c   |  2 +-
  tests/libqos/virtio.c    | 60 ++++++++++++++++++++++++++++++++++++++++++++++++
  tests/virtio-blk-test.c  | 27 ++++++++++++++--------
  tests/virtio-net-test.c  |  6 ++---
  tests/virtio-scsi-test.c |  2 +-
  hw/block/trace-events    | 10 ++++----
 files changed, 101 insertions(+), 26 deletions(-)
 --
-.9.4
+.20.1

-[Qemu-devel] [PULL 1/7] virtio-blk: trace vdev so devices can be distinguished
+[Qemu-devel] [PULL 1/1] virtio-blk: set correct config size for the host driver
-It is hard to analyze trace logs with multiple virtio-blk devices
+From: Changpeng Liu <changpeng.liu@intel.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
+Commit caa1ee43 "vhost-user-blk: add discard/write zeroes features
-with.
+support" added fields to struct virtio_blk_config. This changes
 the size of the config space and breaks migration from QEMU 3.1
 and older:
-I considered using VirtIOBlock *s instead but VirtIODevice *vdev is more
+qemu-system-ppc64: get_pci_config_device: Bad config data: i=0x10 read: 41 device: 1 cmask: ff wmask: 80 w1cmask:0
-general and may be correlated with generic virtio trace events like
+qemu-system-ppc64: Failed to load PCIDevice:config
-virtio_set_status.
+qemu-system-ppc64: Failed to load virtio-blk:virtio
 qemu-system-ppc64: error while loading state for instance 0x0 of device 'pci@800000020000000:01.0/virtio-blk'
 qemu-system-ppc64: load of migration failed: Invalid argument
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Since virtio-blk doesn't support the "discard" and "write zeroes"
-Reviewed-by: Fam Zheng <famz@redhat.com>
+features, it shouldn't even expose the associated fields in the
-Message-id: 20170614092930.11234-1-stefanha@redhat.com
+config space actually. Just include all fields up to num_queues to
 match QEMU 3.1 and older.
 Signed-off-by: Changpeng Liu <changpeng.liu@intel.com>
 Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
 Message-id: 1550022537-27565-1-git-send-email-changpeng.liu@intel.com
 Message-Id: <1550022537-27565-1-git-send-email-changpeng.liu@intel.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/block/virtio-blk.c | 12 +++++++-----
+ hw/block/virtio-blk.c | 13 +++++++++----
- hw/block/trace-events | 10 +++++-----
+file changed, 9 insertions(+), 4 deletions(-)
 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)
+@@ -XXX,XX +XXX,XX @@
-     VirtIOBlock *s = req->dev;
+ #include "hw/virtio/virtio-bus.h"
-     VirtIODevice *vdev = VIRTIO_DEVICE(s);
+ #include "hw/virtio/virtio-access.h"
--    trace_virtio_blk_req_complete(req, status);
++/* We don't support discard yet, hide associated config fields. */
-+    trace_virtio_blk_req_complete(vdev, req, status);
++#define VIRTIO_BLK_CFG_SIZE offsetof(struct virtio_blk_config, \
++                                     max_discard_sectors)
-     stb_p(&req->in->status, status);
++
-     virtqueue_push(req->vq, &req->elem, req->in_len);
+ static void virtio_blk_init_request(VirtIOBlock *s, VirtQueue *vq,
-@@ -XXX,XX +XXX,XX @@ static void virtio_blk_rw_complete(void *opaque, int ret)
+                                     VirtIOBlockReq *req)
  {
-     VirtIOBlockReq *next = opaque;
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
-     VirtIOBlock *s = next->dev;
+     blkcfg.alignment_offset = 0;
-+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
+     blkcfg.wce = blk_enable_write_cache(s->blk);
+     virtio_stw_p(vdev, &blkcfg.num_queues, s->conf.num_queues);
-     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
+-    memcpy(config, &blkcfg, sizeof(struct virtio_blk_config));
-     while (next) {
++    memcpy(config, &blkcfg, VIRTIO_BLK_CFG_SIZE);
-         VirtIOBlockReq *req = next;
++    QEMU_BUILD_BUG_ON(VIRTIO_BLK_CFG_SIZE > sizeof(blkcfg));
-         next = req->mr_next;
+ }
--        trace_virtio_blk_rw_complete(req, ret);
-+        trace_virtio_blk_rw_complete(vdev, req, ret);
+ 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)
-         if (req->qiov.nalloc != -1) {
+     VirtIOBlock *s = VIRTIO_BLK(vdev);
-             /* If nalloc is != 1 req->qiov is a local copy of the original
+     struct virtio_blk_config blkcfg;
-@@ -XXX,XX +XXX,XX @@ static inline void submit_requests(BlockBackend *blk, MultiReqBuffer *mrb,
-             mrb->reqs[i - 1]->mr_next = mrb->reqs[i];
+-    memcpy(&blkcfg, config, sizeof(blkcfg));
-         }
++    memcpy(&blkcfg, config, VIRTIO_BLK_CFG_SIZE);
++    QEMU_BUILD_BUG_ON(VIRTIO_BLK_CFG_SIZE > sizeof(blkcfg));
--        trace_virtio_blk_submit_multireq(mrb, start, num_reqs,
-+        trace_virtio_blk_submit_multireq(VIRTIO_DEVICE(mrb->reqs[start]->dev),
+     aio_context_acquire(blk_get_aio_context(s->blk));
-+                                         mrb, start, num_reqs,
+     blk_set_enable_write_cache(s->blk, blkcfg.wce != 0);
-                                          sector_num << BDRV_SECTOR_BITS,
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
-                                          qiov->size, is_write);
+         return;
-         block_acct_merge_done(blk_get_stats(blk),
+     }
-@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
+-    virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK,
-         if (is_write) {
+-                sizeof(struct virtio_blk_config));
-             qemu_iovec_init_external(&req->qiov, iov, out_num);
++    virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, VIRTIO_BLK_CFG_SIZE);
--            trace_virtio_blk_handle_write(req, req->sector_num,
-+            trace_virtio_blk_handle_write(vdev, req, req->sector_num,
+     s->blk = conf->conf.blk;
-                                           req->qiov.size / BDRV_SECTOR_SIZE);
+     s->rq = NULL;
          } 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
+.20.1

-[Qemu-devel] [PULL 2/7] libqos: fix typo in virtio.h QVirtQueue->used comment
+Deleted patch
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Tested-by: Eric Blake <eblake@redhat.com>
-Tested-by: Kevin Wolf <kwolf@redhat.com>
-Message-id: 20170628184724.21378-2-stefanha@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/libqos/virtio.h | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h
-index XXXXXXX..XXXXXXX 100644
---- a/tests/libqos/virtio.h
-+++ b/tests/libqos/virtio.h
-@@ -XXX,XX +XXX,XX @@ typedef struct QVirtioDevice {
- typedef struct QVirtQueue {
-     uint64_t desc; /* This points to an array of struct vring_desc */
-     uint64_t avail; /* This points to a struct vring_avail */
--    uint64_t used; /* This points to a struct vring_desc */
-+    uint64_t used; /* This points to a struct vring_used */
-     uint16_t index;
-     uint32_t size;
-     uint32_t free_head;
---
-.9.4

-[Qemu-devel] [PULL 3/7] libqos: add virtio used ring support
+Deleted patch
-Existing tests do not touch the virtqueue used ring.  Instead they poll
-the virtqueue ISR register and peek into their request's device-specific
-status field.
-It turns out that the virtqueue ISR register can be set to 1 more than
-once for a single notification (see commit
-d768b5640946b7da55ce8335509df297e2c7cd "virtio: set ISR on dataplane
-notifications").  This causes problems for tests that assume a 1:1
-correspondence between the ISR being 1 and request completion.
-Peeking at device-specific status fields is also problematic if the
-device has no field that can be abused for EINPROGRESS polling
-semantics.  This is the case if all the field's values may be set by the
-device; there's no magic constant left for polling.
-It's time to process the used ring for completed requests, just like a
-real virtio guest driver.  This patch adds the necessary APIs.
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Tested-by: Eric Blake <eblake@redhat.com>
-Tested-by: Kevin Wolf <kwolf@redhat.com>
-Message-id: 20170628184724.21378-3-stefanha@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/libqos/virtio.h |  6 ++++++
- tests/libqos/virtio.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++
-files changed, 66 insertions(+)
-diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h
-index XXXXXXX..XXXXXXX 100644
---- a/tests/libqos/virtio.h
-+++ b/tests/libqos/virtio.h
-@@ -XXX,XX +XXX,XX @@ typedef struct QVirtQueue {
-     uint32_t free_head;
-     uint32_t num_free;
-     uint32_t align;
-+    uint16_t last_used_idx;
-     bool indirect;
-     bool event;
- } QVirtQueue;
-@@ -XXX,XX +XXX,XX @@ uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d,
-                                         QVirtQueue *vq,
-                                         uint64_t addr,
-                                         gint64 timeout_us);
-+void qvirtio_wait_used_elem(QVirtioDevice *d,
-+                            QVirtQueue *vq,
-+                            uint32_t desc_idx,
-+                            gint64 timeout_us);
- void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us);
- QVirtQueue *qvirtqueue_setup(QVirtioDevice *d,
-                              QGuestAllocator *alloc, uint16_t index);
-@@ -XXX,XX +XXX,XX @@ uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write,
-                                                                     bool next);
- uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect);
- void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head);
-+bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx);
- void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx);
- #endif
-diff --git a/tests/libqos/virtio.c b/tests/libqos/virtio.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/libqos/virtio.c
-+++ b/tests/libqos/virtio.c
-@@ -XXX,XX +XXX,XX @@ uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d,
-     return val;
- }
-+/*
-+ * qvirtio_wait_used_elem:
-+ * @desc_idx: The next expected vq->desc[] index in the used ring
-+ * @timeout_us: How many microseconds to wait before failing
-+ *
-+ * This function waits for the next completed request on the used ring.
-+ */
-+void qvirtio_wait_used_elem(QVirtioDevice *d,
-+                            QVirtQueue *vq,
-+                            uint32_t desc_idx,
-+                            gint64 timeout_us)
-+{
-+    gint64 start_time = g_get_monotonic_time();
-+
-+    for (;;) {
-+        uint32_t got_desc_idx;
-+
-+        clock_step(100);
-+
-+        if (d->bus->get_queue_isr_status(d, vq) &&
-+            qvirtqueue_get_buf(vq, &got_desc_idx)) {
-+            g_assert_cmpint(got_desc_idx, ==, desc_idx);
-+            return;
-+        }
-+
-+        g_assert(g_get_monotonic_time() - start_time <= timeout_us);
-+    }
-+}
-+
- void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us)
- {
-     gint64 start_time = g_get_monotonic_time();
-@@ -XXX,XX +XXX,XX @@ void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head)
-     }
- }
-+/*
-+ * qvirtqueue_get_buf:
-+ * @desc_idx: A pointer that is filled with the vq->desc[] index, may be NULL
-+ *
-+ * This function gets the next used element if there is one ready.
-+ *
-+ * Returns: true if an element was ready, false otherwise
-+ */
-+bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx)
-+{
-+    uint16_t idx;
-+
-+    idx = readw(vq->used + offsetof(struct vring_used, idx));
-+    if (idx == vq->last_used_idx) {
-+        return false;
-+    }
-+
-+    if (desc_idx) {
-+        uint64_t elem_addr;
-+
-+        elem_addr = vq->used +
-+                    offsetof(struct vring_used, ring) +
-+                    (vq->last_used_idx % vq->size) *
-+                    sizeof(struct vring_used_elem);
-+        *desc_idx = readl(elem_addr + offsetof(struct vring_used_elem, id));
-+    }
-+
-+    vq->last_used_idx++;
-+    return true;
-+}
-+
- void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx)
- {
-     g_assert(vq->event);
---
-.9.4

-[Qemu-devel] [PULL 4/7] tests: fix virtio-scsi-test ISR dependence
+Deleted patch
-Use the new used ring APIs instead of assuming ISR being set means the
-request has completed.
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Tested-by: Eric Blake <eblake@redhat.com>
-Tested-by: Kevin Wolf <kwolf@redhat.com>
-Message-id: 20170628184724.21378-4-stefanha@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/virtio-scsi-test.c | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/virtio-scsi-test.c
-+++ b/tests/virtio-scsi-test.c
-@@ -XXX,XX +XXX,XX @@ static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb,
-     }
-     qvirtqueue_kick(vs->dev, vq, free_head);
--    qvirtio_wait_queue_isr(vs->dev, vq, QVIRTIO_SCSI_TIMEOUT_US);
-+    qvirtio_wait_used_elem(vs->dev, vq, free_head, QVIRTIO_SCSI_TIMEOUT_US);
-     response = readb(resp_addr +
-                      offsetof(struct virtio_scsi_cmd_resp, response));
---
-.9.4

-[Qemu-devel] [PULL 5/7] tests: fix virtio-blk-test ISR dependence
+Deleted patch
-Use the new used ring APIs instead of assuming ISR being set means the
-request has completed.
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Tested-by: Eric Blake <eblake@redhat.com>
-Tested-by: Kevin Wolf <kwolf@redhat.com>
-Message-id: 20170628184724.21378-5-stefanha@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/virtio-blk-test.c | 27 +++++++++++++++++----------
-file changed, 17 insertions(+), 10 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 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
-     qvirtqueue_kick(dev, vq, free_head);
--    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
-+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US);
-     status = readb(req_addr + 528);
-     g_assert_cmpint(status, ==, 0);
-@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
-     qvirtqueue_kick(dev, vq, free_head);
--    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
-+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US);
-     status = readb(req_addr + 528);
-     g_assert_cmpint(status, ==, 0);
-@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
-         qvirtqueue_add(vq, req_addr + 528, 1, true, false);
-         qvirtqueue_kick(dev, vq, free_head);
--        qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
-+        qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US);
-         status = readb(req_addr + 528);
-         g_assert_cmpint(status, ==, 0);
-@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
-         qvirtqueue_kick(dev, vq, free_head);
--        qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
-+        qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US);
-         status = readb(req_addr + 528);
-         g_assert_cmpint(status, ==, 0);
-@@ -XXX,XX +XXX,XX @@ static void pci_indirect(void)
-     free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
-     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
--    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
-+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
-                            QVIRTIO_BLK_TIMEOUT_US);
-     status = readb(req_addr + 528);
-     g_assert_cmpint(status, ==, 0);
-@@ -XXX,XX +XXX,XX @@ static void pci_indirect(void)
-     free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
-     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
--    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
-+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
-                            QVIRTIO_BLK_TIMEOUT_US);
-     status = readb(req_addr + 528);
-     g_assert_cmpint(status, ==, 0);
-@@ -XXX,XX +XXX,XX @@ static void pci_msix(void)
-     qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
-     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
--    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
-+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
-                            QVIRTIO_BLK_TIMEOUT_US);
-     status = readb(req_addr + 528);
-@@ -XXX,XX +XXX,XX @@ static void pci_msix(void)
-     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
--    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
-+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
-                            QVIRTIO_BLK_TIMEOUT_US);
-     status = readb(req_addr + 528);
-@@ -XXX,XX +XXX,XX @@ static void pci_idx(void)
-     uint64_t capacity;
-     uint32_t features;
-     uint32_t free_head;
-+    uint32_t write_head;
-+    uint32_t desc_idx;
-     uint8_t status;
-     char *data;
-@@ -XXX,XX +XXX,XX @@ static void pci_idx(void)
-     qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
-     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
--    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq, QVIRTIO_BLK_TIMEOUT_US);
-+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
-+                           QVIRTIO_BLK_TIMEOUT_US);
-     /* Write request */
-     req.type = VIRTIO_BLK_T_OUT;
-@@ -XXX,XX +XXX,XX @@ static void pci_idx(void)
-     qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);
-     qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
-     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
-+    write_head = free_head;
-     /* No notification expected */
-     status = qvirtio_wait_status_byte_no_isr(&dev->vdev,
-@@ -XXX,XX +XXX,XX @@ static void pci_idx(void)
-     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
--    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
-+    /* We get just one notification for both requests */
-+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, write_head,
-                            QVIRTIO_BLK_TIMEOUT_US);
-+    g_assert(qvirtqueue_get_buf(&vqpci->vq, &desc_idx));
-+    g_assert_cmpint(desc_idx, ==, free_head);
-     status = readb(req_addr + 528);
-     g_assert_cmpint(status, ==, 0);
---
-.9.4

-[Qemu-devel] [PULL 6/7] tests: fix virtio-net-test ISR dependence
+Deleted patch
-Use the new used ring APIs instead of assuming ISR being set means the
-request has completed.
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Tested-by: Eric Blake <eblake@redhat.com>
-Tested-by: Kevin Wolf <kwolf@redhat.com>
-Message-id: 20170628184724.21378-6-stefanha@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/virtio-net-test.c | 6 +++---
-file changed, 3 insertions(+), 3 deletions(-)
-diff --git a/tests/virtio-net-test.c b/tests/virtio-net-test.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/virtio-net-test.c
-+++ b/tests/virtio-net-test.c
-@@ -XXX,XX +XXX,XX @@ static void rx_test(QVirtioDevice *dev,
-     ret = iov_send(socket, iov, 2, 0, sizeof(len) + sizeof(test));
-     g_assert_cmpint(ret, ==, sizeof(test) + sizeof(len));
--    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
-+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US);
-     memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
-     g_assert_cmpstr(buffer, ==, "TEST");
-@@ -XXX,XX +XXX,XX @@ static void tx_test(QVirtioDevice *dev,
-     free_head = qvirtqueue_add(vq, req_addr, 64, false, false);
-     qvirtqueue_kick(dev, vq, free_head);
--    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
-+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US);
-     guest_free(alloc, req_addr);
-     ret = qemu_recv(socket, &len, sizeof(len), 0);
-@@ -XXX,XX +XXX,XX @@ static void rx_stop_cont_test(QVirtioDevice *dev,
-     rsp = qmp("{ 'execute' : 'cont'}");
-     QDECREF(rsp);
--    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
-+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US);
-     memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
-     g_assert_cmpstr(buffer, ==, "TEST");
---
-.9.4

-[Qemu-devel] [PULL 7/7] virtio-pci: use ioeventfd even when KVM is disabled
+Deleted patch
-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>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Tested-by: Eric Blake <eblake@redhat.com>
-Tested-by: Kevin Wolf <kwolf@redhat.com>
-Message-id: 20170628184724.21378-7-stefanha@redhat.com
-Message-id: 20170615163813.7255-2-stefanha@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- hw/virtio/virtio-pci.c | 2 +-
-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;
-     }
---
-.9.4

The following changes since commit 464588675455afda2899e20a0b120e4075de50c7:

Merge remote-tracking branch 'remotes/sstabellini/tags/xen-20170627-tag' into staging (2017-06-29 11:45:01 +0100)

are available in the git repository at:

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

for you to fetch changes up to c324fd0a39cee43c13f6d1fb34f74fc5e2fb007b:

virtio-pci: use ioeventfd even when KVM is disabled (2017-06-30 11:03:45 +0100)

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

Stefan Hajnoczi (7):
  virtio-blk: trace vdev so devices can be distinguished
  libqos: fix typo in virtio.h QVirtQueue->used comment
  libqos: add virtio used ring support
  tests: fix virtio-scsi-test ISR dependence
  tests: fix virtio-blk-test ISR dependence
  tests: fix virtio-net-test ISR dependence
  virtio-pci: use ioeventfd even when KVM is disabled

-- 
2.9.4

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

Existing tests do not touch the virtqueue used ring.  Instead they poll
the virtqueue ISR register and peek into their request's device-specific
status field.

It turns out that the virtqueue ISR register can be set to 1 more than
once for a single notification (see commit
83d768b5640946b7da55ce8335509df297e2c7cd "virtio: set ISR on dataplane
notifications").  This causes problems for tests that assume a 1:1
correspondence between the ISR being 1 and request completion.

Peeking at device-specific status fields is also problematic if the
device has no field that can be abused for EINPROGRESS polling
semantics.  This is the case if all the field's values may be set by the
device; there's no magic constant left for polling.

It's time to process the used ring for completed requests, just like a
real virtio guest driver.  This patch adds the necessary APIs.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Eric Blake <eblake@redhat.com>
Tested-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 20170628184724.21378-3-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/libqos/virtio.h |  6 ++++++
 tests/libqos/virtio.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 66 insertions(+)

diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h
index XXXXXXX..XXXXXXX 100644
--- a/tests/libqos/virtio.h
+++ b/tests/libqos/virtio.h
@@ -XXX,XX +XXX,XX @@ typedef struct QVirtQueue {
     uint32_t free_head;
     uint32_t num_free;
     uint32_t align;
+    uint16_t last_used_idx;
     bool indirect;
     bool event;
 } QVirtQueue;
@@ -XXX,XX +XXX,XX @@ uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d,
                                         QVirtQueue *vq,
                                         uint64_t addr,
                                         gint64 timeout_us);
+void qvirtio_wait_used_elem(QVirtioDevice *d,
+                            QVirtQueue *vq,
+                            uint32_t desc_idx,
+                            gint64 timeout_us);
 void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us);
 QVirtQueue *qvirtqueue_setup(QVirtioDevice *d,
                              QGuestAllocator *alloc, uint16_t index);
@@ -XXX,XX +XXX,XX @@ uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write,
                                                                     bool next);
 uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect);
 void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head);
+bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx);
 
 void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx);
 #endif
diff --git a/tests/libqos/virtio.c b/tests/libqos/virtio.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/libqos/virtio.c
+++ b/tests/libqos/virtio.c
@@ -XXX,XX +XXX,XX @@ uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d,
     return val;
 }
 
+/*
+ * qvirtio_wait_used_elem:
+ * @desc_idx: The next expected vq->desc[] index in the used ring
+ * @timeout_us: How many microseconds to wait before failing
+ *
+ * This function waits for the next completed request on the used ring.
+ */
+void qvirtio_wait_used_elem(QVirtioDevice *d,
+                            QVirtQueue *vq,
+                            uint32_t desc_idx,
+                            gint64 timeout_us)
+{
+    gint64 start_time = g_get_monotonic_time();
+
+    for (;;) {
+        uint32_t got_desc_idx;
+
+        clock_step(100);
+
+        if (d->bus->get_queue_isr_status(d, vq) &&
+            qvirtqueue_get_buf(vq, &got_desc_idx)) {
+            g_assert_cmpint(got_desc_idx, ==, desc_idx);
+            return;
+        }
+
+        g_assert(g_get_monotonic_time() - start_time <= timeout_us);
+    }
+}
+
 void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us)
 {
     gint64 start_time = g_get_monotonic_time();
@@ -XXX,XX +XXX,XX @@ void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head)
     }
 }
 
+/*
+ * qvirtqueue_get_buf:
+ * @desc_idx: A pointer that is filled with the vq->desc[] index, may be NULL
+ *
+ * This function gets the next used element if there is one ready.
+ *
+ * Returns: true if an element was ready, false otherwise
+ */
+bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx)
+{
+    uint16_t idx;
+
+    idx = readw(vq->used + offsetof(struct vring_used, idx));
+    if (idx == vq->last_used_idx) {
+        return false;
+    }
+
+    if (desc_idx) {
+        uint64_t elem_addr;
+
+        elem_addr = vq->used +
+                    offsetof(struct vring_used, ring) +
+                    (vq->last_used_idx % vq->size) *
+                    sizeof(struct vring_used_elem);
+        *desc_idx = readl(elem_addr + offsetof(struct vring_used_elem, id));
+    }
+
+    vq->last_used_idx++;
+    return true;
+}
+
 void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx)
 {
     g_assert(vq->event);
-- 
2.9.4

Use the new used ring APIs instead of assuming ISR being set means the
request has completed.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Eric Blake <eblake@redhat.com>
Tested-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 20170628184724.21378-4-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/virtio-scsi-test.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/virtio-scsi-test.c b/tests/virtio-scsi-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/virtio-scsi-test.c
+++ b/tests/virtio-scsi-test.c
@@ -XXX,XX +XXX,XX @@ static uint8_t virtio_scsi_do_command(QVirtIOSCSI *vs, const uint8_t *cdb,
     }
 
     qvirtqueue_kick(vs->dev, vq, free_head);
-    qvirtio_wait_queue_isr(vs->dev, vq, QVIRTIO_SCSI_TIMEOUT_US);
+    qvirtio_wait_used_elem(vs->dev, vq, free_head, QVIRTIO_SCSI_TIMEOUT_US);
 
     response = readb(resp_addr +
                      offsetof(struct virtio_scsi_cmd_resp, response));
-- 
2.9.4

Use the new used ring APIs instead of assuming ISR being set means the
request has completed.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Eric Blake <eblake@redhat.com>
Tested-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 20170628184724.21378-5-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/virtio-blk-test.c | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 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 @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
 
     qvirtqueue_kick(dev, vq, free_head);
 
-    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US);
     status = readb(req_addr + 528);
     g_assert_cmpint(status, ==, 0);
 
@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
 
     qvirtqueue_kick(dev, vq, free_head);
 
-    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US);
     status = readb(req_addr + 528);
     g_assert_cmpint(status, ==, 0);
 
@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
         qvirtqueue_add(vq, req_addr + 528, 1, true, false);
         qvirtqueue_kick(dev, vq, free_head);
 
-        qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
+        qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US);
         status = readb(req_addr + 528);
         g_assert_cmpint(status, ==, 0);
 
@@ -XXX,XX +XXX,XX @@ static void test_basic(QVirtioDevice *dev, QGuestAllocator *alloc,
 
         qvirtqueue_kick(dev, vq, free_head);
 
-        qvirtio_wait_queue_isr(dev, vq, QVIRTIO_BLK_TIMEOUT_US);
+        qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_BLK_TIMEOUT_US);
         status = readb(req_addr + 528);
         g_assert_cmpint(status, ==, 0);
 
@@ -XXX,XX +XXX,XX @@ static void pci_indirect(void)
     free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
 
-    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
                            QVIRTIO_BLK_TIMEOUT_US);
     status = readb(req_addr + 528);
     g_assert_cmpint(status, ==, 0);
@@ -XXX,XX +XXX,XX @@ static void pci_indirect(void)
     free_head = qvirtqueue_add_indirect(&vqpci->vq, indirect);
     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
 
-    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
                            QVIRTIO_BLK_TIMEOUT_US);
     status = readb(req_addr + 528);
     g_assert_cmpint(status, ==, 0);
@@ -XXX,XX +XXX,XX @@ static void pci_msix(void)
     qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
 
-    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
                            QVIRTIO_BLK_TIMEOUT_US);
 
     status = readb(req_addr + 528);
@@ -XXX,XX +XXX,XX @@ static void pci_msix(void)
     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
 
 
-    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
                            QVIRTIO_BLK_TIMEOUT_US);
 
     status = readb(req_addr + 528);
@@ -XXX,XX +XXX,XX @@ static void pci_idx(void)
     uint64_t capacity;
     uint32_t features;
     uint32_t free_head;
+    uint32_t write_head;
+    uint32_t desc_idx;
     uint8_t status;
     char *data;
 
@@ -XXX,XX +XXX,XX @@ static void pci_idx(void)
     qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
 
-    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq, QVIRTIO_BLK_TIMEOUT_US);
+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, free_head,
+                           QVIRTIO_BLK_TIMEOUT_US);
 
     /* Write request */
     req.type = VIRTIO_BLK_T_OUT;
@@ -XXX,XX +XXX,XX @@ static void pci_idx(void)
     qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true);
     qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false);
     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
+    write_head = free_head;
 
     /* No notification expected */
     status = qvirtio_wait_status_byte_no_isr(&dev->vdev,
@@ -XXX,XX +XXX,XX @@ static void pci_idx(void)
 
     qvirtqueue_kick(&dev->vdev, &vqpci->vq, free_head);
 
-    qvirtio_wait_queue_isr(&dev->vdev, &vqpci->vq,
+    /* We get just one notification for both requests */
+    qvirtio_wait_used_elem(&dev->vdev, &vqpci->vq, write_head,
                            QVIRTIO_BLK_TIMEOUT_US);
+    g_assert(qvirtqueue_get_buf(&vqpci->vq, &desc_idx));
+    g_assert_cmpint(desc_idx, ==, free_head);
 
     status = readb(req_addr + 528);
     g_assert_cmpint(status, ==, 0);
-- 
2.9.4

Use the new used ring APIs instead of assuming ISR being set means the
request has completed.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Eric Blake <eblake@redhat.com>
Tested-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 20170628184724.21378-6-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/virtio-net-test.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/virtio-net-test.c b/tests/virtio-net-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/virtio-net-test.c
+++ b/tests/virtio-net-test.c
@@ -XXX,XX +XXX,XX @@ static void rx_test(QVirtioDevice *dev,
     ret = iov_send(socket, iov, 2, 0, sizeof(len) + sizeof(test));
     g_assert_cmpint(ret, ==, sizeof(test) + sizeof(len));
 
-    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US);
     memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
     g_assert_cmpstr(buffer, ==, "TEST");
 
@@ -XXX,XX +XXX,XX @@ static void tx_test(QVirtioDevice *dev,
     free_head = qvirtqueue_add(vq, req_addr, 64, false, false);
     qvirtqueue_kick(dev, vq, free_head);
 
-    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US);
     guest_free(alloc, req_addr);
 
     ret = qemu_recv(socket, &len, sizeof(len), 0);
@@ -XXX,XX +XXX,XX @@ static void rx_stop_cont_test(QVirtioDevice *dev,
     rsp = qmp("{ 'execute' : 'cont'}");
     QDECREF(rsp);
 
-    qvirtio_wait_queue_isr(dev, vq, QVIRTIO_NET_TIMEOUT_US);
+    qvirtio_wait_used_elem(dev, vq, free_head, QVIRTIO_NET_TIMEOUT_US);
     memread(req_addr + VNET_HDR_SIZE, buffer, sizeof(test));
     g_assert_cmpstr(buffer, ==, "TEST");
 
-- 
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>
Reviewed-by: Fam Zheng <famz@redhat.com>
Tested-by: Eric Blake <eblake@redhat.com>
Tested-by: Kevin Wolf <kwolf@redhat.com>
Message-id: 20170628184724.21378-7-stefanha@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

From: Changpeng Liu <changpeng.liu@intel.com>

Commit caa1ee43 "vhost-user-blk: add discard/write zeroes features
support" added fields to struct virtio_blk_config. This changes
the size of the config space and breaks migration from QEMU 3.1
and older:

qemu-system-ppc64: get_pci_config_device: Bad config data: i=0x10 read: 41 device: 1 cmask: ff wmask: 80 w1cmask:0
qemu-system-ppc64: Failed to load PCIDevice:config
qemu-system-ppc64: Failed to load virtio-blk:virtio
qemu-system-ppc64: error while loading state for instance 0x0 of device 'pci@800000020000000:01.0/virtio-blk'
qemu-system-ppc64: load of migration failed: Invalid argument

Since virtio-blk doesn't support the "discard" and "write zeroes"
features, it shouldn't even expose the associated fields in the
config space actually. Just include all fields up to num_queues to
match QEMU 3.1 and older.

Signed-off-by: Changpeng Liu <changpeng.liu@intel.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Message-id: 1550022537-27565-1-git-send-email-changpeng.liu@intel.com
Message-Id: <1550022537-27565-1-git-send-email-changpeng.liu@intel.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/block/virtio-blk.c | 13 +++++++++----
 1 file changed, 9 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 @@
 #include "hw/virtio/virtio-bus.h"
 #include "hw/virtio/virtio-access.h"
 
+/* We don't support discard yet, hide associated config fields. */
+#define VIRTIO_BLK_CFG_SIZE offsetof(struct virtio_blk_config, \
+                                     max_discard_sectors)
+
 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, sizeof(struct virtio_blk_config));
+    memcpy(config, &blkcfg, VIRTIO_BLK_CFG_SIZE);
+    QEMU_BUILD_BUG_ON(VIRTIO_BLK_CFG_SIZE > sizeof(blkcfg));
 }
 
 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, sizeof(blkcfg));
+    memcpy(&blkcfg, config, VIRTIO_BLK_CFG_SIZE);
+    QEMU_BUILD_BUG_ON(VIRTIO_BLK_CFG_SIZE > sizeof(blkcfg));
 
     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,
-                sizeof(struct virtio_blk_config));
+    virtio_init(vdev, "virtio-blk", VIRTIO_ID_BLOCK, VIRTIO_BLK_CFG_SIZE);
 
     s->blk = conf->conf.blk;
     s->rq = NULL;
-- 
2.20.1