Commit 0912d0f2 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging 



# gpg: Signature made Fri 30 Jun 2017 12:46:17 BST
# gpg:                using RSA key 0x9CA4ABB381AB73C8
# gpg: Good signature from "Stefan Hajnoczi <stefanha@redhat.com>"
# gpg:                 aka "Stefan Hajnoczi <stefanha@gmail.com>"
# Primary key fingerprint: 8695 A8BF D3F9 7CDA AC35  775A 9CA4 ABB3 81AB 73C8

* remotes/stefanha/tags/block-pull-request:
  virtio-pci: use ioeventfd even when KVM is disabled
  tests: fix virtio-net-test ISR dependence
  tests: fix virtio-blk-test ISR dependence
  tests: fix virtio-scsi-test ISR dependence
  libqos: add virtio used ring support
  libqos: fix typo in virtio.h QVirtQueue->used comment
  virtio-blk: trace vdev so devices can be distinguished

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 36f87b45 c324fd0a

hw/block/trace-events

+5 −5
Original line number Diff line number Diff line 
# 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"

hw/block/virtio-blk.c

+7 −5
Original line number Diff line number Diff line
@@ -50,7 +50,7 @@ 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);
@@ -88,12 +88,13 @@ 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
@@ -355,7 +356,8 @@ 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),
@@ -526,11 +528,11 @@ 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);

        }

hw/virtio/virtio-pci.c

+1 −1
Original line number Diff line number Diff line
@@ -1740,7 +1740,7 @@ 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;

    }

tests/libqos/virtio.c

+60 −0
Original line number Diff line number Diff line
@@ -116,6 +116,35 @@ 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();
@@ -272,6 +301,37 @@ 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);

tests/libqos/virtio.h

+7 −1
Original line number Diff line number Diff line
@@ -26,12 +26,13 @@ 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;

    uint32_t num_free;

    uint32_t align;

    uint16_t last_used_idx;

    bool indirect;

    bool event;

} QVirtQueue;
@@ -120,6 +121,10 @@ 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);
@@ -135,6 +140,7 @@ 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