haraldwolff
/
qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tests: qtest: Add virtio-iommu test 

Add the framework to test the virtio-iommu-pci device
and tests exercising the attach/detach, map/unmap API.

Signed-off-by: Eric Auger <eric.auger@redhat.com>
Tested-by: Jean-Philippe Brucker <jean-philippe@linaro.org>
Reviewed-by: Jean-Philippe Brucker <jean-philippe@linaro.org>
Acked-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20211127072910.1261824-5-eric.auger@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>
staging
Eric Auger 2021-11-27 08:29:10 +01:00 committed by Thomas Huth
parent 6b77ae0531
commit becf88730b
5 changed files with 494 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tests/qtest/libqos/meson.build
View File

@ -41,6 +41,7 @@ libqos_srcs = files('../libqtest.c',
'virtio-rng.c',
'virtio-scsi.c',
'virtio-serial.c',
'virtio-iommu.c',
# qgraph machines:
'aarch64-xlnx-zcu102-machine.c',

126
tests/qtest/libqos/virtio-iommu.c 100644
View File

@ -0,0 +1,126 @@
/*
* libqos driver virtio-iommu-pci framework
*
* Copyright (c) 2021 Red Hat, Inc.
*
* Authors:
* Eric Auger <eric.auger@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or (at your
* option) any later version. See the COPYING file in the top-level directory.
*
*/
#include "qemu/osdep.h"
#include "libqtest.h"
#include "qemu/module.h"
#include "qgraph.h"
#include "virtio-iommu.h"
#include "hw/virtio/virtio-iommu.h"
static QGuestAllocator *alloc;
/* virtio-iommu-device */
static void *qvirtio_iommu_get_driver(QVirtioIOMMU *v_iommu,
const char *interface)
{
if (!g_strcmp0(interface, "virtio-iommu")) {
return v_iommu;
}
if (!g_strcmp0(interface, "virtio")) {
return v_iommu->vdev;
}
fprintf(stderr, "%s not present in virtio-iommu-device\n", interface);
g_assert_not_reached();
}
static void virtio_iommu_cleanup(QVirtioIOMMU *interface)
{
qvirtqueue_cleanup(interface->vdev->bus, interface->vq, alloc);
}
static void virtio_iommu_setup(QVirtioIOMMU *interface)
{
QVirtioDevice *vdev = interface->vdev;
uint64_t features;
features = qvirtio_get_features(vdev);
features &= ~(QVIRTIO_F_BAD_FEATURE |
(1ull << VIRTIO_RING_F_INDIRECT_DESC) |
(1ull << VIRTIO_RING_F_EVENT_IDX) |
(1ull << VIRTIO_IOMMU_F_BYPASS));
qvirtio_set_features(vdev, features);
interface->vq = qvirtqueue_setup(interface->vdev, alloc, 0);
qvirtio_set_driver_ok(interface->vdev);
}
/* virtio-iommu-pci */
static void *qvirtio_iommu_pci_get_driver(void *object, const char *interface)
{
QVirtioIOMMUPCI *v_iommu = object;
if (!g_strcmp0(interface, "pci-device")) {
return v_iommu->pci_vdev.pdev;
}
return qvirtio_iommu_get_driver(&v_iommu->iommu, interface);
}
static void qvirtio_iommu_pci_destructor(QOSGraphObject *obj)
{
QVirtioIOMMUPCI *iommu_pci = (QVirtioIOMMUPCI *) obj;
QVirtioIOMMU *interface = &iommu_pci->iommu;
QOSGraphObject *pci_vobj = &iommu_pci->pci_vdev.obj;
virtio_iommu_cleanup(interface);
qvirtio_pci_destructor(pci_vobj);
}
static void qvirtio_iommu_pci_start_hw(QOSGraphObject *obj)
{
QVirtioIOMMUPCI *iommu_pci = (QVirtioIOMMUPCI *) obj;
QVirtioIOMMU *interface = &iommu_pci->iommu;
QOSGraphObject *pci_vobj = &iommu_pci->pci_vdev.obj;
qvirtio_pci_start_hw(pci_vobj);
virtio_iommu_setup(interface);
}
static void *virtio_iommu_pci_create(void *pci_bus, QGuestAllocator *t_alloc,
void *addr)
{
QVirtioIOMMUPCI *virtio_rpci = g_new0(QVirtioIOMMUPCI, 1);
QVirtioIOMMU *interface = &virtio_rpci->iommu;
QOSGraphObject *obj = &virtio_rpci->pci_vdev.obj;
virtio_pci_init(&virtio_rpci->pci_vdev, pci_bus, addr);
interface->vdev = &virtio_rpci->pci_vdev.vdev;
alloc = t_alloc;
obj->get_driver = qvirtio_iommu_pci_get_driver;
obj->start_hw = qvirtio_iommu_pci_start_hw;
obj->destructor = qvirtio_iommu_pci_destructor;
return obj;
}
static void virtio_iommu_register_nodes(void)
{
QPCIAddress addr = {
.devfn = QPCI_DEVFN(4, 0),
};
QOSGraphEdgeOptions opts = {
.extra_device_opts = "addr=04.0",
};
/* virtio-iommu-pci */
add_qpci_address(&opts, &addr);
qos_node_create_driver("virtio-iommu-pci", virtio_iommu_pci_create);
qos_node_consumes("virtio-iommu-pci", "pci-bus", &opts);
qos_node_produces("virtio-iommu-pci", "pci-device");
qos_node_produces("virtio-iommu-pci", "virtio");
qos_node_produces("virtio-iommu-pci", "virtio-iommu");
}
libqos_init(virtio_iommu_register_nodes);

40
tests/qtest/libqos/virtio-iommu.h 100644
View File

@ -0,0 +1,40 @@
/*
* libqos driver virtio-iommu-pci framework
*
* Copyright (c) 2021 Red Hat, Inc.
*
* Authors:
* Eric Auger <eric.auger@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or (at your
* option) any later version. See the COPYING file in the top-level directory.
*
*/
#ifndef TESTS_LIBQOS_VIRTIO_IOMMU_H
#define TESTS_LIBQOS_VIRTIO_IOMMU_H
#include "qgraph.h"
#include "virtio.h"
#include "virtio-pci.h"
typedef struct QVirtioIOMMU QVirtioIOMMU;
typedef struct QVirtioIOMMUPCI QVirtioIOMMUPCI;
typedef struct QVirtioIOMMUDevice QVirtioIOMMUDevice;
struct QVirtioIOMMU {
QVirtioDevice *vdev;
QVirtQueue *vq;
};
struct QVirtioIOMMUPCI {
QVirtioPCIDevice pci_vdev;
QVirtioIOMMU iommu;
};
struct QVirtioIOMMUDevice {
QOSGraphObject obj;
QVirtioIOMMU iommu;
};
#endif

1
tests/qtest/meson.build
View File

@ -234,6 +234,7 @@ qos_test_ss.add(
'virtio-rng-test.c',
'virtio-scsi-test.c',
'virtio-serial-test.c',
'virtio-iommu-test.c',
'vmxnet3-test.c',
)
if have_virtfs

326
tests/qtest/virtio-iommu-test.c 100644
View File

@ -0,0 +1,326 @@
/*
* QTest testcase for VirtIO IOMMU
*
* Copyright (c) 2021 Red Hat, Inc.
*
* Authors:
* Eric Auger <eric.auger@redhat.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or (at your
* option) any later version. See the COPYING file in the top-level directory.
*
*/
#include "qemu/osdep.h"
#include "libqtest-single.h"
#include "qemu/module.h"
#include "libqos/qgraph.h"
#include "libqos/virtio-iommu.h"
#include "hw/virtio/virtio-iommu.h"
#define PCI_SLOT_HP 0x06
#define QVIRTIO_IOMMU_TIMEOUT_US (30 * 1000 * 1000)
static QGuestAllocator *alloc;
static void pci_config(void *obj, void *data, QGuestAllocator *t_alloc)
{
QVirtioIOMMU *v_iommu = obj;
QVirtioDevice *dev = v_iommu->vdev;
uint64_t input_range_start = qvirtio_config_readq(dev, 8);
uint64_t input_range_end = qvirtio_config_readq(dev, 16);
uint32_t domain_range_start = qvirtio_config_readl(dev, 24);
uint32_t domain_range_end = qvirtio_config_readl(dev, 28);
g_assert_cmpint(input_range_start, ==, 0);
g_assert_cmphex(input_range_end, ==, UINT64_MAX);
g_assert_cmpint(domain_range_start, ==, 0);
g_assert_cmpint(domain_range_end, ==, UINT32_MAX);
}
static int read_tail_status(struct virtio_iommu_req_tail *buffer)
{
int i;
for (i = 0; i < 3; i++) {
g_assert_cmpint(buffer->reserved[i], ==, 0);
}
return buffer->status;
}
/**
* send_attach_detach - Send an attach/detach command to the device
* @type: VIRTIO_IOMMU_T_ATTACH/VIRTIO_IOMMU_T_DETACH
* @domain: domain the endpoint is attached to
* @ep: endpoint
*/
static int send_attach_detach(QTestState *qts, QVirtioIOMMU *v_iommu,
uint8_t type, uint32_t domain, uint32_t ep)
{
QVirtioDevice *dev = v_iommu->vdev;
QVirtQueue *vq = v_iommu->vq;
uint64_t ro_addr, wr_addr;
uint32_t free_head;
struct virtio_iommu_req_attach req = {}; /* same layout as detach */
size_t ro_size = sizeof(req) - sizeof(struct virtio_iommu_req_tail);
size_t wr_size = sizeof(struct virtio_iommu_req_tail);
struct virtio_iommu_req_tail buffer;
int ret;
req.head.type = type;
req.domain = cpu_to_le32(domain);
req.endpoint = cpu_to_le32(ep);
ro_addr = guest_alloc(alloc, ro_size);
wr_addr = guest_alloc(alloc, wr_size);
qtest_memwrite(qts, ro_addr, &req, ro_size);
free_head = qvirtqueue_add(qts, vq, ro_addr, ro_size, false, true);
qvirtqueue_add(qts, vq, wr_addr, wr_size, true, false);
qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_IOMMU_TIMEOUT_US);
qtest_memread(qts, wr_addr, &buffer, wr_size);
ret = read_tail_status(&buffer);
guest_free(alloc, ro_addr);
guest_free(alloc, wr_addr);
return ret;
}
/**
* send_map - Send a map command to the device
* @domain: domain the new mapping is attached to
* @virt_start: iova start
* @virt_end: iova end
* @phys_start: base physical address
* @flags: mapping flags
*/
static int send_map(QTestState *qts, QVirtioIOMMU *v_iommu,
uint32_t domain, uint64_t virt_start, uint64_t virt_end,
uint64_t phys_start, uint32_t flags)
{
QVirtioDevice *dev = v_iommu->vdev;
QVirtQueue *vq = v_iommu->vq;
uint64_t ro_addr, wr_addr;
uint32_t free_head;
struct virtio_iommu_req_map req;
size_t ro_size = sizeof(req) - sizeof(struct virtio_iommu_req_tail);
size_t wr_size = sizeof(struct virtio_iommu_req_tail);
struct virtio_iommu_req_tail buffer;
int ret;
req.head.type = VIRTIO_IOMMU_T_MAP;
req.domain = cpu_to_le32(domain);
req.virt_start = cpu_to_le64(virt_start);
req.virt_end = cpu_to_le64(virt_end);
req.phys_start = cpu_to_le64(phys_start);
req.flags = cpu_to_le32(flags);
ro_addr = guest_alloc(alloc, ro_size);
wr_addr = guest_alloc(alloc, wr_size);
qtest_memwrite(qts, ro_addr, &req, ro_size);
free_head = qvirtqueue_add(qts, vq, ro_addr, ro_size, false, true);
qvirtqueue_add(qts, vq, wr_addr, wr_size, true, false);
qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_IOMMU_TIMEOUT_US);
qtest_memread(qts, wr_addr, &buffer, wr_size);
ret = read_tail_status(&buffer);
guest_free(alloc, ro_addr);
guest_free(alloc, wr_addr);
return ret;
}
/**
* send_unmap - Send an unmap command to the device
* @domain: domain the new binding is attached to
* @virt_start: iova start
* @virt_end: iova end
*/
static int send_unmap(QTestState *qts, QVirtioIOMMU *v_iommu,
uint32_t domain, uint64_t virt_start, uint64_t virt_end)
{
QVirtioDevice *dev = v_iommu->vdev;
QVirtQueue *vq = v_iommu->vq;
uint64_t ro_addr, wr_addr;
uint32_t free_head;
struct virtio_iommu_req_unmap req;
size_t ro_size = sizeof(req) - sizeof(struct virtio_iommu_req_tail);
size_t wr_size = sizeof(struct virtio_iommu_req_tail);
struct virtio_iommu_req_tail buffer;
int ret;
req.head.type = VIRTIO_IOMMU_T_UNMAP;
req.domain = cpu_to_le32(domain);
req.virt_start = cpu_to_le64(virt_start);
req.virt_end = cpu_to_le64(virt_end);
ro_addr = guest_alloc(alloc, ro_size);
wr_addr = guest_alloc(alloc, wr_size);
qtest_memwrite(qts, ro_addr, &req, ro_size);
free_head = qvirtqueue_add(qts, vq, ro_addr, ro_size, false, true);
qvirtqueue_add(qts, vq, wr_addr, wr_size, true, false);
qvirtqueue_kick(qts, dev, vq, free_head);
qvirtio_wait_used_elem(qts, dev, vq, free_head, NULL,
QVIRTIO_IOMMU_TIMEOUT_US);
qtest_memread(qts, wr_addr, &buffer, wr_size);
ret = read_tail_status(&buffer);
guest_free(alloc, ro_addr);
guest_free(alloc, wr_addr);
return ret;
}
static void test_attach_detach(void *obj, void *data, QGuestAllocator *t_alloc)
{
QVirtioIOMMU *v_iommu = obj;
QTestState *qts = global_qtest;
int ret;
alloc = t_alloc;
/* type, domain, ep */
/* attach ep0 to domain 0 */
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_ATTACH, 0, 0);
g_assert_cmpint(ret, ==, 0);
/* attach a non existing device */
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_ATTACH, 0, 444);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_NOENT);
/* detach a non existing device (1) */
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_DETACH, 0, 1);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_NOENT);
/* move ep0 from domain 0 to domain 1 */
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_ATTACH, 1, 0);
g_assert_cmpint(ret, ==, 0);
/* detach ep0 from domain 0 */
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_DETACH, 0, 0);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_INVAL);
/* detach ep0 from domain 1 */
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_DETACH, 1, 0);
g_assert_cmpint(ret, ==, 0);
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_ATTACH, 1, 0);
g_assert_cmpint(ret, ==, 0);
ret = send_map(qts, v_iommu, 1, 0x0, 0xFFF, 0xa1000,
VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_map(qts, v_iommu, 1, 0x2000, 0x2FFF, 0xb1000,
VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_DETACH, 1, 0);
g_assert_cmpint(ret, ==, 0);
}
/* Test map/unmap scenari documented in the spec */
static void test_map_unmap(void *obj, void *data, QGuestAllocator *t_alloc)
{
QVirtioIOMMU *v_iommu = obj;
QTestState *qts = global_qtest;
int ret;
alloc = t_alloc;
/* attach ep0 to domain 1 */
ret = send_attach_detach(qts, v_iommu, VIRTIO_IOMMU_T_ATTACH, 1, 0);
g_assert_cmpint(ret, ==, 0);
ret = send_map(qts, v_iommu, 0, 0, 0xFFF, 0xa1000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_NOENT);
/* domain, virt start, virt end, phys start, flags */
ret = send_map(qts, v_iommu, 1, 0x0, 0xFFF, 0xa1000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
/* send a new mapping overlapping the previous one */
ret = send_map(qts, v_iommu, 1, 0, 0xFFFF, 0xb1000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_INVAL);
ret = send_unmap(qts, v_iommu, 4, 0x10, 0xFFF);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_NOENT);
ret = send_unmap(qts, v_iommu, 1, 0x10, 0xFFF);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_RANGE);
ret = send_unmap(qts, v_iommu, 1, 0, 0x1000);
g_assert_cmpint(ret, ==, 0); /* unmap everything */
/* Spec example sequence */
/* 1 */
ret = send_unmap(qts, v_iommu, 1, 0, 4);
g_assert_cmpint(ret, ==, 0); /* doesn't unmap anything */
/* 2 */
ret = send_map(qts, v_iommu, 1, 0, 9, 0xa1000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_unmap(qts, v_iommu, 1, 0, 9);
g_assert_cmpint(ret, ==, 0); /* unmaps [0,9] */
/* 3 */
ret = send_map(qts, v_iommu, 1, 0, 4, 0xb1000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_map(qts, v_iommu, 1, 5, 9, 0xb2000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_unmap(qts, v_iommu, 1, 0, 9);
g_assert_cmpint(ret, ==, 0); /* unmaps [0,4] and [5,9] */
/* 4 */
ret = send_map(qts, v_iommu, 1, 0, 9, 0xc1000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_unmap(qts, v_iommu, 1, 0, 4);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_RANGE); /* doesn't unmap anything */
ret = send_unmap(qts, v_iommu, 1, 0, 10);
g_assert_cmpint(ret, ==, 0);
/* 5 */
ret = send_map(qts, v_iommu, 1, 0, 4, 0xd1000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_map(qts, v_iommu, 1, 5, 9, 0xd2000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_unmap(qts, v_iommu, 1, 0, 4);
g_assert_cmpint(ret, ==, 0); /* unmaps [0,4] */
ret = send_unmap(qts, v_iommu, 1, 5, 9);
g_assert_cmpint(ret, ==, 0);
/* 6 */
ret = send_map(qts, v_iommu, 1, 0, 4, 0xe2000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_unmap(qts, v_iommu, 1, 0, 9);
g_assert_cmpint(ret, ==, 0); /* unmaps [0,4] */
/* 7 */
ret = send_map(qts, v_iommu, 1, 0, 4, 0xf2000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_map(qts, v_iommu, 1, 10, 14, 0xf3000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_unmap(qts, v_iommu, 1, 0, 14);
g_assert_cmpint(ret, ==, 0); /* unmaps [0,4] and [10,14] */
ret = send_map(qts, v_iommu, 1, 10, 14, 0xf3000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_map(qts, v_iommu, 1, 0, 4, 0xf2000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, 0);
ret = send_unmap(qts, v_iommu, 1, 0, 4);
g_assert_cmpint(ret, ==, 0); /* only unmaps [0,4] */
ret = send_map(qts, v_iommu, 1, 10, 14, 0xf3000, VIRTIO_IOMMU_MAP_F_READ);
g_assert_cmpint(ret, ==, VIRTIO_IOMMU_S_INVAL); /* 10-14 still is mapped */
}
static void register_virtio_iommu_test(void)
{
qos_add_test("config", "virtio-iommu", pci_config, NULL);
qos_add_test("attach_detach", "virtio-iommu", test_attach_detach, NULL);
qos_add_test("map_unmap", "virtio-iommu", test_map_unmap, NULL);
}
libqos_init(register_virtio_iommu_test);