[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-devel] [PATCH v2 7/7] libqos: Added basic virtqueue support to vir
|
From: |
Marc Marí |
|
Subject: |
[Qemu-devel] [PATCH v2 7/7] libqos: Added basic virtqueue support to virtio implementation |
|
Date: |
Fri, 25 Jul 2014 23:37:43 +0200 |
Add status changing and feature negotiation.
Add basic virtqueue support for adding and sending virtqueue requests.
Add ISR checking.
Signed-off-by: Marc Marí <address@hidden>
---
tests/libqos/virtio-pci.c | 91 +++++++++++++++++++++++++-
tests/libqos/virtio-pci.h | 7 ++
tests/libqos/virtio.c | 89 ++++++++++++++++++++++++++
tests/libqos/virtio.h | 90 +++++++++++++++++++++++++-
tests/virtio-blk-test.c | 155 +++++++++++++++++++++++++++++++++++++++++++--
5 files changed, 425 insertions(+), 7 deletions(-)
diff --git a/tests/libqos/virtio-pci.c b/tests/libqos/virtio-pci.c
index b707c8d..5d00826 100644
--- a/tests/libqos/virtio-pci.c
+++ b/tests/libqos/virtio-pci.c
@@ -13,6 +13,8 @@
#include "libqos/virtio-pci.h"
#include "libqos/pci.h"
#include "libqos/pci-pc.h"
+#include "libqos/malloc.h"
+#include "libqos/malloc-pc.h"
#include "hw/pci/pci_regs.h"
@@ -79,16 +81,93 @@ static uint64_t qvirtio_pci_config_readq(QVirtioDevice *d,
void *addr)
return qpci_io_readl(dev->pdev, addr) | qpci_io_readl(dev->pdev, addr+4);
}
+static uint32_t qvirtio_pci_get_features(QVirtioDevice *d)
+{
+ QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
+ return qpci_io_readl(dev->pdev, dev->addr + QVIRTIO_DEVICE_FEATURES);
+}
+
+static void qvirtio_pci_set_features(QVirtioDevice *d, uint32_t features)
+{
+ QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
+ qpci_io_writel(dev->pdev, dev->addr + QVIRTIO_GUEST_FEATURES, features);
+}
+
static uint8_t qvirtio_pci_get_status(QVirtioDevice *d)
{
QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
return qpci_io_readb(dev->pdev, dev->addr + QVIRTIO_DEVICE_STATUS);
}
-static void qvirtio_pci_set_status(QVirtioDevice *d, uint8_t val)
+static void qvirtio_pci_set_status(QVirtioDevice *d, uint8_t status)
+{
+ QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
+ qpci_io_writeb(dev->pdev, dev->addr + QVIRTIO_DEVICE_STATUS, status);
+}
+
+static uint8_t qvirtio_pci_get_isr_status(QVirtioDevice *d)
+{
+ QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
+ return qpci_io_readb(dev->pdev, dev->addr + QVIRTIO_ISR_STATUS);
+}
+
+static void qvirtio_pci_queue_select(QVirtioDevice *d, uint16_t index)
+{
+ QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
+ qpci_io_writeb(dev->pdev, dev->addr + QVIRTIO_QUEUE_SELECT, index);
+}
+
+static uint16_t qvirtio_pci_get_queue_size(QVirtioDevice *d)
+{
+ QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
+ return qpci_io_readw(dev->pdev, dev->addr + QVIRTIO_QUEUE_SIZE);
+}
+
+static void qvirtio_pci_set_queue_address(QVirtioDevice *d, uint32_t pfn)
+{
+ QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
+ qpci_io_writel(dev->pdev, dev->addr + QVIRTIO_QUEUE_ADDRESS, pfn);
+}
+
+static QVirtQueue *qvirtio_pci_virtqueue_setup(QVirtioDevice *d,
+ QGuestAllocator *alloc, uint16_t index)
+{
+ uint16_t aux;
+ uint64_t addr;
+ QVirtQueue *vq;
+
+ vq = g_malloc0(sizeof(*vq));
+
+ qvirtio_pci_queue_select(d, index);
+ vq->index = index;
+ vq->size = qvirtio_pci_get_queue_size(d);
+ vq->free_head = 0;
+ vq->num_free = vq->size;
+ vq->align = QVIRTIO_PCI_ALIGN;
+
+ /* Check different than 0 */
+ g_assert_cmpint(vq->size, !=, 0);
+
+ /* Check power of 2 */
+ aux = vq->size;
+ while ((aux & 1) != 0) {
+ aux = aux >> 1;
+ }
+ g_assert_cmpint(aux, !=, 1);
+
+ addr = guest_alloc(alloc, qvring_size(vq->size, QVIRTIO_PCI_ALIGN));
+ qvring_init(alloc, vq, addr);
+ qvirtio_pci_set_queue_address(d, vq->desc/4096);
+
+ /* TODO: MSI-X configuration */
+
+ return vq;
+}
+
+static void qvirtio_pci_virtqueue_kick(QVirtioDevice *d, QVirtQueue *vq)
{
QVirtioPCIDevice *dev = (QVirtioPCIDevice *)d;
- qpci_io_writeb(dev->pdev, dev->addr + QVIRTIO_DEVICE_STATUS, val);
+ qpci_io_writew(dev->pdev, dev->addr + QVIRTIO_QUEUE_NOTIFY, vq->index);
}
const QVirtioBus qvirtio_pci = {
@@ -96,8 +175,16 @@ const QVirtioBus qvirtio_pci = {
.config_readw = qvirtio_pci_config_readw,
.config_readl = qvirtio_pci_config_readl,
.config_readq = qvirtio_pci_config_readq,
+ .get_features = qvirtio_pci_get_features,
+ .set_features = qvirtio_pci_set_features,
.get_status = qvirtio_pci_get_status,
.set_status = qvirtio_pci_set_status,
+ .get_isr_status = qvirtio_pci_get_isr_status,
+ .queue_select = qvirtio_pci_queue_select,
+ .get_queue_size = qvirtio_pci_get_queue_size,
+ .set_queue_address = qvirtio_pci_set_queue_address,
+ .virtqueue_setup = qvirtio_pci_virtqueue_setup,
+ .virtqueue_kick = qvirtio_pci_virtqueue_kick,
};
void qvirtio_pci_foreach(QPCIBus *bus, uint16_t device_type,
diff --git a/tests/libqos/virtio-pci.h b/tests/libqos/virtio-pci.h
index 3060238..1e1154a 100644
--- a/tests/libqos/virtio-pci.h
+++ b/tests/libqos/virtio-pci.h
@@ -26,6 +26,13 @@
#define QVIRTIO_DEVICE_SPECIFIC_MSIX 0x18
#define QVIRTIO_DEVICE_SPECIFIC_NO_MSIX 0x14
+#define QVIRTIO_F_NOTIFY_ON_EMPTY 0x01000000
+#define QVIRTIO_F_ANY_LAYOUT 0x08000000
+#define QVIRTIO_F_RING_INDIRECT_DESC 0x10000000
+#define QVIRTIO_F_RING_EVENT_IDX 0x20000000
+
+#define QVIRTIO_PCI_ALIGN 4096
+
typedef struct QVirtioPCIDevice {
QVirtioDevice vdev;
QPCIDevice *pdev;
diff --git a/tests/libqos/virtio.c b/tests/libqos/virtio.c
index 577d679..0e14bb3 100644
--- a/tests/libqos/virtio.c
+++ b/tests/libqos/virtio.c
@@ -8,6 +8,8 @@
*/
#include <glib.h>
+#include <stdio.h>
+#include <inttypes.h>
#include "libqtest.h"
#include "libqos/virtio.h"
@@ -53,3 +55,90 @@ void qvirtio_set_driver(const QVirtioBus *bus, QVirtioDevice
*d)
g_assert_cmphex(bus->get_status(d), ==,
QVIRTIO_DRIVER | QVIRTIO_ACKNOWLEDGE);
}
+
+void qvirtio_set_driver_ok(const QVirtioBus *bus, QVirtioDevice *d)
+{
+ bus->set_status(d, bus->get_status(d) | QVIRTIO_DRIVER_OK);
+ g_assert_cmphex(bus->get_status(d), ==,
+ QVIRTIO_DRIVER_OK | QVIRTIO_DRIVER | QVIRTIO_ACKNOWLEDGE);
+}
+
+int qvirtio_wait_isr(const QVirtioBus *bus, QVirtioDevice *d, uint8_t mask,
+ uint64_t timeout)
+{
+ do {
+ clock_step(10);
+ if (bus->get_isr_status(d) & mask) {
+ break; /* It has ended */
+ }
+ } while (--timeout);
+
+ if (timeout != 0) {
+ return 0;
+ } else {
+ return -1;
+ }
+}
+
+void qvring_init(const QGuestAllocator *alloc, QVirtQueue *vq, uint64_t addr)
+{
+ int i;
+
+ vq->desc = addr;
+ vq->avail = vq->desc + vq->size*sizeof(QVRingDesc);
+ vq->used = (uint64_t)((vq->avail + sizeof(uint16_t) * (3 + vq->size)
+ +vq->align-1) & ~(vq->align - 1));
+
+ for (i = 0; i < vq->size-1; i++) {
+ /* vq->desc[aux].addr */
+ writew(vq->desc+(16*i), 0);
+ /* vq->desc[aux].next */
+ writew(vq->desc+(16*i)+14, i+1);
+ }
+
+ /* vq->avail->flags */
+ writew(vq->avail, 0);
+ /* vq->avail->idx */
+ writew(vq->avail+2, 0);
+
+ /* vq->used->flags */
+ writew(vq->used, 0);
+}
+
+uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, int write,
+ int next)
+{
+ uint16_t flags = 0;
+ vq->num_free--;
+
+ if (write) {
+ flags |= QVRING_DESC_F_WRITE;
+ }
+
+ if (next) {
+ flags |= QVRING_DESC_F_NEXT;
+ }
+
+ /* vq->desc[vq->free_head].addr */
+ writeq(vq->desc+(16*vq->free_head), data);
+ /* vq->desc[vq->free_head].len */
+ writel(vq->desc+(16*vq->free_head)+8, len);
+ /* vq->desc[vq->free_head].flags */
+ writew(vq->desc+(16*vq->free_head)+12, flags);
+
+ return vq->free_head++; /* Return and increase, in this order */
+}
+
+void qvirtqueue_kick(const QVirtioBus *bus, QVirtioDevice *d, QVirtQueue *vq,
+ uint32_t free_head)
+{
+ /* vq->avail->idx */
+ uint32_t idx = readl(vq->avail+2);
+
+ /* vq->avail->ring[idx % vq->size] */
+ writel(vq->avail+4+(2*(idx % vq->size)), free_head);
+ /* vq->avail->idx */
+ writel(vq->avail+2, idx+1);
+
+ bus->virtqueue_kick(d, vq);
+}
diff --git a/tests/libqos/virtio.h b/tests/libqos/virtio.h
index 23e975b..1ac1fea 100644
--- a/tests/libqos/virtio.h
+++ b/tests/libqos/virtio.h
@@ -10,33 +10,111 @@
#ifndef LIBQOS_VIRTIO_H
#define LIBQOS_VIRTIO_H
+#include "libqos/malloc.h"
+
#define QVIRTIO_VENDOR_ID 0x1AF4
#define QVIRTIO_RESET 0x0
#define QVIRTIO_ACKNOWLEDGE 0x1
#define QVIRTIO_DRIVER 0x2
+#define QVIRTIO_DRIVER_OK 0x4
#define QVIRTIO_NET_DEVICE_ID 0x1
#define QVIRTIO_BLK_DEVICE_ID 0x2
+#define QVRING_DESC_F_NEXT 0x1
+#define QVRING_DESC_F_WRITE 0x2
+#define QVRING_DESC_F_INDIRECT 0x4
+
+#define QVRING_AVAIL_F_NO_INTERRUPT 1
+
+#define QVRING_USED_F_NO_NOTIFY 1
+
typedef struct QVirtioDevice {
/* Device type */
uint16_t device_type;
} QVirtioDevice;
+typedef struct QVRingDesc {
+ uint64_t addr;
+ uint32_t len;
+ uint16_t flags;
+ uint16_t next;
+} QVRingDesc;
+
+typedef struct QVRingAvail {
+ uint16_t flags;
+ uint16_t idx;
+ uint16_t ring[0]; /* This is an array of uint16_t */
+} QVRingAvail;
+
+typedef struct QVRingUsedElem {
+ uint32_t id;
+ uint32_t len;
+} QVRingUsedElem;
+
+typedef struct QVRingUsed {
+ uint16_t flags;
+ uint16_t idx;
+ QVRingUsedElem ring[0]; /* This is an array of QVRingUsedElem structs */
+} QVRingUsed;
+
+typedef struct QVirtQueue {
+ uint64_t desc; /* This points to an array of QVRingDesc */
+ uint64_t avail; /* This points to a QVRingAvail */
+ uint64_t used; /* This points to a QVRingDesc */
+ uint16_t index;
+ uint32_t size;
+ uint32_t free_head;
+ uint32_t num_free;
+ uint32_t align;
+} QVirtQueue;
+
typedef struct QVirtioBus {
uint8_t (*config_readb)(QVirtioDevice *d, void *addr);
uint16_t (*config_readw)(QVirtioDevice *d, void *addr);
uint32_t (*config_readl)(QVirtioDevice *d, void *addr);
uint64_t (*config_readq)(QVirtioDevice *d, void *addr);
+ /* Get features of the device */
+ uint32_t (*get_features)(QVirtioDevice *d);
+
+ /* Get features of the device */
+ void (*set_features)(QVirtioDevice *d, uint32_t features);
+
/* Get status of the device */
uint8_t (*get_status)(QVirtioDevice *d);
/* Set status of the device */
- void (*set_status)(QVirtioDevice *d, uint8_t val);
+ void (*set_status)(QVirtioDevice *d, uint8_t status);
+
+ /* Get the ISR status of the device */
+ uint8_t (*get_isr_status)(QVirtioDevice *d);
+
+ /* Select a queue to work on */
+ void (*queue_select)(QVirtioDevice *d, uint16_t index);
+
+ /* Get the size of the selected queue */
+ uint16_t (*get_queue_size)(QVirtioDevice *d);
+
+ /* Set the address of the selected queue */
+ void (*set_queue_address)(QVirtioDevice *d, uint32_t pfn);
+
+ /* Setup the virtqueue specified by index */
+ QVirtQueue *(*virtqueue_setup)(QVirtioDevice *d, QGuestAllocator *alloc,
+ uint16_t
index);
+
+ /* Notify changes in virtqueue */
+ void (*virtqueue_kick)(QVirtioDevice *d, QVirtQueue *vq);
} QVirtioBus;
+static inline unsigned qvring_size(uint32_t num, uint32_t align)
+{
+ return ((sizeof(struct QVRingDesc) * num + sizeof(uint16_t) * (3 + num)
+ + align - 1) & ~(align - 1))
+ + sizeof(uint16_t) * 3 + sizeof(struct QVRingUsedElem) * num;
+}
+
uint8_t qvirtio_config_readb(const QVirtioBus *bus, QVirtioDevice *d,
void *addr);
uint16_t qvirtio_config_readw(const QVirtioBus *bus, QVirtioDevice *d,
@@ -49,5 +127,15 @@ uint64_t qvirtio_config_readq(const QVirtioBus *bus,
QVirtioDevice *d,
void qvirtio_reset(const QVirtioBus *bus, QVirtioDevice *d);
void qvirtio_set_acknowledge(const QVirtioBus *bus, QVirtioDevice *d);
void qvirtio_set_driver(const QVirtioBus *bus, QVirtioDevice *d);
+void qvirtio_set_driver_ok(const QVirtioBus *bus, QVirtioDevice *d);
+
+int qvirtio_wait_isr(const QVirtioBus *bus, QVirtioDevice *d, uint8_t mask,
+ uint64_t timeout);
+
+void qvring_init(const QGuestAllocator *alloc, QVirtQueue *vq, uint64_t addr);
+uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, int write,
+ int next);
+void qvirtqueue_kick(const QVirtioBus *bus, QVirtioDevice *d, QVirtQueue *vq,
+ uint32_t
free_head);
#endif
diff --git a/tests/virtio-blk-test.c b/tests/virtio-blk-test.c
index 58fc2a7..2aad1d4 100644
--- a/tests/virtio-blk-test.c
+++ b/tests/virtio-blk-test.c
@@ -17,10 +17,40 @@
#include "libqos/virtio.h"
#include "libqos/virtio-pci.h"
#include "libqos/pci-pc.h"
-
-#define TEST_IMAGE_SIZE (64 * 1024 * 1024)
-#define PCI_SLOT 0x04
-#define PCI_FN 0x00
+#include "libqos/malloc.h"
+#include "libqos/malloc-pc.h"
+
+#define QVIRTIO_BLK_F_BARRIER 0x00000001
+#define QVIRTIO_BLK_F_SIZE_MAX 0x00000002
+#define QVIRTIO_BLK_F_SEG_MAX 0x00000004
+#define QVIRTIO_BLK_F_GEOMETRY 0x00000010
+#define QVIRTIO_BLK_F_RO 0x00000020
+#define QVIRTIO_BLK_F_BLK_SIZE 0x00000040
+#define QVIRTIO_BLK_F_SCSI 0x00000080
+#define QVIRTIO_BLK_F_WCE 0x00000200
+#define QVIRTIO_BLK_F_TOPOLOGY 0x00000400
+#define QVIRTIO_BLK_F_CONFIG_WCE 0x00000800
+
+#define QVIRTIO_BLK_T_IN 0
+#define QVIRTIO_BLK_T_OUT 1
+#define QVIRTIO_BLK_T_SCSI_CMD 2
+#define QVIRTIO_BLK_T_SCSI_CMD_OUT 3
+#define QVIRTIO_BLK_T_FLUSH 4
+#define QVIRTIO_BLK_T_FLUSH_OUT 5
+#define QVIRTIO_BLK_T_GET_ID 8
+
+#define TEST_IMAGE_SIZE (64 * 1024 * 1024)
+#define QVIRTIO_BLK_TIMEOUT 10000
+#define PCI_SLOT 0x04
+#define PCI_FN 0x00
+
+typedef struct QVirtioBlkReq {
+ uint32_t type;
+ uint32_t ioprio;
+ uint64_t sector;
+ uint8_t data[0];
+ uint8_t status;
+} QVirtioBlkReq;
static QPCIBus *test_start(void)
{
@@ -53,8 +83,17 @@ static void pci_basic(void)
{
QVirtioPCIDevice *dev;
QPCIBus *bus;
+ QVirtQueue *vq;
+ QGuestAllocator *alloc;
+ int isr_result;
void *addr;
+ uint64_t w_req;
+ uint64_t r_req;
uint64_t capacity;
+ uint32_t features;
+ uint32_t free_head;
+ uint8_t status;
+ char *data;
bus = test_start();
@@ -74,6 +113,114 @@ static void pci_basic(void)
capacity = qvirtio_config_readq(&qvirtio_pci, &dev->vdev, addr);
g_assert_cmpint(capacity, ==, TEST_IMAGE_SIZE/512);
+ features = qvirtio_pci.get_features(&dev->vdev);
+ features = features & ~(QVIRTIO_F_RING_INDIRECT_DESC |
+ QVIRTIO_F_RING_EVENT_IDX | QVIRTIO_BLK_F_SCSI);
+ qvirtio_pci.set_features(&dev->vdev, features);
+
+ alloc = pc_alloc_init();
+ vq = qvirtio_pci.virtqueue_setup(&dev->vdev, alloc, 0);
+
+ qvirtio_set_driver_ok(&qvirtio_pci, &dev->vdev);
+
+ /* Write and read with 2 descriptor layout */
+ data = g_malloc0(512);
+ strcpy(data, "TEST");
+
+ /* Write request */
+ w_req = guest_alloc(alloc, sizeof(QVirtioBlkReq)+512);
+ /* w_req->type */
+ writel(w_req, QVIRTIO_BLK_T_OUT);
+ /* w_req->ioprio */
+ writel(w_req+4, 1);
+ /* w_req->sector */
+ writeq(w_req+8, 0);
+ /* w_req->data */
+ memwrite(w_req+16, data, 512);
+ /* w_req->status */
+ writeb(w_req+528, 0xFF);
+
+ g_free(data);
+
+ free_head = qvirtqueue_add(vq, w_req, 528, 0, 1);
+ qvirtqueue_add(vq, w_req+528, 1, 1, 0);
+ qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head);
+
+ isr_result = qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1,
+ QVIRTIO_BLK_TIMEOUT);
+ g_assert_cmpint(isr_result, ==, 0);
+ status = readb(w_req+528);
+ g_assert_cmpint(status, ==, 0);
+
+ /* Read request */
+ r_req = guest_alloc(alloc, sizeof(QVirtioBlkReq)+512);
+ /* r_req->type */
+ writel(r_req, QVIRTIO_BLK_T_IN);
+ /* r_req->ioprio */
+ writel(r_req+4, 1);
+ /* r_req->sector */
+ writeq(r_req+8, 0);
+ /* r_req->status */
+ writeb(r_req+528, 0xFF);
+
+ free_head = qvirtqueue_add(vq, r_req, 16, 0, 1);
+ qvirtqueue_add(vq, r_req+16, 513, 1, 0);
+
+ qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head);
+
+ isr_result = qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1,
+ QVIRTIO_BLK_TIMEOUT);
+ g_assert_cmpint(isr_result, ==, 0);
+ status = readb(r_req+528);
+ g_assert_cmpint(status, ==, 0);
+
+ data = g_malloc0(512);
+ memread(r_req+16, data, 512);
+ g_assert_cmpstr(data, ==, "TEST");
+ g_free(data);
+
+ /* Write and read with 3 descriptor layout */
+ /* w_req->sector */
+ writeq(w_req+8, 1);
+ /* w_req->status */
+ writeb(w_req+528, 0xFF);
+
+ free_head = qvirtqueue_add(vq, w_req, 16, 0, 1);
+ qvirtqueue_add(vq, w_req+16, 512, 0, 1);
+ qvirtqueue_add(vq, w_req+528, 1, 1, 0);
+
+ qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head);
+
+ isr_result = qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1,
+ QVIRTIO_BLK_TIMEOUT);
+ g_assert_cmpint(isr_result, ==, 0);
+ status = readb(w_req+528);
+ g_assert_cmpint(status, ==, 0);
+
+ /* r_req->sector */
+ writeq(r_req+8, 1);
+ /* r_req->status */
+ writeb(r_req+528, 0xFF);
+
+ free_head = qvirtqueue_add(vq, r_req, 16, 0, 1);
+ qvirtqueue_add(vq, r_req+16, 512, 1, 1);
+ qvirtqueue_add(vq, r_req+528, 1, 1, 0);
+
+ qvirtqueue_kick(&qvirtio_pci, &dev->vdev, vq, free_head);
+
+ isr_result = qvirtio_wait_isr(&qvirtio_pci, &dev->vdev, 0x1,
+ QVIRTIO_BLK_TIMEOUT);
+ g_assert_cmpint(isr_result, ==, 0);
+ status = readb(w_req+528);
+ g_assert_cmpint(status, ==, 0);
+
+ data = g_malloc0(512);
+ memread(r_req+16, data, 512);
+ g_assert_cmpstr(data, ==, "TEST");
+ g_free(data);
+
+ /* End test */
+ guest_free(alloc, vq->desc);
qvirtio_pci_disable_device(dev);
g_free(dev);
test_end();
--
1.7.10.4
- [Qemu-devel] [PATCH v2 0/7] Virtio PCI libqos driver, Marc Marí, 2014/07/25
- [Qemu-devel] [PATCH v2 1/7] tests: Functions bus_foreach and device_find from libqos virtio API, Marc Marí, 2014/07/25
- [Qemu-devel] [PATCH v2 3/7] libqtest: add QTEST_LOG for debugging qtest testcases, Marc Marí, 2014/07/25
- [Qemu-devel] [PATCH v2 4/7] libqos: Correct mask to align size to PAGE_SIZE in malloc-pc, Marc Marí, 2014/07/25
- [Qemu-devel] [PATCH v2 2/7] tests: Add virtio device initialization, Marc Marí, 2014/07/25
- [Qemu-devel] [PATCH v2 5/7] libqos: Change free function called in malloc, Marc Marí, 2014/07/25
- [Qemu-devel] [PATCH v2 6/7] virtio-blk: Correct bug in support for flexible descriptor layout, Marc Marí, 2014/07/25
- [Qemu-devel] [PATCH v2 7/7] libqos: Added basic virtqueue support to virtio implementation,
Marc Marí <=