From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:38687) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XQwYb-0003Xs-Rb for qemu-devel@nongnu.org; Mon, 08 Sep 2014 06:52:32 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1XQwYV-0007iX-Do for qemu-devel@nongnu.org; Mon, 08 Sep 2014 06:52:25 -0400 Received: from mx1.redhat.com ([209.132.183.28]:13719) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XQwYV-0007iT-4O for qemu-devel@nongnu.org; Mon, 08 Sep 2014 06:52:19 -0400 From: Stefan Hajnoczi Date: Mon, 8 Sep 2014 11:51:34 +0100 Message-Id: <1410173509-26667-10-git-send-email-stefanha@redhat.com> In-Reply-To: <1410173509-26667-1-git-send-email-stefanha@redhat.com> References: <1410173509-26667-1-git-send-email-stefanha@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable Subject: [Qemu-devel] [PULL 09/24] libqos: Added MSI-X support List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: =?UTF-8?q?Marc=20Mar=C3=AD?= , Peter Maydell , Stefan Hajnoczi From: Marc Mar=C3=AD Added MSI-X support for qtest PCI. Added MSI-X support for virtio-pci. Added MSI-X test case in virtio-blk-test. Signed-off-by: Marc Mar=C3=AD Signed-off-by: Stefan Hajnoczi --- tests/libqos/pci.c | 111 +++++++++++++++++++++++++++- tests/libqos/pci.h | 10 +++ tests/libqos/virtio-pci.c | 142 +++++++++++++++++++++++++++++++----- tests/libqos/virtio-pci.h | 17 +++++ tests/libqos/virtio.c | 17 ++++- tests/libqos/virtio.h | 11 ++- tests/virtio-blk-test.c | 180 ++++++++++++++++++++++++++++++++++++----= ------ 7 files changed, 426 insertions(+), 62 deletions(-) diff --git a/tests/libqos/pci.c b/tests/libqos/pci.c index ce0b308..d5ce683 100644 --- a/tests/libqos/pci.c +++ b/tests/libqos/pci.c @@ -15,8 +15,6 @@ #include "hw/pci/pci_regs.h" #include =20 -#include - void qpci_device_foreach(QPCIBus *bus, int vendor_id, int device_id, void (*func)(QPCIDevice *dev, int devfn, void *= data), void *data) @@ -75,6 +73,115 @@ void qpci_device_enable(QPCIDevice *dev) qpci_config_writew(dev, PCI_COMMAND, cmd); } =20 +uint8_t qpci_find_capability(QPCIDevice *dev, uint8_t id) +{ + uint8_t cap; + uint8_t addr =3D qpci_config_readb(dev, PCI_CAPABILITY_LIST); + + do { + cap =3D qpci_config_readb(dev, addr); + if (cap !=3D id) { + addr =3D qpci_config_readb(dev, addr + PCI_CAP_LIST_NEXT); + } + } while (cap !=3D id && addr !=3D 0); + + return addr; +} + +void qpci_msix_enable(QPCIDevice *dev) +{ + uint8_t addr; + uint16_t val; + uint32_t table; + uint8_t bir_table; + uint8_t bir_pba; + void *offset; + + addr =3D qpci_find_capability(dev, PCI_CAP_ID_MSIX); + g_assert_cmphex(addr, !=3D, 0); + + val =3D qpci_config_readw(dev, addr + PCI_MSIX_FLAGS); + qpci_config_writew(dev, addr + PCI_MSIX_FLAGS, val | PCI_MSIX_FLAGS_= ENABLE); + + table =3D qpci_config_readl(dev, addr + PCI_MSIX_TABLE); + bir_table =3D table & PCI_MSIX_FLAGS_BIRMASK; + offset =3D qpci_iomap(dev, bir_table, NULL); + dev->msix_table =3D offset + (table & ~PCI_MSIX_FLAGS_BIRMASK); + + table =3D qpci_config_readl(dev, addr + PCI_MSIX_PBA); + bir_pba =3D table & PCI_MSIX_FLAGS_BIRMASK; + if (bir_pba !=3D bir_table) { + offset =3D qpci_iomap(dev, bir_pba, NULL); + } + dev->msix_pba =3D offset + (table & ~PCI_MSIX_FLAGS_BIRMASK); + + g_assert(dev->msix_table !=3D NULL); + g_assert(dev->msix_pba !=3D NULL); + dev->msix_enabled =3D true; +} + +void qpci_msix_disable(QPCIDevice *dev) +{ + uint8_t addr; + uint16_t val; + + g_assert(dev->msix_enabled); + addr =3D qpci_find_capability(dev, PCI_CAP_ID_MSIX); + g_assert_cmphex(addr, !=3D, 0); + val =3D qpci_config_readw(dev, addr + PCI_MSIX_FLAGS); + qpci_config_writew(dev, addr + PCI_MSIX_FLAGS, + val & ~PCI_MSIX_FLAGS_EN= ABLE); + + qpci_iounmap(dev, dev->msix_table); + qpci_iounmap(dev, dev->msix_pba); + dev->msix_enabled =3D 0; + dev->msix_table =3D NULL; + dev->msix_pba =3D NULL; +} + +bool qpci_msix_pending(QPCIDevice *dev, uint16_t entry) +{ + uint32_t pba_entry; + uint8_t bit_n =3D entry % 32; + void *addr =3D dev->msix_pba + (entry / 32) * PCI_MSIX_ENTRY_SIZE / = 4; + + g_assert(dev->msix_enabled); + pba_entry =3D qpci_io_readl(dev, addr); + qpci_io_writel(dev, addr, pba_entry & ~(1 << bit_n)); + return (pba_entry & (1 << bit_n)) !=3D 0; +} + +bool qpci_msix_masked(QPCIDevice *dev, uint16_t entry) +{ + uint8_t addr; + uint16_t val; + void *vector_addr =3D dev->msix_table + (entry * PCI_MSIX_ENTRY_SIZE= ); + + g_assert(dev->msix_enabled); + addr =3D qpci_find_capability(dev, PCI_CAP_ID_MSIX); + g_assert_cmphex(addr, !=3D, 0); + val =3D qpci_config_readw(dev, addr + PCI_MSIX_FLAGS); + + if (val & PCI_MSIX_FLAGS_MASKALL) { + return true; + } else { + return (qpci_io_readl(dev, vector_addr + PCI_MSIX_ENTRY_VECTOR_C= TRL) + & PCI_MSIX_ENTRY_CTRL_MASKBI= T) !=3D 0; + } +} + +uint16_t qpci_msix_table_size(QPCIDevice *dev) +{ + uint8_t addr; + uint16_t control; + + addr =3D qpci_find_capability(dev, PCI_CAP_ID_MSIX); + g_assert_cmphex(addr, !=3D, 0); + + control =3D qpci_config_readw(dev, addr + PCI_MSIX_FLAGS); + return (control & PCI_MSIX_FLAGS_QSIZE) + 1; +} + uint8_t qpci_config_readb(QPCIDevice *dev, uint8_t offset) { return dev->bus->config_readb(dev->bus, dev->devfn, offset); diff --git a/tests/libqos/pci.h b/tests/libqos/pci.h index 9ee048b..d51eb9e 100644 --- a/tests/libqos/pci.h +++ b/tests/libqos/pci.h @@ -14,6 +14,7 @@ #define LIBQOS_PCI_H =20 #include +#include "libqtest.h" =20 #define QPCI_DEVFN(dev, fn) (((dev) << 3) | (fn)) =20 @@ -49,6 +50,9 @@ struct QPCIDevice { QPCIBus *bus; int devfn; + bool msix_enabled; + void *msix_table; + void *msix_pba; }; =20 void qpci_device_foreach(QPCIBus *bus, int vendor_id, int device_id, @@ -57,6 +61,12 @@ void qpci_device_foreach(QPCIBus *bus, int vendor_id, = int device_id, QPCIDevice *qpci_device_find(QPCIBus *bus, int devfn); =20 void qpci_device_enable(QPCIDevice *dev); +uint8_t qpci_find_capability(QPCIDevice *dev, uint8_t id); +void qpci_msix_enable(QPCIDevice *dev); +void qpci_msix_disable(QPCIDevice *dev); +bool qpci_msix_pending(QPCIDevice *dev, uint16_t entry); +bool qpci_msix_masked(QPCIDevice *dev, uint16_t entry); +uint16_t qpci_msix_table_size(QPCIDevice *dev); =20 uint8_t qpci_config_readb(QPCIDevice *dev, uint8_t offset); uint16_t qpci_config_readw(QPCIDevice *dev, uint8_t offset); diff --git a/tests/libqos/virtio-pci.c b/tests/libqos/virtio-pci.c index cf15f7a..ab28717 100644 --- a/tests/libqos/virtio-pci.c +++ b/tests/libqos/virtio-pci.c @@ -36,6 +36,8 @@ static QVirtioPCIDevice *qpcidevice_to_qvirtiodevice(QP= CIDevice *pdev) qpci_config_readw(vpcidev->pdev, PCI_SUBSYST= EM_ID); } =20 + vpcidev->config_msix_entry =3D -1; + return vpcidev; } =20 @@ -125,10 +127,45 @@ static void qvirtio_pci_set_status(QVirtioDevice *d= , uint8_t status) qpci_io_writeb(dev->pdev, dev->addr + QVIRTIO_DEVICE_STATUS, status)= ; } =20 -static uint8_t qvirtio_pci_get_isr_status(QVirtioDevice *d) +static bool qvirtio_pci_get_queue_isr_status(QVirtioDevice *d, QVirtQueu= e *vq) { QVirtioPCIDevice *dev =3D (QVirtioPCIDevice *)d; - return qpci_io_readb(dev->pdev, dev->addr + QVIRTIO_ISR_STATUS); + QVirtQueuePCI *vqpci =3D (QVirtQueuePCI *)vq; + uint32_t data; + + if (dev->pdev->msix_enabled) { + g_assert_cmpint(vqpci->msix_entry, !=3D, -1); + if (qpci_msix_masked(dev->pdev, vqpci->msix_entry)) { + /* No ISR checking should be done if masked, but read anyway= */ + return qpci_msix_pending(dev->pdev, vqpci->msix_entry); + } else { + data =3D readl(vqpci->msix_addr); + writel(vqpci->msix_addr, 0); + return data =3D=3D vqpci->msix_data; + } + } else { + return qpci_io_readb(dev->pdev, dev->addr + QVIRTIO_ISR_STATUS) = & 1; + } +} + +static bool qvirtio_pci_get_config_isr_status(QVirtioDevice *d) +{ + QVirtioPCIDevice *dev =3D (QVirtioPCIDevice *)d; + uint32_t data; + + if (dev->pdev->msix_enabled) { + g_assert_cmpint(dev->config_msix_entry, !=3D, -1); + if (qpci_msix_masked(dev->pdev, dev->config_msix_entry)) { + /* No ISR checking should be done if masked, but read anyway= */ + return qpci_msix_pending(dev->pdev, dev->config_msix_entry); + } else { + data =3D readl(dev->config_msix_addr); + writel(dev->config_msix_addr, 0); + return data =3D=3D dev->config_msix_data; + } + } else { + return qpci_io_readb(dev->pdev, dev->addr + QVIRTIO_ISR_STATUS) = & 2; + } } =20 static void qvirtio_pci_queue_select(QVirtioDevice *d, uint16_t index) @@ -154,32 +191,34 @@ static QVirtQueue *qvirtio_pci_virtqueue_setup(QVir= tioDevice *d, { uint32_t feat; uint64_t addr; - QVirtQueue *vq; + QVirtQueuePCI *vqpci; =20 - vq =3D g_malloc0(sizeof(*vq)); + vqpci =3D g_malloc0(sizeof(*vqpci)); feat =3D qvirtio_pci_get_guest_features(d); =20 qvirtio_pci_queue_select(d, index); - vq->index =3D index; - vq->size =3D qvirtio_pci_get_queue_size(d); - vq->free_head =3D 0; - vq->num_free =3D vq->size; - vq->align =3D QVIRTIO_PCI_ALIGN; - vq->indirect =3D (feat & QVIRTIO_F_RING_INDIRECT_DESC) !=3D 0; + vqpci->vq.index =3D index; + vqpci->vq.size =3D qvirtio_pci_get_queue_size(d); + vqpci->vq.free_head =3D 0; + vqpci->vq.num_free =3D vqpci->vq.size; + vqpci->vq.align =3D QVIRTIO_PCI_ALIGN; + vqpci->vq.indirect =3D (feat & QVIRTIO_F_RING_INDIRECT_DESC) !=3D 0; + + vqpci->msix_entry =3D -1; + vqpci->msix_addr =3D 0; + vqpci->msix_data =3D 0x12345678; =20 /* Check different than 0 */ - g_assert_cmpint(vq->size, !=3D, 0); + g_assert_cmpint(vqpci->vq.size, !=3D, 0); =20 /* Check power of 2 */ - g_assert_cmpint(vq->size & (vq->size - 1), =3D=3D, 0); - - addr =3D guest_alloc(alloc, qvring_size(vq->size, QVIRTIO_PCI_ALIGN)= ); - qvring_init(alloc, vq, addr); - qvirtio_pci_set_queue_address(d, vq->desc / QVIRTIO_PCI_ALIGN); + g_assert_cmpint(vqpci->vq.size & (vqpci->vq.size - 1), =3D=3D, 0); =20 - /* TODO: MSI-X configuration */ + addr =3D guest_alloc(alloc, qvring_size(vqpci->vq.size, QVIRTIO_PCI_= ALIGN)); + qvring_init(alloc, &vqpci->vq, addr); + qvirtio_pci_set_queue_address(d, vqpci->vq.desc / QVIRTIO_PCI_ALIGN)= ; =20 - return vq; + return &vqpci->vq; } =20 static void qvirtio_pci_virtqueue_kick(QVirtioDevice *d, QVirtQueue *vq) @@ -198,7 +237,8 @@ const QVirtioBus qvirtio_pci =3D { .get_guest_features =3D qvirtio_pci_get_guest_features, .get_status =3D qvirtio_pci_get_status, .set_status =3D qvirtio_pci_set_status, - .get_isr_status =3D qvirtio_pci_get_isr_status, + .get_queue_isr_status =3D qvirtio_pci_get_queue_isr_status, + .get_config_isr_status =3D qvirtio_pci_get_config_isr_status, .queue_select =3D qvirtio_pci_queue_select, .get_queue_size =3D qvirtio_pci_get_queue_size, .set_queue_address =3D qvirtio_pci_set_queue_address, @@ -235,4 +275,68 @@ void qvirtio_pci_device_enable(QVirtioPCIDevice *d) void qvirtio_pci_device_disable(QVirtioPCIDevice *d) { qpci_iounmap(d->pdev, d->addr); + d->addr =3D NULL; +} + +void qvirtqueue_pci_msix_setup(QVirtioPCIDevice *d, QVirtQueuePCI *vqpci= , + QGuestAllocator *alloc, uint16_t= entry) +{ + uint16_t vector; + uint32_t control; + void *addr; + + g_assert(d->pdev->msix_enabled); + addr =3D d->pdev->msix_table + (entry * 16); + + g_assert_cmpint(entry, >=3D, 0); + g_assert_cmpint(entry, <, qpci_msix_table_size(d->pdev)); + vqpci->msix_entry =3D entry; + + vqpci->msix_addr =3D guest_alloc(alloc, 4); + qpci_io_writel(d->pdev, addr + PCI_MSIX_ENTRY_LOWER_ADDR, + vqpci->msix_addr & ~= 0UL); + qpci_io_writel(d->pdev, addr + PCI_MSIX_ENTRY_UPPER_ADDR, + (vqpci->msix_addr >> 32) & ~= 0UL); + qpci_io_writel(d->pdev, addr + PCI_MSIX_ENTRY_DATA, vqpci->msix_data= ); + + control =3D qpci_io_readl(d->pdev, addr + PCI_MSIX_ENTRY_VECTOR_CTRL= ); + qpci_io_writel(d->pdev, addr + PCI_MSIX_ENTRY_VECTOR_CTRL, + control & ~PCI_MSIX_ENTRY_CTRL_M= ASKBIT); + + qvirtio_pci_queue_select(&d->vdev, vqpci->vq.index); + qpci_io_writew(d->pdev, d->addr + QVIRTIO_MSIX_QUEUE_VECTOR, entry); + vector =3D qpci_io_readw(d->pdev, d->addr + QVIRTIO_MSIX_QUEUE_VECTO= R); + g_assert_cmphex(vector, !=3D, QVIRTIO_MSI_NO_VECTOR); +} + +void qvirtio_pci_set_msix_configuration_vector(QVirtioPCIDevice *d, + QGuestAllocator *alloc, uint16_t= entry) +{ + uint16_t vector; + uint32_t control; + void *addr; + + g_assert(d->pdev->msix_enabled); + addr =3D d->pdev->msix_table + (entry * 16); + + g_assert_cmpint(entry, >=3D, 0); + g_assert_cmpint(entry, <, qpci_msix_table_size(d->pdev)); + d->config_msix_entry =3D entry; + + d->config_msix_data =3D 0x12345678; + d->config_msix_addr =3D guest_alloc(alloc, 4); + + qpci_io_writel(d->pdev, addr + PCI_MSIX_ENTRY_LOWER_ADDR, + d->config_msix_addr = & ~0UL); + qpci_io_writel(d->pdev, addr + PCI_MSIX_ENTRY_UPPER_ADDR, + (d->config_msix_addr >> 32) = & ~0UL); + qpci_io_writel(d->pdev, addr + PCI_MSIX_ENTRY_DATA, d->config_msix_d= ata); + + control =3D qpci_io_readl(d->pdev, addr + PCI_MSIX_ENTRY_VECTOR_CTRL= ); + qpci_io_writel(d->pdev, addr + PCI_MSIX_ENTRY_VECTOR_CTRL, + control & ~PCI_MSIX_ENTRY_CTRL_M= ASKBIT); + + qpci_io_writew(d->pdev, d->addr + QVIRTIO_MSIX_CONF_VECTOR, entry); + vector =3D qpci_io_readw(d->pdev, d->addr + QVIRTIO_MSIX_CONF_VECTOR= ); + g_assert_cmphex(vector, !=3D, QVIRTIO_MSI_NO_VECTOR); } diff --git a/tests/libqos/virtio-pci.h b/tests/libqos/virtio-pci.h index 40bd12d..883f7ff 100644 --- a/tests/libqos/virtio-pci.h +++ b/tests/libqos/virtio-pci.h @@ -28,12 +28,24 @@ =20 #define QVIRTIO_PCI_ALIGN 4096 =20 +#define QVIRTIO_MSI_NO_VECTOR 0xFFFF + typedef struct QVirtioPCIDevice { QVirtioDevice vdev; QPCIDevice *pdev; void *addr; + uint16_t config_msix_entry; + uint64_t config_msix_addr; + uint32_t config_msix_data; } QVirtioPCIDevice; =20 +typedef struct QVirtQueuePCI { + QVirtQueue vq; + uint16_t msix_entry; + uint64_t msix_addr; + uint32_t msix_data; +} QVirtQueuePCI; + extern const QVirtioBus qvirtio_pci; =20 void qvirtio_pci_foreach(QPCIBus *bus, uint16_t device_type, @@ -41,4 +53,9 @@ void qvirtio_pci_foreach(QPCIBus *bus, uint16_t device_= type, QVirtioPCIDevice *qvirtio_pci_device_find(QPCIBus *bus, uint16_t device_= type); void qvirtio_pci_device_enable(QVirtioPCIDevice *d); void qvirtio_pci_device_disable(QVirtioPCIDevice *d); + +void qvirtio_pci_set_msix_configuration_vector(QVirtioPCIDevice *d, + QGuestAllocator *alloc, uint16_t= entry); +void qvirtqueue_pci_msix_setup(QVirtioPCIDevice *d, QVirtQueuePCI *vqpci= , + QGuestAllocator *alloc, uint16_t= entry); #endif diff --git a/tests/libqos/virtio.c b/tests/libqos/virtio.c index b1cab1f..16eaf79 100644 --- a/tests/libqos/virtio.c +++ b/tests/libqos/virtio.c @@ -78,12 +78,25 @@ void qvirtio_set_driver_ok(const QVirtioBus *bus, QVi= rtioDevice *d) QVIRTIO_DRIVER_OK | QVIRTIO_DRIVER | QVIRTIO_ACKNOWLEDGE= ); } =20 -bool qvirtio_wait_isr(const QVirtioBus *bus, QVirtioDevice *d, uint8_t m= ask, +bool qvirtio_wait_queue_isr(const QVirtioBus *bus, QVirtioDevice *d, + QVirtQueue *vq, uint64_t tim= eout) +{ + do { + clock_step(10); + if (bus->get_queue_isr_status(d, vq)) { + break; /* It has ended */ + } + } while (--timeout); + + return timeout !=3D 0; +} + +bool qvirtio_wait_config_isr(const QVirtioBus *bus, QVirtioDevice *d, uint64_t tim= eout) { do { clock_step(10); - if (bus->get_isr_status(d) & mask) { + if (bus->get_config_isr_status(d)) { break; /* It has ended */ } } while (--timeout); diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h index 1860660..cebccd2 100644 --- a/tests/libqos/virtio.h +++ b/tests/libqos/virtio.h @@ -109,8 +109,11 @@ typedef struct QVirtioBus { /* Set status of the device */ void (*set_status)(QVirtioDevice *d, uint8_t status); =20 - /* Get the ISR status of the device */ - uint8_t (*get_isr_status)(QVirtioDevice *d); + /* Get the queue ISR status of the device */ + bool (*get_queue_isr_status)(QVirtioDevice *d, QVirtQueue *vq); + + /* Get the configuration ISR status of the device */ + bool (*get_config_isr_status)(QVirtioDevice *d); =20 /* Select a queue to work on */ void (*queue_select)(QVirtioDevice *d, uint16_t index); @@ -153,7 +156,9 @@ void qvirtio_set_acknowledge(const QVirtioBus *bus, Q= VirtioDevice *d); void qvirtio_set_driver(const QVirtioBus *bus, QVirtioDevice *d); void qvirtio_set_driver_ok(const QVirtioBus *bus, QVirtioDevice *d); =20 -bool qvirtio_wait_isr(const QVirtioBus *bus, QVirtioDevice *d, uint8_t m= ask, +bool qvirtio_wait_queue_isr(const QVirtioBus *bus, QVirtioDevice *d, + QVirtQueue *vq, uint64_t tim= eout); +bool qvirtio_wait_config_isr(const QVirtioBus *bus, QVirtioDevice *d, uint64_t tim= eout); QVirtQueue *qvirtqueue_setup(const QVirtioBus *bus, QVirtioDevice *d, QGuestAllocator *alloc, uint16_t= index); diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c index 672580b..0100aaa 100644 --- a/tests/virtio-blk-test.c +++ b/tests/virtio-blk-test.c @@ -134,7 +134,7 @@ static void pci_basic(void) { QVirtioPCIDevice *dev; QPCIBus *bus; - QVirtQueue *vq; + QVirtQueuePCI *vqpci; QGuestAllocator *alloc; QVirtioBlkReq req; void *addr; @@ -162,7 +162,8 @@ static void pci_basic(void) qvirtio_set_features(&qvirtio_pci, &dev->vdev, features); =20 alloc =3D pc_alloc_init(); - vq =3D qvirtqueue_setup(&qvirtio_pci, &dev->vdev, alloc, 0); + vqpci =3D (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev= , + allo= c, 0); =20 qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev); =20 @@ -178,11 +179,11 @@ static void pci_basic(void) =20 g_free(req.data); =20 - free_head =3D qvirtqueue_add(vq, req_addr, 528, false, true); - qvirtqueue_add(vq, req_addr + 528, 1, true, false); - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head); + free_head =3D qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true)= ; + qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false); + qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head); =20 - g_assert(qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1, + g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq= , QVIRTIO_BLK_TIME= OUT)); status =3D readb(req_addr + 528); g_assert_cmpint(status, =3D=3D, 0); @@ -199,12 +200,12 @@ static void pci_basic(void) =20 g_free(req.data); =20 - free_head =3D qvirtqueue_add(vq, req_addr, 16, false, true); - qvirtqueue_add(vq, req_addr + 16, 513, true, false); + free_head =3D qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true); + qvirtqueue_add(&vqpci->vq, req_addr + 16, 513, true, false); =20 - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head); + qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head); =20 - g_assert(qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1, + g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq= , QVIRTIO_BLK_TIME= OUT)); status =3D readb(req_addr + 528); g_assert_cmpint(status, =3D=3D, 0); @@ -226,15 +227,13 @@ static void pci_basic(void) =20 req_addr =3D virtio_blk_request(alloc, &req, 512); =20 - g_free(req.data); - - free_head =3D qvirtqueue_add(vq, req_addr, 16, false, true); - qvirtqueue_add(vq, req_addr + 16, 512, false, true); - qvirtqueue_add(vq, req_addr + 528, 1, true, false); + free_head =3D qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true); + qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, false, true); + qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false); =20 - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head); + qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head); =20 - g_assert(qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1, + g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq= , QVIRTIO_BLK_TIME= OUT)); status =3D readb(req_addr + 528); g_assert_cmpint(status, =3D=3D, 0); @@ -251,19 +250,17 @@ static void pci_basic(void) =20 g_free(req.data); =20 - free_head =3D qvirtqueue_add(vq, req_addr, 16, false, true); - qvirtqueue_add(vq, req_addr + 16, 512, true, true); - qvirtqueue_add(vq, req_addr + 528, 1, true, false); + free_head =3D qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true); + qvirtqueue_add(&vqpci->vq, req_addr + 16, 512, true, true); + qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false); =20 - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head); + qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head); =20 - g_assert(qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1, + g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq= , QVIRTIO_BLK_TIME= OUT)); status =3D readb(req_addr + 528); g_assert_cmpint(status, =3D=3D, 0); =20 - guest_free(alloc, req_addr); - data =3D g_malloc0(512); memread(req_addr + 16, data, 512); g_assert_cmpstr(data, =3D=3D, "TEST"); @@ -272,7 +269,7 @@ static void pci_basic(void) guest_free(alloc, req_addr); =20 /* End test */ - guest_free(alloc, vq->desc); + guest_free(alloc, vqpci->vq.desc); qvirtio_pci_device_disable(dev); g_free(dev); test_end(); @@ -282,7 +279,7 @@ static void pci_indirect(void) { QVirtioPCIDevice *dev; QPCIBus *bus; - QVirtQueue *vq; + QVirtQueuePCI *vqpci; QGuestAllocator *alloc; QVirtioBlkReq req; QVRingIndirectDesc *indirect; @@ -311,8 +308,8 @@ static void pci_indirect(void) qvirtio_set_features(&qvirtio_pci, &dev->vdev, features); =20 alloc =3D pc_alloc_init(); - vq =3D qvirtqueue_setup(&qvirtio_pci, &dev->vdev, alloc, 0); - + vqpci =3D (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev= , + allo= c, 0); qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev); =20 /* Write request */ @@ -329,10 +326,10 @@ static void pci_indirect(void) indirect =3D qvring_indirect_desc_setup(&dev->vdev, alloc, 2); qvring_indirect_desc_add(indirect, req_addr, 528, false); qvring_indirect_desc_add(indirect, req_addr + 528, 1, true); - free_head =3D qvirtqueue_add_indirect(vq, indirect); - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head); + free_head =3D qvirtqueue_add_indirect(&vqpci->vq, indirect); + qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head); =20 - g_assert(qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1, + g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq= , QVIRTIO_BLK_TIME= OUT)); status =3D readb(req_addr + 528); g_assert_cmpint(status, =3D=3D, 0); @@ -354,10 +351,10 @@ static void pci_indirect(void) indirect =3D qvring_indirect_desc_setup(&dev->vdev, alloc, 2); qvring_indirect_desc_add(indirect, req_addr, 16, false); qvring_indirect_desc_add(indirect, req_addr + 16, 513, true); - free_head =3D qvirtqueue_add_indirect(vq, indirect); - qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head); + free_head =3D qvirtqueue_add_indirect(&vqpci->vq, indirect); + qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head); =20 - g_assert(qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1, + g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq= , QVIRTIO_BLK_TIME= OUT)); status =3D readb(req_addr + 528); g_assert_cmpint(status, =3D=3D, 0); @@ -371,7 +368,7 @@ static void pci_indirect(void) guest_free(alloc, req_addr); =20 /* End test */ - guest_free(alloc, vq->desc); + guest_free(alloc, vqpci->vq.desc); qvirtio_pci_device_disable(dev); g_free(dev); test_end(); @@ -399,7 +396,7 @@ static void pci_config(void) =20 qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0',= " " 'size': %d } }", n= _size); - g_assert(qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x2, + g_assert(qvirtio_wait_config_isr(&qvirtio_pci, &dev->vdev, QVIRTIO_BLK_TIME= OUT)); =20 capacity =3D qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr); @@ -410,6 +407,116 @@ static void pci_config(void) test_end(); } =20 +static void pci_msix(void) +{ + QVirtioPCIDevice *dev; + QPCIBus *bus; + QVirtQueuePCI *vqpci; + QGuestAllocator *alloc; + QVirtioBlkReq req; + int n_size =3D TEST_IMAGE_SIZE / 2; + void *addr; + uint64_t req_addr; + uint64_t capacity; + uint32_t features; + uint32_t free_head; + uint8_t status; + char *data; + + bus =3D test_start(); + alloc =3D pc_alloc_init(); + + dev =3D virtio_blk_init(bus); + qpci_msix_enable(dev->pdev); + + qvirtio_pci_set_msix_configuration_vector(dev, alloc, 0); + + /* MSI-X is enabled */ + addr =3D dev->addr + QVIRTIO_DEVICE_SPECIFIC_MSIX; + + capacity =3D qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr); + g_assert_cmpint(capacity, =3D=3D, TEST_IMAGE_SIZE / 512); + + features =3D qvirtio_get_features(&qvirtio_pci, &dev->vdev); + features =3D features & ~(QVIRTIO_F_BAD_FEATURE | + QVIRTIO_F_RING_INDIRECT_DESC | + QVIRTIO_F_RING_EVENT_IDX | QVIRTIO_BLK_F_SCS= I); + qvirtio_set_features(&qvirtio_pci, &dev->vdev, features); + + vqpci =3D (QVirtQueuePCI *)qvirtqueue_setup(&qvirtio_pci, &dev->vdev= , + allo= c, 0); + qvirtqueue_pci_msix_setup(dev, vqpci, alloc, 1); + + qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev); + + qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0',= " + " 'size': %d } }", n= _size); + + g_assert(qvirtio_wait_config_isr(&qvirtio_pci, &dev->vdev, + QVIRTIO_BLK_TIME= OUT)); + + capacity =3D qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr); + g_assert_cmpint(capacity, =3D=3D, n_size / 512); + + /* Write request */ + req.type =3D QVIRTIO_BLK_T_OUT; + req.ioprio =3D 1; + req.sector =3D 0; + req.data =3D g_malloc0(512); + strcpy(req.data, "TEST"); + + req_addr =3D virtio_blk_request(alloc, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(&vqpci->vq, req_addr, 528, false, true)= ; + qvirtqueue_add(&vqpci->vq, req_addr + 528, 1, true, false); + qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head); + + g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq= , + QVIRTIO_BLK_TIME= OUT)); + + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + guest_free(alloc, req_addr); + + /* Read request */ + req.type =3D QVIRTIO_BLK_T_IN; + req.ioprio =3D 1; + req.sector =3D 0; + req.data =3D g_malloc0(512); + + req_addr =3D virtio_blk_request(alloc, &req, 512); + + g_free(req.data); + + free_head =3D qvirtqueue_add(&vqpci->vq, req_addr, 16, false, true); + qvirtqueue_add(&vqpci->vq, req_addr + 16, 513, true, false); + + qvirtqueue_kick(&qvirtio_pci, &dev->vdev, &vqpci->vq, free_head); + + g_assert(qvirtio_wait_queue_isr(&qvirtio_pci, &dev->vdev, &vqpci->vq= , + QVIRTIO_BLK_TIME= OUT)); + + status =3D readb(req_addr + 528); + g_assert_cmpint(status, =3D=3D, 0); + + data =3D g_malloc0(512); + memread(req_addr + 16, data, 512); + g_assert_cmpstr(data, =3D=3D, "TEST"); + g_free(data); + + guest_free(alloc, req_addr); + + /* End test */ + guest_free(alloc, vqpci->vq.desc); + qpci_msix_disable(dev->pdev); + qvirtio_pci_device_disable(dev); + g_free(dev); + test_end(); +} + int main(int argc, char **argv) { int ret; @@ -419,6 +526,7 @@ int main(int argc, char **argv) g_test_add_func("/virtio/blk/pci/basic", pci_basic); g_test_add_func("/virtio/blk/pci/indirect", pci_indirect); g_test_add_func("/virtio/blk/pci/config", pci_config); + g_test_add_func("/virtio/blk/pci/msix", pci_msix); =20 ret =3D g_test_run(); =20 --=20 1.9.3