* [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device
@ 2018-08-06 20:14 Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 01/16] linux-headers: Partial update for virtio-iommu v0.7 Eric Auger
` (15 more replies)
0 siblings, 16 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This series rebases the virtio-iommu device on qemu 3.0.0-rc3
and implements the v0.7 virtio-iommu spec [1]. This is a basic
upgrade as the fate of the virtio mmio based solution is unclear.
It also fixes a bug when the end-points are not attached to the
root bus.
Important notice: the way the virtio-iommu is instantiated was
changed to fit the way the smmuv3 is, ie. using a virt machine
option: ",iommu=virtio".
Best Regards
Eric
This series can be found at:
https://github.com/eauger/qemu/tree/v3.0.0-rc3-virtio-iommu-v0.7
References:
[1] [RFC] virtio-iommu version 0.7
git://linux-arm.org/virtio-iommu.git viommu/v0.7
[2] guest branch featuring the virtio-iommu driver v0.7
https://github.com/eauger/linux/tree/v4.18-rc1-virtio-iommu-v0.7-acpi
Testing:
- tested with guest using virtio-net-pci
(,vhost=off,iommu_platform,disable-modern=off,disable-legacy=on)
and virtio-blk-pci
- VFIO/VHOST integration is not part of this series
History:
v6 -> v7:
- rebase on qemu 3.0.0-rc3
- minor update against v0.7
- fix issue with EP not on pci.0 and ACPI probing
- change the instantiation method
v5 -> v6:
- minor update against v0.6 spec
- fix g_hash_table_lookup in virtio_iommu_find_add_as
- replace some error_reports by qemu_log_mask(LOG_GUEST_ERROR, ...)
v4 -> v5:
- event queue and fault reporting
- we now return the IOAPIC MSI region if the virtio-iommu is instantiated
in a PC machine.
- we bypass transactions on MSI HW region and fault on reserved ones.
- We support ACPI boot with mach-virt (based on IORT proposal)
- We moved to the new driver naming conventions
- simplified mach-virt instantiation
- worked around the disappearing of pci_find_primary_bus
- in virtio_iommu_translate, check the dev->as is not NULL
- initialize as->device_list in virtio_iommu_get_as
- initialize bufstate.error to false in virtio_iommu_probe
v3 -> v4:
- probe request support although no reserved region is returned at
the moment
- unmap semantics less strict, as specified in v0.4
- device registration, attach/detach revisited
- split into smaller patches to ease review
- propose a way to inform the IOMMU mr about the page_size_mask
of underlying HW IOMMU, if any
- remove warning associated with the translation of the MSI doorbell
v2 -> v3:
- rebase on top of 2.10-rc0 and especially
[PATCH qemu v9 0/2] memory/iommu: QOM'fy IOMMU MemoryRegion
- add mutex init
- fix as->mappings deletion using g_tree_ref/unref
- when a dev is attached whereas it is already attached to
another address space, first detach it
- fix some error values
- page_sizes = TARGET_PAGE_MASK;
- I haven't changed the unmap() semantics yet, waiting for the
next virtio-iommu spec revision.
v1 -> v2:
- fix redifinition of viommu_as typedef
Eric Auger (16):
linux-headers: Partial update for virtio-iommu v0.7
virtio-iommu: Add skeleton
virtio-iommu: Decode the command payload
virtio-iommu: Add the iommu regions
virtio-iommu: Endpoint and domains structs and helpers
virtio-iommu: Implement attach/detach command
virtio-iommu: Implement map/unmap
virtio-iommu: Implement translate
virtio-iommu: Implement probe request
virtio-iommu: Add an msi_bypass property
virtio-iommu: Implement fault reporting
virtio_iommu: Handle reserved regions in translation process
qdev: export qbus_find_recursive
hw/arm/virt: Add virtio-iommu to the virt board
hw/arm/virt-acpi-build: Add virtio-iommu node in IORT table
hw/arm/virt: Allow virtio-iommu instantiation
hw/arm/virt-acpi-build.c | 39 +-
hw/arm/virt.c | 59 +-
hw/virtio/Makefile.objs | 1 +
hw/virtio/trace-events | 24 +
hw/virtio/virtio-iommu.c | 1041 +++++++++++++++++++++++++
include/hw/acpi/acpi-defs.h | 21 +-
include/hw/arm/virt.h | 1 +
include/hw/qdev-core.h | 3 +
include/hw/virtio/virtio-iommu.h | 64 ++
include/standard-headers/linux/virtio_ids.h | 1 +
include/standard-headers/linux/virtio_iommu.h | 172 ++++
linux-headers/linux/virtio_iommu.h | 1 +
qdev-monitor.c | 5 +-
13 files changed, 1418 insertions(+), 14 deletions(-)
create mode 100644 hw/virtio/virtio-iommu.c
create mode 100644 include/hw/virtio/virtio-iommu.h
create mode 100644 include/standard-headers/linux/virtio_iommu.h
create mode 100644 linux-headers/linux/virtio_iommu.h
--
2.5.5
^ permalink raw reply [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 01/16] linux-headers: Partial update for virtio-iommu v0.7
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 02/16] virtio-iommu: Add skeleton Eric Auger
` (14 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
Partial sync against Jean-Philippe's branch:
git://linux-arm.org/linux-jpb.git virtio-iommu/v0.7
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
include/standard-headers/linux/virtio_ids.h | 1 +
include/standard-headers/linux/virtio_iommu.h | 172 ++++++++++++++++++++++++++
| 1 +
3 files changed, 174 insertions(+)
create mode 100644 include/standard-headers/linux/virtio_iommu.h
create mode 100644 linux-headers/linux/virtio_iommu.h
diff --git a/include/standard-headers/linux/virtio_ids.h b/include/standard-headers/linux/virtio_ids.h
index 6d5c3b2..cfe47c5 100644
--- a/include/standard-headers/linux/virtio_ids.h
+++ b/include/standard-headers/linux/virtio_ids.h
@@ -43,5 +43,6 @@
#define VIRTIO_ID_INPUT 18 /* virtio input */
#define VIRTIO_ID_VSOCK 19 /* virtio vsock transport */
#define VIRTIO_ID_CRYPTO 20 /* virtio crypto */
+#define VIRTIO_ID_IOMMU 23 /* virtio IOMMU */
#endif /* _LINUX_VIRTIO_IDS_H */
diff --git a/include/standard-headers/linux/virtio_iommu.h b/include/standard-headers/linux/virtio_iommu.h
new file mode 100644
index 0000000..a233206
--- /dev/null
+++ b/include/standard-headers/linux/virtio_iommu.h
@@ -0,0 +1,172 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/*
+ * Virtio-iommu definition v0.7
+ *
+ * Copyright (C) 2018 Arm Ltd.
+ */
+#ifndef _LINUX_VIRTIO_IOMMU_H
+#define _LINUX_VIRTIO_IOMMU_H
+
+#include "standard-headers/linux/types.h"
+
+/* Feature bits */
+#define VIRTIO_IOMMU_F_INPUT_RANGE 0
+#define VIRTIO_IOMMU_F_DOMAIN_BITS 1
+#define VIRTIO_IOMMU_F_MAP_UNMAP 2
+#define VIRTIO_IOMMU_F_BYPASS 3
+#define VIRTIO_IOMMU_F_PROBE 4
+
+struct virtio_iommu_config {
+ /* Supported page sizes */
+ uint64_t page_size_mask;
+ /* Supported IOVA range */
+ struct virtio_iommu_range {
+ uint64_t start;
+ uint64_t end;
+ } input_range;
+ /* Max domain ID size */
+ uint8_t domain_bits;
+ uint8_t padding[3];
+ /* Probe buffer size */
+ uint32_t probe_size;
+} QEMU_PACKED;
+
+/* Request types */
+#define VIRTIO_IOMMU_T_ATTACH 0x01
+#define VIRTIO_IOMMU_T_DETACH 0x02
+#define VIRTIO_IOMMU_T_MAP 0x03
+#define VIRTIO_IOMMU_T_UNMAP 0x04
+#define VIRTIO_IOMMU_T_PROBE 0x05
+
+/* Status types */
+#define VIRTIO_IOMMU_S_OK 0x00
+#define VIRTIO_IOMMU_S_IOERR 0x01
+#define VIRTIO_IOMMU_S_UNSUPP 0x02
+#define VIRTIO_IOMMU_S_DEVERR 0x03
+#define VIRTIO_IOMMU_S_INVAL 0x04
+#define VIRTIO_IOMMU_S_RANGE 0x05
+#define VIRTIO_IOMMU_S_NOENT 0x06
+#define VIRTIO_IOMMU_S_FAULT 0x07
+
+struct virtio_iommu_req_head {
+ uint8_t type;
+ uint8_t reserved[3];
+} QEMU_PACKED;
+
+struct virtio_iommu_req_tail {
+ uint8_t status;
+ uint8_t reserved[3];
+} QEMU_PACKED;
+
+struct virtio_iommu_req_attach {
+ struct virtio_iommu_req_head head;
+
+ uint32_t domain;
+ uint32_t endpoint;
+ uint32_t reserved;
+
+ struct virtio_iommu_req_tail tail;
+} QEMU_PACKED;
+
+struct virtio_iommu_req_detach {
+ struct virtio_iommu_req_head head;
+
+ uint32_t endpoint;
+ uint32_t reserved;
+
+ struct virtio_iommu_req_tail tail;
+} QEMU_PACKED;
+
+#define VIRTIO_IOMMU_MAP_F_READ (1 << 0)
+#define VIRTIO_IOMMU_MAP_F_WRITE (1 << 1)
+#define VIRTIO_IOMMU_MAP_F_EXEC (1 << 2)
+#define VIRTIO_IOMMU_MAP_F_MMIO (1 << 3)
+
+#define VIRTIO_IOMMU_MAP_F_MASK (VIRTIO_IOMMU_MAP_F_READ | \
+ VIRTIO_IOMMU_MAP_F_WRITE | \
+ VIRTIO_IOMMU_MAP_F_EXEC | \
+ VIRTIO_IOMMU_MAP_F_MMIO)
+
+struct virtio_iommu_req_map {
+ struct virtio_iommu_req_head head;
+
+ uint32_t domain;
+ uint64_t virt_start;
+ uint64_t virt_end;
+ uint64_t phys_start;
+ uint32_t flags;
+
+ struct virtio_iommu_req_tail tail;
+} QEMU_PACKED;
+
+struct virtio_iommu_req_unmap {
+ struct virtio_iommu_req_head head;
+
+ uint32_t domain;
+ uint64_t virt_start;
+ uint64_t virt_end;
+ uint32_t reserved;
+
+ struct virtio_iommu_req_tail tail;
+} QEMU_PACKED;
+
+#define VIRTIO_IOMMU_RESV_MEM_T_RESERVED 0
+#define VIRTIO_IOMMU_RESV_MEM_T_MSI 1
+
+struct virtio_iommu_probe_resv_mem {
+ uint8_t subtype;
+ uint8_t reserved[3];
+ uint64_t start;
+ uint64_t end;
+} QEMU_PACKED;
+
+#define VIRTIO_IOMMU_PROBE_T_NONE 0
+#define VIRTIO_IOMMU_PROBE_T_RESV_MEM 1
+
+#define VIRTIO_IOMMU_PROBE_T_MASK 0xfff
+
+struct virtio_iommu_probe_property {
+ uint16_t type;
+ uint16_t length;
+ uint8_t value[];
+} QEMU_PACKED;
+
+struct virtio_iommu_req_probe {
+ struct virtio_iommu_req_head head;
+ uint32_t endpoint;
+ uint8_t reserved[64];
+
+ uint8_t properties[];
+
+ /* Tail follows the variable-length properties array (no padding) */
+} QEMU_PACKED;
+
+union virtio_iommu_req {
+ struct virtio_iommu_req_head head;
+
+ struct virtio_iommu_req_attach attach;
+ struct virtio_iommu_req_detach detach;
+ struct virtio_iommu_req_map map;
+ struct virtio_iommu_req_unmap unmap;
+ struct virtio_iommu_req_probe probe;
+};
+
+/* Fault types */
+#define VIRTIO_IOMMU_FAULT_R_UNKNOWN 0
+#define VIRTIO_IOMMU_FAULT_R_DOMAIN 1
+#define VIRTIO_IOMMU_FAULT_R_MAPPING 2
+
+#define VIRTIO_IOMMU_FAULT_F_READ (1 << 0)
+#define VIRTIO_IOMMU_FAULT_F_WRITE (1 << 1)
+#define VIRTIO_IOMMU_FAULT_F_EXEC (1 << 2)
+#define VIRTIO_IOMMU_FAULT_F_ADDRESS (1 << 8)
+
+struct virtio_iommu_fault {
+ uint8_t reason;
+ uint8_t padding[3];
+ uint32_t flags;
+ uint32_t endpoint;
+ uint64_t address;
+} QEMU_PACKED;
+
+#endif
--git a/linux-headers/linux/virtio_iommu.h b/linux-headers/linux/virtio_iommu.h
new file mode 100644
index 0000000..2dc4609
--- /dev/null
+++ b/linux-headers/linux/virtio_iommu.h
@@ -0,0 +1 @@
+#include "standard-headers/linux/virtio_iommu.h"
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 02/16] virtio-iommu: Add skeleton
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 01/16] linux-headers: Partial update for virtio-iommu v0.7 Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 03/16] virtio-iommu: Decode the command payload Eric Auger
` (13 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patchs adds the skeleton for the virtio-iommu device.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
v6 -> v7:
- removed qapi-event.h include
- add primary_bus and associated property
v4 -> v5:
- use the new v0.5 terminology (domain, endpoint)
- add the event virtqueue
v3 -> v4:
- use page_size_mask instead of page_sizes
- added set_features()
- added some traces (reset, set_status, set_features)
- empty virtio_iommu_set_config() as the driver MUST NOT
write to device configuration fields
- add get_config trace
v2 -> v3:
- rebase on 2.10-rc0, ie. use IOMMUMemoryRegion and remove
iommu_ops.
- advertise VIRTIO_IOMMU_F_MAP_UNMAP feature
- page_sizes set to TARGET_PAGE_SIZE
Conflicts:
hw/virtio/trace-events
---
hw/virtio/Makefile.objs | 1 +
hw/virtio/trace-events | 7 ++
hw/virtio/virtio-iommu.c | 256 +++++++++++++++++++++++++++++++++++++++
include/hw/virtio/virtio-iommu.h | 61 ++++++++++
4 files changed, 325 insertions(+)
create mode 100644 hw/virtio/virtio-iommu.c
create mode 100644 include/hw/virtio/virtio-iommu.h
diff --git a/hw/virtio/Makefile.objs b/hw/virtio/Makefile.objs
index 1b2799c..49eba67 100644
--- a/hw/virtio/Makefile.objs
+++ b/hw/virtio/Makefile.objs
@@ -10,6 +10,7 @@ obj-$(CONFIG_VIRTIO_CRYPTO) += virtio-crypto.o
obj-$(call land,$(CONFIG_VIRTIO_CRYPTO),$(CONFIG_VIRTIO_PCI)) += virtio-crypto-pci.o
obj-$(CONFIG_LINUX) += vhost.o vhost-backend.o vhost-user.o
+obj-$(CONFIG_LINUX) += virtio-iommu.o
obj-$(CONFIG_VHOST_VSOCK) += vhost-vsock.o
endif
diff --git a/hw/virtio/trace-events b/hw/virtio/trace-events
index 07bcbe9..01dc20f 100644
--- a/hw/virtio/trace-events
+++ b/hw/virtio/trace-events
@@ -46,3 +46,10 @@ virtio_balloon_handle_output(const char *name, uint64_t gpa) "section name: %s g
virtio_balloon_get_config(uint32_t num_pages, uint32_t actual) "num_pages: %d actual: %d"
virtio_balloon_set_config(uint32_t actual, uint32_t oldactual) "actual: %d oldactual: %d"
virtio_balloon_to_target(uint64_t target, uint32_t num_pages) "balloon target: 0x%"PRIx64" num_pages: %d"
+
+# hw/virtio/virtio-iommu.c
+#
+virtio_iommu_set_features(uint64_t features) "features accepted by the driver =0x%"PRIx64
+virtio_iommu_device_reset(void) "reset!"
+virtio_iommu_device_status(uint8_t status) "driver status = %d"
+virtio_iommu_get_config(uint64_t page_size_mask, uint64_t start, uint64_t end, uint8_t ioasid_bits, uint32_t probe_size) "page_size_mask=0x%"PRIx64" start=0x%"PRIx64" end=0x%"PRIx64" ioasid_bits=%d probe_size=0x%x"
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
new file mode 100644
index 0000000..34c7584
--- /dev/null
+++ b/hw/virtio/virtio-iommu.c
@@ -0,0 +1,256 @@
+/*
+ * virtio-iommu device
+ *
+ * Copyright (c) 2017 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2 or later, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "qemu/osdep.h"
+#include "qemu/iov.h"
+#include "qemu-common.h"
+#include "hw/virtio/virtio.h"
+#include "sysemu/kvm.h"
+#include "trace.h"
+
+#include "standard-headers/linux/virtio_ids.h"
+#include <linux/virtio_iommu.h>
+
+#include "hw/virtio/virtio-bus.h"
+#include "hw/virtio/virtio-access.h"
+#include "hw/virtio/virtio-iommu.h"
+
+/* Max size */
+#define VIOMMU_DEFAULT_QUEUE_SIZE 256
+
+static int virtio_iommu_handle_attach(VirtIOIOMMU *s,
+ struct iovec *iov,
+ unsigned int iov_cnt)
+{
+ return -ENOENT;
+}
+static int virtio_iommu_handle_detach(VirtIOIOMMU *s,
+ struct iovec *iov,
+ unsigned int iov_cnt)
+{
+ return -ENOENT;
+}
+static int virtio_iommu_handle_map(VirtIOIOMMU *s,
+ struct iovec *iov,
+ unsigned int iov_cnt)
+{
+ return -ENOENT;
+}
+static int virtio_iommu_handle_unmap(VirtIOIOMMU *s,
+ struct iovec *iov,
+ unsigned int iov_cnt)
+{
+ return -ENOENT;
+}
+
+static void virtio_iommu_handle_command(VirtIODevice *vdev, VirtQueue *vq)
+{
+ VirtIOIOMMU *s = VIRTIO_IOMMU(vdev);
+ VirtQueueElement *elem;
+ struct virtio_iommu_req_head head;
+ struct virtio_iommu_req_tail tail;
+ unsigned int iov_cnt;
+ struct iovec *iov;
+ size_t sz;
+
+ for (;;) {
+ elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
+ if (!elem) {
+ return;
+ }
+
+ if (iov_size(elem->in_sg, elem->in_num) < sizeof(tail) ||
+ iov_size(elem->out_sg, elem->out_num) < sizeof(head)) {
+ virtio_error(vdev, "virtio-iommu erroneous head or tail");
+ virtqueue_detach_element(vq, elem, 0);
+ g_free(elem);
+ break;
+ }
+
+ iov_cnt = elem->out_num;
+ iov = g_memdup(elem->out_sg, sizeof(struct iovec) * elem->out_num);
+ sz = iov_to_buf(iov, iov_cnt, 0, &head, sizeof(head));
+ if (sz != sizeof(head)) {
+ tail.status = VIRTIO_IOMMU_S_UNSUPP;
+ }
+ qemu_mutex_lock(&s->mutex);
+ switch (head.type) {
+ case VIRTIO_IOMMU_T_ATTACH:
+ tail.status = virtio_iommu_handle_attach(s, iov, iov_cnt);
+ break;
+ case VIRTIO_IOMMU_T_DETACH:
+ tail.status = virtio_iommu_handle_detach(s, iov, iov_cnt);
+ break;
+ case VIRTIO_IOMMU_T_MAP:
+ tail.status = virtio_iommu_handle_map(s, iov, iov_cnt);
+ break;
+ case VIRTIO_IOMMU_T_UNMAP:
+ tail.status = virtio_iommu_handle_unmap(s, iov, iov_cnt);
+ break;
+ default:
+ tail.status = VIRTIO_IOMMU_S_UNSUPP;
+ }
+ qemu_mutex_unlock(&s->mutex);
+
+ sz = iov_from_buf(elem->in_sg, elem->in_num, 0,
+ &tail, sizeof(tail));
+ assert(sz == sizeof(tail));
+
+ virtqueue_push(vq, elem, sizeof(tail));
+ virtio_notify(vdev, vq);
+ g_free(elem);
+ }
+}
+
+static void virtio_iommu_get_config(VirtIODevice *vdev, uint8_t *config_data)
+{
+ VirtIOIOMMU *dev = VIRTIO_IOMMU(vdev);
+ struct virtio_iommu_config *config = &dev->config;
+
+ trace_virtio_iommu_get_config(config->page_size_mask,
+ config->input_range.start,
+ config->input_range.end,
+ config->domain_bits,
+ config->probe_size);
+ memcpy(config_data, &dev->config, sizeof(struct virtio_iommu_config));
+}
+
+static void virtio_iommu_set_config(VirtIODevice *vdev,
+ const uint8_t *config_data)
+{
+}
+
+static uint64_t virtio_iommu_get_features(VirtIODevice *vdev, uint64_t f,
+ Error **errp)
+{
+ VirtIOIOMMU *dev = VIRTIO_IOMMU(vdev);
+ f |= dev->host_features;
+ virtio_add_feature(&f, VIRTIO_RING_F_EVENT_IDX);
+ virtio_add_feature(&f, VIRTIO_RING_F_INDIRECT_DESC);
+ virtio_add_feature(&f, VIRTIO_IOMMU_F_INPUT_RANGE);
+ virtio_add_feature(&f, VIRTIO_IOMMU_F_MAP_UNMAP);
+ return f;
+}
+
+static void virtio_iommu_set_features(VirtIODevice *vdev, uint64_t val)
+{
+ trace_virtio_iommu_set_features(val);
+}
+
+static int virtio_iommu_post_load_device(void *opaque, int version_id)
+{
+ return 0;
+}
+
+static const VMStateDescription vmstate_virtio_iommu_device = {
+ .name = "virtio-iommu-device",
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .post_load = virtio_iommu_post_load_device,
+ .fields = (VMStateField[]) {
+ VMSTATE_END_OF_LIST()
+ },
+};
+
+static void virtio_iommu_device_realize(DeviceState *dev, Error **errp)
+{
+ VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+ VirtIOIOMMU *s = VIRTIO_IOMMU(dev);
+
+ virtio_init(vdev, "virtio-iommu", VIRTIO_ID_IOMMU,
+ sizeof(struct virtio_iommu_config));
+
+ s->req_vq = virtio_add_queue(vdev, VIOMMU_DEFAULT_QUEUE_SIZE,
+ virtio_iommu_handle_command);
+ s->event_vq = virtio_add_queue(vdev, VIOMMU_DEFAULT_QUEUE_SIZE, NULL);
+
+ s->config.page_size_mask = TARGET_PAGE_MASK;
+ s->config.input_range.end = -1UL;
+}
+
+static void virtio_iommu_device_unrealize(DeviceState *dev, Error **errp)
+{
+ VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+
+ virtio_cleanup(vdev);
+}
+
+static void virtio_iommu_device_reset(VirtIODevice *vdev)
+{
+ trace_virtio_iommu_device_reset();
+}
+
+static void virtio_iommu_set_status(VirtIODevice *vdev, uint8_t status)
+{
+ trace_virtio_iommu_device_status(status);
+}
+
+static void virtio_iommu_instance_init(Object *obj)
+{
+}
+
+static const VMStateDescription vmstate_virtio_iommu = {
+ .name = "virtio-iommu",
+ .minimum_version_id = 1,
+ .version_id = 1,
+ .fields = (VMStateField[]) {
+ VMSTATE_VIRTIO_DEVICE,
+ VMSTATE_END_OF_LIST()
+ },
+};
+
+static Property virtio_iommu_properties[] = {
+ DEFINE_PROP_LINK("primary-bus", VirtIOIOMMU, primary_bus, "PCI", PCIBus *),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void virtio_iommu_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
+
+ dc->props = virtio_iommu_properties;
+ dc->vmsd = &vmstate_virtio_iommu;
+
+ set_bit(DEVICE_CATEGORY_MISC, dc->categories);
+ vdc->realize = virtio_iommu_device_realize;
+ vdc->unrealize = virtio_iommu_device_unrealize;
+ vdc->reset = virtio_iommu_device_reset;
+ vdc->get_config = virtio_iommu_get_config;
+ vdc->set_config = virtio_iommu_set_config;
+ vdc->get_features = virtio_iommu_get_features;
+ vdc->set_features = virtio_iommu_set_features;
+ vdc->set_status = virtio_iommu_set_status;
+ vdc->vmsd = &vmstate_virtio_iommu_device;
+}
+
+static const TypeInfo virtio_iommu_info = {
+ .name = TYPE_VIRTIO_IOMMU,
+ .parent = TYPE_VIRTIO_DEVICE,
+ .instance_size = sizeof(VirtIOIOMMU),
+ .instance_init = virtio_iommu_instance_init,
+ .class_init = virtio_iommu_class_init,
+};
+
+static void virtio_register_types(void)
+{
+ type_register_static(&virtio_iommu_info);
+}
+
+type_init(virtio_register_types)
diff --git a/include/hw/virtio/virtio-iommu.h b/include/hw/virtio/virtio-iommu.h
new file mode 100644
index 0000000..f54d09b
--- /dev/null
+++ b/include/hw/virtio/virtio-iommu.h
@@ -0,0 +1,61 @@
+/*
+ * virtio-iommu device
+ *
+ * Copyright (c) 2017 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2 or later, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef QEMU_VIRTIO_IOMMU_H
+#define QEMU_VIRTIO_IOMMU_H
+
+#include "standard-headers/linux/virtio_iommu.h"
+#include "hw/virtio/virtio.h"
+#include "hw/pci/pci.h"
+
+#define TYPE_VIRTIO_IOMMU "virtio-iommu-device"
+#define VIRTIO_IOMMU(obj) \
+ OBJECT_CHECK(VirtIOIOMMU, (obj), TYPE_VIRTIO_IOMMU)
+
+#define IOMMU_PCI_BUS_MAX 256
+#define IOMMU_PCI_DEVFN_MAX 256
+
+typedef struct IOMMUDevice {
+ void *viommu;
+ PCIBus *bus;
+ int devfn;
+ IOMMUMemoryRegion iommu_mr;
+ AddressSpace as;
+} IOMMUDevice;
+
+typedef struct IOMMUPciBus {
+ PCIBus *bus;
+ IOMMUDevice *pbdev[0]; /* Parent array is sparse, so dynamically alloc */
+} IOMMUPciBus;
+
+typedef struct VirtIOIOMMU {
+ VirtIODevice parent_obj;
+ VirtQueue *req_vq;
+ VirtQueue *event_vq;
+ struct virtio_iommu_config config;
+ uint32_t host_features;
+ GHashTable *as_by_busptr;
+ IOMMUPciBus *as_by_bus_num[IOMMU_PCI_BUS_MAX];
+ PCIBus *primary_bus;
+ GTree *domains;
+ QemuMutex mutex;
+ GTree *endpoints;
+} VirtIOIOMMU;
+
+#endif
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 03/16] virtio-iommu: Decode the command payload
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 01/16] linux-headers: Partial update for virtio-iommu v0.7 Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 02/16] virtio-iommu: Add skeleton Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 04/16] virtio-iommu: Add the iommu regions Eric Auger
` (12 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patch adds the command payload decoding and
introduces the functions that will do the actual
command handling. Those functions are not yet implemented.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
v5 -> v6:
- change map/unmap semantics (remove size)
v4 -> v5:
- adopt new v0.5 terminology
v3 -> v4:
- no flags field anymore in struct virtio_iommu_req_unmap
- test reserved on attach/detach, change trace proto
- rebase on v2.10.0.
---
hw/virtio/trace-events | 6 ++-
hw/virtio/virtio-iommu.c | 104 +++++++++++++++++++++++++++++++++++++++++++++--
2 files changed, 105 insertions(+), 5 deletions(-)
diff --git a/hw/virtio/trace-events b/hw/virtio/trace-events
index 01dc20f..f6675cf 100644
--- a/hw/virtio/trace-events
+++ b/hw/virtio/trace-events
@@ -52,4 +52,8 @@ virtio_balloon_to_target(uint64_t target, uint32_t num_pages) "balloon target: 0
virtio_iommu_set_features(uint64_t features) "features accepted by the driver =0x%"PRIx64
virtio_iommu_device_reset(void) "reset!"
virtio_iommu_device_status(uint8_t status) "driver status = %d"
-virtio_iommu_get_config(uint64_t page_size_mask, uint64_t start, uint64_t end, uint8_t ioasid_bits, uint32_t probe_size) "page_size_mask=0x%"PRIx64" start=0x%"PRIx64" end=0x%"PRIx64" ioasid_bits=%d probe_size=0x%x"
+virtio_iommu_get_config(uint64_t page_size_mask, uint64_t start, uint64_t end, uint8_t domain_bits, uint32_t probe_size) "page_size_mask=0x%"PRIx64" start=0x%"PRIx64" end=0x%"PRIx64" domain_bits=%d probe_size=0x%x"
+virtio_iommu_attach(uint32_t domain_id, uint32_t ep_id) "domain=%d endpoint=%d"
+virtio_iommu_detach(uint32_t ep_id) "endpoint=%d"
+virtio_iommu_map(uint32_t domain_id, uint64_t virt_start, uint64_t virt_end, uint64_t phys_start, uint32_t flags) "domain=%d virt_start=0x%"PRIx64" virt_end=0x%"PRIx64 " phys_start=0x%"PRIx64" flags=%d"
+virtio_iommu_unmap(uint32_t domain_id, uint64_t virt_start, uint64_t virt_end) "domain=%d virt_start=0x%"PRIx64" virt_end=0x%"PRIx64
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index 34c7584..492cf22 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -34,29 +34,125 @@
/* Max size */
#define VIOMMU_DEFAULT_QUEUE_SIZE 256
+static int virtio_iommu_attach(VirtIOIOMMU *s,
+ struct virtio_iommu_req_attach *req)
+{
+ uint32_t domain_id = le32_to_cpu(req->domain);
+ uint32_t ep_id = le32_to_cpu(req->endpoint);
+ uint32_t reserved = le32_to_cpu(req->reserved);
+
+ trace_virtio_iommu_attach(domain_id, ep_id);
+
+ if (reserved) {
+ return VIRTIO_IOMMU_S_INVAL;
+ }
+
+ return VIRTIO_IOMMU_S_UNSUPP;
+}
+
+static int virtio_iommu_detach(VirtIOIOMMU *s,
+ struct virtio_iommu_req_detach *req)
+{
+ uint32_t ep_id = le32_to_cpu(req->endpoint);
+ uint32_t reserved = le32_to_cpu(req->reserved);
+
+ trace_virtio_iommu_detach(ep_id);
+
+ if (reserved) {
+ return VIRTIO_IOMMU_S_INVAL;
+ }
+
+ return VIRTIO_IOMMU_S_UNSUPP;
+}
+
+static int virtio_iommu_map(VirtIOIOMMU *s,
+ struct virtio_iommu_req_map *req)
+{
+ uint32_t domain_id = le32_to_cpu(req->domain);
+ uint64_t phys_start = le64_to_cpu(req->phys_start);
+ uint64_t virt_start = le64_to_cpu(req->virt_start);
+ uint64_t virt_end = le64_to_cpu(req->virt_end);
+ uint32_t flags = le32_to_cpu(req->flags);
+
+ trace_virtio_iommu_map(domain_id, virt_start, virt_end, phys_start, flags);
+
+ return VIRTIO_IOMMU_S_UNSUPP;
+}
+
+static int virtio_iommu_unmap(VirtIOIOMMU *s,
+ struct virtio_iommu_req_unmap *req)
+{
+ uint32_t domain_id = le32_to_cpu(req->domain);
+ uint64_t virt_start = le64_to_cpu(req->virt_start);
+ uint64_t virt_end = le64_to_cpu(req->virt_end);
+
+ trace_virtio_iommu_unmap(domain_id, virt_start, virt_end);
+
+ return VIRTIO_IOMMU_S_UNSUPP;
+}
+
+#define get_payload_size(req) (\
+sizeof((req)) - sizeof(struct virtio_iommu_req_tail))
+
static int virtio_iommu_handle_attach(VirtIOIOMMU *s,
struct iovec *iov,
unsigned int iov_cnt)
{
- return -ENOENT;
+ struct virtio_iommu_req_attach req;
+ size_t sz, payload_sz;
+
+ payload_sz = get_payload_size(req);
+
+ sz = iov_to_buf(iov, iov_cnt, 0, &req, payload_sz);
+ if (sz != payload_sz) {
+ return VIRTIO_IOMMU_S_INVAL;
+ }
+ return virtio_iommu_attach(s, &req);
}
static int virtio_iommu_handle_detach(VirtIOIOMMU *s,
struct iovec *iov,
unsigned int iov_cnt)
{
- return -ENOENT;
+ struct virtio_iommu_req_detach req;
+ size_t sz, payload_sz;
+
+ payload_sz = get_payload_size(req);
+
+ sz = iov_to_buf(iov, iov_cnt, 0, &req, payload_sz);
+ if (sz != payload_sz) {
+ return VIRTIO_IOMMU_S_INVAL;
+ }
+ return virtio_iommu_detach(s, &req);
}
static int virtio_iommu_handle_map(VirtIOIOMMU *s,
struct iovec *iov,
unsigned int iov_cnt)
{
- return -ENOENT;
+ struct virtio_iommu_req_map req;
+ size_t sz, payload_sz;
+
+ payload_sz = get_payload_size(req);
+
+ sz = iov_to_buf(iov, iov_cnt, 0, &req, payload_sz);
+ if (sz != payload_sz) {
+ return VIRTIO_IOMMU_S_INVAL;
+ }
+ return virtio_iommu_map(s, &req);
}
static int virtio_iommu_handle_unmap(VirtIOIOMMU *s,
struct iovec *iov,
unsigned int iov_cnt)
{
- return -ENOENT;
+ struct virtio_iommu_req_unmap req;
+ size_t sz, payload_sz;
+
+ payload_sz = get_payload_size(req);
+
+ sz = iov_to_buf(iov, iov_cnt, 0, &req, payload_sz);
+ if (sz != payload_sz) {
+ return VIRTIO_IOMMU_S_INVAL;
+ }
+ return virtio_iommu_unmap(s, &req);
}
static void virtio_iommu_handle_command(VirtIODevice *vdev, VirtQueue *vq)
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 04/16] virtio-iommu: Add the iommu regions
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (2 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 03/16] virtio-iommu: Decode the command payload Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 05/16] virtio-iommu: Endpoint and domains structs and helpers Eric Auger
` (11 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patch initializes the iommu memory regions so that
PCIe end point transactions get translated. The translation
function is not yet implemented though.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
v6 -> v7:
- use primary_bus
- rebase on new translate proto featuring iommu_idx
v5 -> v6:
- include qapi/error.h
- fix g_hash_table_lookup key in virtio_iommu_find_add_as
v4 -> v5:
- use PCI bus handle as a key
- use get_primary_pci_bus() callback
v3 -> v4:
- add trace_virtio_iommu_init_iommu_mr
v2 -> v3:
- use IOMMUMemoryRegion
- iommu mr name built with BDF
- rename smmu_get_sid into virtio_iommu_get_sid and use PCI_BUILD_BDF
---
hw/virtio/trace-events | 2 +
hw/virtio/virtio-iommu.c | 94 ++++++++++++++++++++++++++++++++++++++++
include/hw/virtio/virtio-iommu.h | 2 +
3 files changed, 98 insertions(+)
diff --git a/hw/virtio/trace-events b/hw/virtio/trace-events
index f6675cf..bc6e5c4 100644
--- a/hw/virtio/trace-events
+++ b/hw/virtio/trace-events
@@ -57,3 +57,5 @@ virtio_iommu_attach(uint32_t domain_id, uint32_t ep_id) "domain=%d endpoint=%d"
virtio_iommu_detach(uint32_t ep_id) "endpoint=%d"
virtio_iommu_map(uint32_t domain_id, uint64_t virt_start, uint64_t virt_end, uint64_t phys_start, uint32_t flags) "domain=%d virt_start=0x%"PRIx64" virt_end=0x%"PRIx64 " phys_start=0x%"PRIx64" flags=%d"
virtio_iommu_unmap(uint32_t domain_id, uint64_t virt_start, uint64_t virt_end) "domain=%d virt_start=0x%"PRIx64" virt_end=0x%"PRIx64
+virtio_iommu_translate(const char *name, uint32_t rid, uint64_t iova, int flag) "mr=%s rid=%d addr=0x%"PRIx64" flag=%d"
+virtio_iommu_init_iommu_mr(char *iommu_mr) "init %s"
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index 492cf22..f2f5310 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -22,6 +22,10 @@
#include "qemu-common.h"
#include "hw/virtio/virtio.h"
#include "sysemu/kvm.h"
+#include "qapi/error.h"
+#include "qemu/error-report.h"
+#include "hw/i386/pc.h"
+#include "hw/arm/virt.h"
#include "trace.h"
#include "standard-headers/linux/virtio_ids.h"
@@ -34,6 +38,50 @@
/* Max size */
#define VIOMMU_DEFAULT_QUEUE_SIZE 256
+static inline uint16_t virtio_iommu_get_sid(IOMMUDevice *dev)
+{
+ return PCI_BUILD_BDF(pci_bus_num(dev->bus), dev->devfn);
+}
+
+static AddressSpace *virtio_iommu_find_add_as(PCIBus *bus, void *opaque,
+ int devfn)
+{
+ VirtIOIOMMU *s = opaque;
+ IOMMUPciBus *sbus = g_hash_table_lookup(s->as_by_busptr, bus);
+ IOMMUDevice *sdev;
+
+ if (!sbus) {
+ sbus = g_malloc0(sizeof(IOMMUPciBus) +
+ sizeof(IOMMUDevice *) * IOMMU_PCI_DEVFN_MAX);
+ sbus->bus = bus;
+ g_hash_table_insert(s->as_by_busptr, bus, sbus);
+ }
+
+ sdev = sbus->pbdev[devfn];
+ if (!sdev) {
+ char *name = g_strdup_printf("%s-%d-%d",
+ TYPE_VIRTIO_IOMMU_MEMORY_REGION,
+ pci_bus_num(bus), devfn);
+ sdev = sbus->pbdev[devfn] = g_malloc0(sizeof(IOMMUDevice));
+
+ sdev->viommu = s;
+ sdev->bus = bus;
+ sdev->devfn = devfn;
+
+ trace_virtio_iommu_init_iommu_mr(name);
+
+ memory_region_init_iommu(&sdev->iommu_mr, sizeof(sdev->iommu_mr),
+ TYPE_VIRTIO_IOMMU_MEMORY_REGION,
+ OBJECT(s), name,
+ UINT64_MAX);
+ address_space_init(&sdev->as,
+ MEMORY_REGION(&sdev->iommu_mr), TYPE_VIRTIO_IOMMU);
+ }
+
+ return &sdev->as;
+
+}
+
static int virtio_iommu_attach(VirtIOIOMMU *s,
struct virtio_iommu_req_attach *req)
{
@@ -214,6 +262,27 @@ static void virtio_iommu_handle_command(VirtIODevice *vdev, VirtQueue *vq)
}
}
+static IOMMUTLBEntry virtio_iommu_translate(IOMMUMemoryRegion *mr, hwaddr addr,
+ IOMMUAccessFlags flag,
+ int iommu_idx)
+{
+ IOMMUDevice *sdev = container_of(mr, IOMMUDevice, iommu_mr);
+ uint32_t sid;
+
+ IOMMUTLBEntry entry = {
+ .target_as = &address_space_memory,
+ .iova = addr,
+ .translated_addr = addr,
+ .addr_mask = ~(hwaddr)0,
+ .perm = IOMMU_NONE,
+ };
+
+ sid = virtio_iommu_get_sid(sdev);
+
+ trace_virtio_iommu_translate(mr->parent_obj.name, sid, addr, flag);
+ return entry;
+}
+
static void virtio_iommu_get_config(VirtIODevice *vdev, uint8_t *config_data)
{
VirtIOIOMMU *dev = VIRTIO_IOMMU(vdev);
@@ -278,6 +347,15 @@ static void virtio_iommu_device_realize(DeviceState *dev, Error **errp)
s->config.page_size_mask = TARGET_PAGE_MASK;
s->config.input_range.end = -1UL;
+
+ memset(s->as_by_bus_num, 0, sizeof(s->as_by_bus_num));
+ s->as_by_busptr = g_hash_table_new(NULL, NULL);
+
+ if (s->primary_bus) {
+ pci_setup_iommu(s->primary_bus, virtio_iommu_find_add_as, s);
+ } else {
+ error_setg(errp, "VIRTIO-IOMMU is not attached to any PCI bus!");
+ }
}
static void virtio_iommu_device_unrealize(DeviceState *dev, Error **errp)
@@ -336,6 +414,14 @@ static void virtio_iommu_class_init(ObjectClass *klass, void *data)
vdc->vmsd = &vmstate_virtio_iommu_device;
}
+static void virtio_iommu_memory_region_class_init(ObjectClass *klass,
+ void *data)
+{
+ IOMMUMemoryRegionClass *imrc = IOMMU_MEMORY_REGION_CLASS(klass);
+
+ imrc->translate = virtio_iommu_translate;
+}
+
static const TypeInfo virtio_iommu_info = {
.name = TYPE_VIRTIO_IOMMU,
.parent = TYPE_VIRTIO_DEVICE,
@@ -344,9 +430,17 @@ static const TypeInfo virtio_iommu_info = {
.class_init = virtio_iommu_class_init,
};
+static const TypeInfo virtio_iommu_memory_region_info = {
+ .parent = TYPE_IOMMU_MEMORY_REGION,
+ .name = TYPE_VIRTIO_IOMMU_MEMORY_REGION,
+ .class_init = virtio_iommu_memory_region_class_init,
+};
+
+
static void virtio_register_types(void)
{
type_register_static(&virtio_iommu_info);
+ type_register_static(&virtio_iommu_memory_region_info);
}
type_init(virtio_register_types)
diff --git a/include/hw/virtio/virtio-iommu.h b/include/hw/virtio/virtio-iommu.h
index f54d09b..913e96b 100644
--- a/include/hw/virtio/virtio-iommu.h
+++ b/include/hw/virtio/virtio-iommu.h
@@ -28,6 +28,8 @@
#define VIRTIO_IOMMU(obj) \
OBJECT_CHECK(VirtIOIOMMU, (obj), TYPE_VIRTIO_IOMMU)
+#define TYPE_VIRTIO_IOMMU_MEMORY_REGION "virtio-iommu-memory-region"
+
#define IOMMU_PCI_BUS_MAX 256
#define IOMMU_PCI_DEVFN_MAX 256
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-devel] [RFC v7 05/16] virtio-iommu: Endpoint and domains structs and helpers
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (3 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 04/16] virtio-iommu: Add the iommu regions Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 06/16] virtio-iommu: Implement attach/detach command Eric Auger
` (10 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: wei, kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patch introduce domain and endpoint internal
datatypes. Both are stored in RB trees. The domain
owns a list of endpoints attached to it.
Helpers to get/put end points and domains are introduced.
get() helpers will become static in subsequent patches.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
v6 -> v7:
- on virtio_iommu_find_add_as the bus number computation may
not be finalized yet so we cannot register the EPs at that time.
Hence, let's remove the get_endpoint and also do not use the
bus number for building the memory region name string (only
used for debug though).
v4 -> v5:
- initialize as->endpoint_list
v3 -> v4:
- new separate patch
---
hw/virtio/trace-events | 4 ++
hw/virtio/virtio-iommu.c | 125 ++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 128 insertions(+), 1 deletion(-)
diff --git a/hw/virtio/trace-events b/hw/virtio/trace-events
index bc6e5c4..f4d6b4b 100644
--- a/hw/virtio/trace-events
+++ b/hw/virtio/trace-events
@@ -59,3 +59,7 @@ virtio_iommu_map(uint32_t domain_id, uint64_t virt_start, uint64_t virt_end, uin
virtio_iommu_unmap(uint32_t domain_id, uint64_t virt_start, uint64_t virt_end) "domain=%d virt_start=0x%"PRIx64" virt_end=0x%"PRIx64
virtio_iommu_translate(const char *name, uint32_t rid, uint64_t iova, int flag) "mr=%s rid=%d addr=0x%"PRIx64" flag=%d"
virtio_iommu_init_iommu_mr(char *iommu_mr) "init %s"
+virtio_iommu_get_endpoint(uint32_t ep_id) "Alloc endpoint=%d"
+virtio_iommu_put_endpoint(uint32_t ep_id) "Free endpoint=%d"
+virtio_iommu_get_domain(uint32_t domain_id) "Alloc domain=%d"
+virtio_iommu_put_domain(uint32_t domain_id) "Free domain=%d"
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index f2f5310..8bbb116 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -34,20 +34,124 @@
#include "hw/virtio/virtio-bus.h"
#include "hw/virtio/virtio-access.h"
#include "hw/virtio/virtio-iommu.h"
+#include "hw/pci/pci_bus.h"
+#include "hw/pci/pci.h"
/* Max size */
#define VIOMMU_DEFAULT_QUEUE_SIZE 256
+typedef struct viommu_domain {
+ uint32_t id;
+ GTree *mappings;
+ QLIST_HEAD(, viommu_endpoint) endpoint_list;
+} viommu_domain;
+
+typedef struct viommu_endpoint {
+ uint32_t id;
+ viommu_domain *domain;
+ QLIST_ENTRY(viommu_endpoint) next;
+ VirtIOIOMMU *viommu;
+} viommu_endpoint;
+
+typedef struct viommu_interval {
+ uint64_t low;
+ uint64_t high;
+} viommu_interval;
+
static inline uint16_t virtio_iommu_get_sid(IOMMUDevice *dev)
{
return PCI_BUILD_BDF(pci_bus_num(dev->bus), dev->devfn);
}
+static gint interval_cmp(gconstpointer a, gconstpointer b, gpointer user_data)
+{
+ viommu_interval *inta = (viommu_interval *)a;
+ viommu_interval *intb = (viommu_interval *)b;
+
+ if (inta->high <= intb->low) {
+ return -1;
+ } else if (intb->high <= inta->low) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+static void virtio_iommu_detach_endpoint_from_domain(viommu_endpoint *ep)
+{
+ QLIST_REMOVE(ep, next);
+ ep->domain = NULL;
+}
+
+viommu_endpoint *virtio_iommu_get_endpoint(VirtIOIOMMU *s, uint32_t ep_id);
+viommu_endpoint *virtio_iommu_get_endpoint(VirtIOIOMMU *s, uint32_t ep_id)
+{
+ viommu_endpoint *ep;
+
+ ep = g_tree_lookup(s->endpoints, GUINT_TO_POINTER(ep_id));
+ if (ep) {
+ return ep;
+ }
+ ep = g_malloc0(sizeof(*ep));
+ ep->id = ep_id;
+ ep->viommu = s;
+ trace_virtio_iommu_get_endpoint(ep_id);
+ g_tree_insert(s->endpoints, GUINT_TO_POINTER(ep_id), ep);
+ return ep;
+}
+
+static void virtio_iommu_put_endpoint(gpointer data)
+{
+ viommu_endpoint *ep = (viommu_endpoint *)data;
+
+ if (ep->domain) {
+ virtio_iommu_detach_endpoint_from_domain(ep);
+ g_tree_unref(ep->domain->mappings);
+ }
+
+ trace_virtio_iommu_put_endpoint(ep->id);
+ g_free(ep);
+}
+
+viommu_domain *virtio_iommu_get_domain(VirtIOIOMMU *s, uint32_t domain_id);
+viommu_domain *virtio_iommu_get_domain(VirtIOIOMMU *s, uint32_t domain_id)
+{
+ viommu_domain *domain;
+
+ domain = g_tree_lookup(s->domains, GUINT_TO_POINTER(domain_id));
+ if (domain) {
+ return domain;
+ }
+ domain = g_malloc0(sizeof(*domain));
+ domain->id = domain_id;
+ domain->mappings = g_tree_new_full((GCompareDataFunc)interval_cmp,
+ NULL, (GDestroyNotify)g_free,
+ (GDestroyNotify)g_free);
+ g_tree_insert(s->domains, GUINT_TO_POINTER(domain_id), domain);
+ QLIST_INIT(&domain->endpoint_list);
+ trace_virtio_iommu_get_domain(domain_id);
+ return domain;
+}
+
+static void virtio_iommu_put_domain(gpointer data)
+{
+ viommu_domain *domain = (viommu_domain *)data;
+ viommu_endpoint *iter, *tmp;
+
+ QLIST_FOREACH_SAFE(iter, &domain->endpoint_list, next, tmp) {
+ virtio_iommu_detach_endpoint_from_domain(iter);
+ }
+ g_tree_destroy(domain->mappings);
+ trace_virtio_iommu_put_domain(domain->id);
+ g_free(domain);
+}
+
static AddressSpace *virtio_iommu_find_add_as(PCIBus *bus, void *opaque,
int devfn)
{
VirtIOIOMMU *s = opaque;
IOMMUPciBus *sbus = g_hash_table_lookup(s->as_by_busptr, bus);
+ static uint32_t mr_index;
IOMMUDevice *sdev;
if (!sbus) {
@@ -61,7 +165,7 @@ static AddressSpace *virtio_iommu_find_add_as(PCIBus *bus, void *opaque,
if (!sdev) {
char *name = g_strdup_printf("%s-%d-%d",
TYPE_VIRTIO_IOMMU_MEMORY_REGION,
- pci_bus_num(bus), devfn);
+ mr_index++, devfn);
sdev = sbus->pbdev[devfn] = g_malloc0(sizeof(IOMMUDevice));
sdev->viommu = s;
@@ -76,6 +180,7 @@ static AddressSpace *virtio_iommu_find_add_as(PCIBus *bus, void *opaque,
UINT64_MAX);
address_space_init(&sdev->as,
MEMORY_REGION(&sdev->iommu_mr), TYPE_VIRTIO_IOMMU);
+ g_free(name);
}
return &sdev->as;
@@ -333,6 +438,13 @@ static const VMStateDescription vmstate_virtio_iommu_device = {
},
};
+static gint int_cmp(gconstpointer a, gconstpointer b, gpointer user_data)
+{
+ uint ua = GPOINTER_TO_UINT(a);
+ uint ub = GPOINTER_TO_UINT(b);
+ return (ua > ub) - (ua < ub);
+}
+
static void virtio_iommu_device_realize(DeviceState *dev, Error **errp)
{
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
@@ -348,6 +460,8 @@ static void virtio_iommu_device_realize(DeviceState *dev, Error **errp)
s->config.page_size_mask = TARGET_PAGE_MASK;
s->config.input_range.end = -1UL;
+ qemu_mutex_init(&s->mutex);
+
memset(s->as_by_bus_num, 0, sizeof(s->as_by_bus_num));
s->as_by_busptr = g_hash_table_new(NULL, NULL);
@@ -356,11 +470,20 @@ static void virtio_iommu_device_realize(DeviceState *dev, Error **errp)
} else {
error_setg(errp, "VIRTIO-IOMMU is not attached to any PCI bus!");
}
+
+ s->domains = g_tree_new_full((GCompareDataFunc)int_cmp,
+ NULL, NULL, virtio_iommu_put_domain);
+ s->endpoints = g_tree_new_full((GCompareDataFunc)int_cmp,
+ NULL, NULL, virtio_iommu_put_endpoint);
}
static void virtio_iommu_device_unrealize(DeviceState *dev, Error **errp)
{
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
+ VirtIOIOMMU *s = VIRTIO_IOMMU(dev);
+
+ g_tree_destroy(s->domains);
+ g_tree_destroy(s->endpoints);
virtio_cleanup(vdev);
}
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-devel] [RFC v7 06/16] virtio-iommu: Implement attach/detach command
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (4 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 05/16] virtio-iommu: Endpoint and domains structs and helpers Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 07/16] virtio-iommu: Implement map/unmap Eric Auger
` (9 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: wei, kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patch implements the endpoint attach/detach to/from
a domain.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
hw/virtio/virtio-iommu.c | 43 +++++++++++++++++++++++++++++++++++--------
1 file changed, 35 insertions(+), 8 deletions(-)
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index 8bbb116..4cb6e15 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -83,8 +83,8 @@ static void virtio_iommu_detach_endpoint_from_domain(viommu_endpoint *ep)
ep->domain = NULL;
}
-viommu_endpoint *virtio_iommu_get_endpoint(VirtIOIOMMU *s, uint32_t ep_id);
-viommu_endpoint *virtio_iommu_get_endpoint(VirtIOIOMMU *s, uint32_t ep_id)
+static viommu_endpoint *virtio_iommu_get_endpoint(VirtIOIOMMU *s,
+ uint32_t ep_id)
{
viommu_endpoint *ep;
@@ -113,8 +113,8 @@ static void virtio_iommu_put_endpoint(gpointer data)
g_free(ep);
}
-viommu_domain *virtio_iommu_get_domain(VirtIOIOMMU *s, uint32_t domain_id);
-viommu_domain *virtio_iommu_get_domain(VirtIOIOMMU *s, uint32_t domain_id)
+static viommu_domain *virtio_iommu_get_domain(VirtIOIOMMU *s,
+ uint32_t domain_id)
{
viommu_domain *domain;
@@ -193,6 +193,8 @@ static int virtio_iommu_attach(VirtIOIOMMU *s,
uint32_t domain_id = le32_to_cpu(req->domain);
uint32_t ep_id = le32_to_cpu(req->endpoint);
uint32_t reserved = le32_to_cpu(req->reserved);
+ viommu_domain *domain;
+ viommu_endpoint *ep;
trace_virtio_iommu_attach(domain_id, ep_id);
@@ -200,7 +202,22 @@ static int virtio_iommu_attach(VirtIOIOMMU *s,
return VIRTIO_IOMMU_S_INVAL;
}
- return VIRTIO_IOMMU_S_UNSUPP;
+ ep = virtio_iommu_get_endpoint(s, ep_id);
+ if (ep->domain) {
+ /*
+ * the device is already attached to a domain,
+ * detach it first
+ */
+ virtio_iommu_detach_endpoint_from_domain(ep);
+ }
+
+ domain = virtio_iommu_get_domain(s, domain_id);
+ QLIST_INSERT_HEAD(&domain->endpoint_list, ep, next);
+
+ ep->domain = domain;
+ g_tree_ref(domain->mappings);
+
+ return VIRTIO_IOMMU_S_OK;
}
static int virtio_iommu_detach(VirtIOIOMMU *s,
@@ -208,14 +225,24 @@ static int virtio_iommu_detach(VirtIOIOMMU *s,
{
uint32_t ep_id = le32_to_cpu(req->endpoint);
uint32_t reserved = le32_to_cpu(req->reserved);
-
- trace_virtio_iommu_detach(ep_id);
+ viommu_endpoint *ep;
if (reserved) {
return VIRTIO_IOMMU_S_INVAL;
}
- return VIRTIO_IOMMU_S_UNSUPP;
+ ep = g_tree_lookup(s->endpoints, GUINT_TO_POINTER(ep_id));
+ if (!ep) {
+ return VIRTIO_IOMMU_S_NOENT;
+ }
+
+ if (!ep->domain) {
+ return VIRTIO_IOMMU_S_INVAL;
+ }
+
+ virtio_iommu_detach_endpoint_from_domain(ep);
+ trace_virtio_iommu_detach(ep_id);
+ return VIRTIO_IOMMU_S_OK;
}
static int virtio_iommu_map(VirtIOIOMMU *s,
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 07/16] virtio-iommu: Implement map/unmap
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (5 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 06/16] virtio-iommu: Implement attach/detach command Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 08/16] virtio-iommu: Implement translate Eric Auger
` (8 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patch implements virtio_iommu_map/unmap.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
v5 -> v6:
- use new v0.6 fields
- replace error_report by qemu_log_mask
v3 -> v4:
- implement unmap semantics as specified in v0.4
---
hw/virtio/trace-events | 3 ++
hw/virtio/virtio-iommu.c | 94 ++++++++++++++++++++++++++++++++++++++++++++++--
2 files changed, 95 insertions(+), 2 deletions(-)
diff --git a/hw/virtio/trace-events b/hw/virtio/trace-events
index f4d6b4b..926c50b 100644
--- a/hw/virtio/trace-events
+++ b/hw/virtio/trace-events
@@ -63,3 +63,6 @@ virtio_iommu_get_endpoint(uint32_t ep_id) "Alloc endpoint=%d"
virtio_iommu_put_endpoint(uint32_t ep_id) "Free endpoint=%d"
virtio_iommu_get_domain(uint32_t domain_id) "Alloc domain=%d"
virtio_iommu_put_domain(uint32_t domain_id) "Free domain=%d"
+virtio_iommu_unmap_left_interval(uint64_t low, uint64_t high, uint64_t next_low, uint64_t next_high) "Unmap left [0x%"PRIx64",0x%"PRIx64"], new interval=[0x%"PRIx64",0x%"PRIx64"]"
+virtio_iommu_unmap_right_interval(uint64_t low, uint64_t high, uint64_t next_low, uint64_t next_high) "Unmap right [0x%"PRIx64",0x%"PRIx64"], new interval=[0x%"PRIx64",0x%"PRIx64"]"
+virtio_iommu_unmap_inc_interval(uint64_t low, uint64_t high) "Unmap inc [0x%"PRIx64",0x%"PRIx64"]"
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index 4cb6e15..f3a6799 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -18,6 +18,7 @@
*/
#include "qemu/osdep.h"
+#include "qemu/log.h"
#include "qemu/iov.h"
#include "qemu-common.h"
#include "hw/virtio/virtio.h"
@@ -58,6 +59,13 @@ typedef struct viommu_interval {
uint64_t high;
} viommu_interval;
+typedef struct viommu_mapping {
+ uint64_t virt_addr;
+ uint64_t phys_addr;
+ uint64_t size;
+ uint32_t flags;
+} viommu_mapping;
+
static inline uint16_t virtio_iommu_get_sid(IOMMUDevice *dev)
{
return PCI_BUILD_BDF(pci_bus_num(dev->bus), dev->devfn);
@@ -253,10 +261,37 @@ static int virtio_iommu_map(VirtIOIOMMU *s,
uint64_t virt_start = le64_to_cpu(req->virt_start);
uint64_t virt_end = le64_to_cpu(req->virt_end);
uint32_t flags = le32_to_cpu(req->flags);
+ viommu_domain *domain;
+ viommu_interval *interval;
+ viommu_mapping *mapping;
+
+ interval = g_malloc0(sizeof(*interval));
+
+ interval->low = virt_start;
+ interval->high = virt_end;
+
+ domain = g_tree_lookup(s->domains, GUINT_TO_POINTER(domain_id));
+ if (!domain) {
+ return VIRTIO_IOMMU_S_NOENT;
+ }
+
+ mapping = g_tree_lookup(domain->mappings, (gpointer)interval);
+ if (mapping) {
+ g_free(interval);
+ return VIRTIO_IOMMU_S_INVAL;
+ }
trace_virtio_iommu_map(domain_id, virt_start, virt_end, phys_start, flags);
- return VIRTIO_IOMMU_S_UNSUPP;
+ mapping = g_malloc0(sizeof(*mapping));
+ mapping->virt_addr = virt_start;
+ mapping->phys_addr = phys_start;
+ mapping->size = virt_end - virt_start + 1;
+ mapping->flags = flags;
+
+ g_tree_insert(domain->mappings, interval, mapping);
+
+ return VIRTIO_IOMMU_S_OK;
}
static int virtio_iommu_unmap(VirtIOIOMMU *s,
@@ -265,10 +300,65 @@ static int virtio_iommu_unmap(VirtIOIOMMU *s,
uint32_t domain_id = le32_to_cpu(req->domain);
uint64_t virt_start = le64_to_cpu(req->virt_start);
uint64_t virt_end = le64_to_cpu(req->virt_end);
+ uint64_t size = virt_end - virt_start + 1;
+ viommu_mapping *mapping;
+ viommu_interval interval;
+ viommu_domain *domain;
trace_virtio_iommu_unmap(domain_id, virt_start, virt_end);
- return VIRTIO_IOMMU_S_UNSUPP;
+ domain = g_tree_lookup(s->domains, GUINT_TO_POINTER(domain_id));
+ if (!domain) {
+ qemu_log_mask(LOG_GUEST_ERROR, "%s: no domain\n", __func__);
+ return VIRTIO_IOMMU_S_NOENT;
+ }
+ interval.low = virt_start;
+ interval.high = virt_end;
+
+ mapping = g_tree_lookup(domain->mappings, (gpointer)(&interval));
+
+ while (mapping) {
+ viommu_interval current;
+ uint64_t low = mapping->virt_addr;
+ uint64_t high = mapping->virt_addr + mapping->size - 1;
+
+ current.low = low;
+ current.high = high;
+
+ if (low == interval.low && size >= mapping->size) {
+ g_tree_remove(domain->mappings, (gpointer)(¤t));
+ interval.low = high + 1;
+ trace_virtio_iommu_unmap_left_interval(current.low, current.high,
+ interval.low, interval.high);
+ } else if (high == interval.high && size >= mapping->size) {
+ trace_virtio_iommu_unmap_right_interval(current.low, current.high,
+ interval.low, interval.high);
+ g_tree_remove(domain->mappings, (gpointer)(¤t));
+ interval.high = low - 1;
+ } else if (low > interval.low && high < interval.high) {
+ trace_virtio_iommu_unmap_inc_interval(current.low, current.high);
+ g_tree_remove(domain->mappings, (gpointer)(¤t));
+ } else {
+ break;
+ }
+ if (interval.low >= interval.high) {
+ return VIRTIO_IOMMU_S_OK;
+ } else {
+ mapping = g_tree_lookup(domain->mappings, (gpointer)(&interval));
+ }
+ }
+
+ if (mapping) {
+ qemu_log_mask(LOG_GUEST_ERROR,
+ "****** %s: Unmap 0x%"PRIx64" size=0x%"PRIx64
+ " from 0x%"PRIx64" size=0x%"PRIx64" is not supported\n",
+ __func__, interval.low, size,
+ mapping->virt_addr, mapping->size);
+ } else {
+ return VIRTIO_IOMMU_S_OK;
+ }
+
+ return VIRTIO_IOMMU_S_INVAL;
}
#define get_payload_size(req) (\
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-devel] [RFC v7 08/16] virtio-iommu: Implement translate
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (6 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 07/16] virtio-iommu: Implement map/unmap Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 09/16] virtio-iommu: Implement probe request Eric Auger
` (7 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: wei, kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patch implements the translate callback
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
v5 -> v6:
- replace error_report by qemu_log_mask
v4 -> v5:
- check the device domain is not NULL
- s/printf/error_report
- set flags to IOMMU_NONE in case of all translation faults
---
hw/virtio/trace-events | 1 +
hw/virtio/virtio-iommu.c | 45 ++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 45 insertions(+), 1 deletion(-)
diff --git a/hw/virtio/trace-events b/hw/virtio/trace-events
index 926c50b..4041af6 100644
--- a/hw/virtio/trace-events
+++ b/hw/virtio/trace-events
@@ -66,3 +66,4 @@ virtio_iommu_put_domain(uint32_t domain_id) "Free domain=%d"
virtio_iommu_unmap_left_interval(uint64_t low, uint64_t high, uint64_t next_low, uint64_t next_high) "Unmap left [0x%"PRIx64",0x%"PRIx64"], new interval=[0x%"PRIx64",0x%"PRIx64"]"
virtio_iommu_unmap_right_interval(uint64_t low, uint64_t high, uint64_t next_low, uint64_t next_high) "Unmap right [0x%"PRIx64",0x%"PRIx64"], new interval=[0x%"PRIx64",0x%"PRIx64"]"
virtio_iommu_unmap_inc_interval(uint64_t low, uint64_t high) "Unmap inc [0x%"PRIx64",0x%"PRIx64"]"
+virtio_iommu_translate_out(uint64_t virt_addr, uint64_t phys_addr, uint32_t sid) "0x%"PRIx64" -> 0x%"PRIx64 " for sid=%d"
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index f3a6799..6f44d15 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -489,19 +489,62 @@ static IOMMUTLBEntry virtio_iommu_translate(IOMMUMemoryRegion *mr, hwaddr addr,
int iommu_idx)
{
IOMMUDevice *sdev = container_of(mr, IOMMUDevice, iommu_mr);
+ VirtIOIOMMU *s = sdev->viommu;
uint32_t sid;
+ viommu_endpoint *ep;
+ viommu_mapping *mapping;
+ viommu_interval interval;
+
+ interval.low = addr;
+ interval.high = addr + 1;
IOMMUTLBEntry entry = {
.target_as = &address_space_memory,
.iova = addr,
.translated_addr = addr,
- .addr_mask = ~(hwaddr)0,
+ .addr_mask = (1 << ctz32(s->config.page_size_mask)) - 1,
.perm = IOMMU_NONE,
};
sid = virtio_iommu_get_sid(sdev);
trace_virtio_iommu_translate(mr->parent_obj.name, sid, addr, flag);
+ qemu_mutex_lock(&s->mutex);
+
+ ep = g_tree_lookup(s->endpoints, GUINT_TO_POINTER(sid));
+ if (!ep) {
+ error_report("%s sid=%d is not known!!", __func__, sid);
+ goto unlock;
+ }
+
+ if (!ep->domain) {
+ qemu_log_mask(LOG_GUEST_ERROR,
+ "%s %02x:%02x.%01x not attached to any domain\n",
+ __func__, PCI_BUS_NUM(sid), PCI_SLOT(sid), PCI_FUNC(sid));
+ goto unlock;
+ }
+
+ mapping = g_tree_lookup(ep->domain->mappings, (gpointer)(&interval));
+ if (!mapping) {
+ qemu_log_mask(LOG_GUEST_ERROR,
+ "%s no mapping for 0x%"PRIx64" for sid=%d\n",
+ __func__, addr, sid);
+ goto unlock;
+ }
+
+ if (((flag & IOMMU_RO) && !(mapping->flags & VIRTIO_IOMMU_MAP_F_READ)) ||
+ ((flag & IOMMU_WO) && !(mapping->flags & VIRTIO_IOMMU_MAP_F_WRITE))) {
+ qemu_log_mask(LOG_GUEST_ERROR,
+ "Permission error on 0x%"PRIx64"(%d): allowed=%d\n",
+ addr, flag, mapping->flags);
+ goto unlock;
+ }
+ entry.translated_addr = addr - mapping->virt_addr + mapping->phys_addr;
+ entry.perm = flag;
+ trace_virtio_iommu_translate_out(addr, entry.translated_addr, sid);
+
+unlock:
+ qemu_mutex_unlock(&s->mutex);
return entry;
}
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 09/16] virtio-iommu: Implement probe request
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (7 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 08/16] virtio-iommu: Implement translate Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 10/16] virtio-iommu: Add an msi_bypass property Eric Auger
` (6 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patch implements the PROBE request. At the moment,
no reserved regions are returned as none are registered
per device. Only a NONE property is returned.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
v6 -> v7:
- adapt to the change in virtio_iommu_probe_resv_mem fields
- use get_endpoint() instead of directly checking the EP
was registered.
v4 -> v5:
- initialize bufstate.error to false
- add cpu_to_le64(size)
---
hw/virtio/trace-events | 2 +
hw/virtio/virtio-iommu.c | 187 ++++++++++++++++++++++++++++++++++++++++++++++-
2 files changed, 187 insertions(+), 2 deletions(-)
diff --git a/hw/virtio/trace-events b/hw/virtio/trace-events
index 4041af6..69aba56 100644
--- a/hw/virtio/trace-events
+++ b/hw/virtio/trace-events
@@ -67,3 +67,5 @@ virtio_iommu_unmap_left_interval(uint64_t low, uint64_t high, uint64_t next_low,
virtio_iommu_unmap_right_interval(uint64_t low, uint64_t high, uint64_t next_low, uint64_t next_high) "Unmap right [0x%"PRIx64",0x%"PRIx64"], new interval=[0x%"PRIx64",0x%"PRIx64"]"
virtio_iommu_unmap_inc_interval(uint64_t low, uint64_t high) "Unmap inc [0x%"PRIx64",0x%"PRIx64"]"
virtio_iommu_translate_out(uint64_t virt_addr, uint64_t phys_addr, uint32_t sid) "0x%"PRIx64" -> 0x%"PRIx64 " for sid=%d"
+virtio_iommu_fill_resv_property(uint32_t devid, uint8_t subtype, uint64_t start, uint64_t end, uint32_t flags, size_t filled) "dev= %d, subtype=%d start=0x%"PRIx64" end=0x%"PRIx64" flags=%d filled=0x%lx"
+virtio_iommu_fill_none_property(uint32_t devid) "devid=%d"
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index 6f44d15..0291a04 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -40,6 +40,11 @@
/* Max size */
#define VIOMMU_DEFAULT_QUEUE_SIZE 256
+#define VIOMMU_PROBE_SIZE 512
+
+#define SUPPORTED_PROBE_PROPERTIES (\
+ VIRTIO_IOMMU_PROBE_T_NONE | \
+ VIRTIO_IOMMU_PROBE_T_RESV_MEM)
typedef struct viommu_domain {
uint32_t id;
@@ -52,6 +57,7 @@ typedef struct viommu_endpoint {
viommu_domain *domain;
QLIST_ENTRY(viommu_endpoint) next;
VirtIOIOMMU *viommu;
+ GTree *reserved_regions;
} viommu_endpoint;
typedef struct viommu_interval {
@@ -66,6 +72,13 @@ typedef struct viommu_mapping {
uint32_t flags;
} viommu_mapping;
+typedef struct viommu_property_buffer {
+ viommu_endpoint *endpoint;
+ size_t filled;
+ uint8_t *start;
+ bool error;
+} viommu_property_buffer;
+
static inline uint16_t virtio_iommu_get_sid(IOMMUDevice *dev)
{
return PCI_BUILD_BDF(pci_bus_num(dev->bus), dev->devfn);
@@ -105,6 +118,9 @@ static viommu_endpoint *virtio_iommu_get_endpoint(VirtIOIOMMU *s,
ep->viommu = s;
trace_virtio_iommu_get_endpoint(ep_id);
g_tree_insert(s->endpoints, GUINT_TO_POINTER(ep_id), ep);
+ ep->reserved_regions = g_tree_new_full((GCompareDataFunc)interval_cmp,
+ NULL, (GDestroyNotify)g_free,
+ (GDestroyNotify)g_free);
return ep;
}
@@ -118,6 +134,7 @@ static void virtio_iommu_put_endpoint(gpointer data)
}
trace_virtio_iommu_put_endpoint(ep->id);
+ g_tree_destroy(ep->reserved_regions);
g_free(ep);
}
@@ -361,6 +378,136 @@ static int virtio_iommu_unmap(VirtIOIOMMU *s,
return VIRTIO_IOMMU_S_INVAL;
}
+/**
+ * virtio_iommu_fill_resv_mem_prop - Add a RESV_MEM probe
+ * property into the probe request buffer
+ *
+ * @key: interval handle
+ * @value: handle to the reserved memory region
+ * @data: handle to the probe request buffer state
+ */
+static gboolean virtio_iommu_fill_resv_mem_prop(gpointer key,
+ gpointer value,
+ gpointer data)
+{
+ struct virtio_iommu_probe_resv_mem *resv =
+ (struct virtio_iommu_probe_resv_mem *)value;
+ struct virtio_iommu_probe_property *prop;
+ struct virtio_iommu_probe_resv_mem *current;
+ viommu_property_buffer *bufstate = (viommu_property_buffer *)data;
+ size_t size = sizeof(*resv), total_size;
+
+ total_size = size + sizeof(*prop);
+
+ if (bufstate->filled + total_size >= VIOMMU_PROBE_SIZE) {
+ bufstate->error = true;
+ /* get the traversal stopped by returning true */
+ return true;
+ }
+ prop = (struct virtio_iommu_probe_property *)
+ (bufstate->start + bufstate->filled);
+ prop->type = cpu_to_le16(VIRTIO_IOMMU_PROBE_T_RESV_MEM) &
+ VIRTIO_IOMMU_PROBE_T_MASK;
+ prop->length = cpu_to_le16(size);
+
+ current = (struct virtio_iommu_probe_resv_mem *)prop->value;
+ *current = *resv;
+ bufstate->filled += total_size;
+ trace_virtio_iommu_fill_resv_property(bufstate->endpoint->id,
+ resv->subtype, resv->start,
+ resv->end, resv->subtype,
+ bufstate->filled);
+ return false;
+}
+
+static int virtio_iommu_fill_none_prop(viommu_property_buffer *bufstate)
+{
+ struct virtio_iommu_probe_property *prop;
+
+ prop = (struct virtio_iommu_probe_property *)
+ (bufstate->start + bufstate->filled);
+ prop->type = cpu_to_le16(VIRTIO_IOMMU_PROBE_T_NONE)
+ & VIRTIO_IOMMU_PROBE_T_MASK;
+ prop->length = 0;
+ bufstate->filled += sizeof(*prop);
+ trace_virtio_iommu_fill_none_property(bufstate->endpoint->id);
+ return 0;
+}
+
+static int virtio_iommu_fill_property(int type,
+ viommu_property_buffer *bufstate)
+{
+ int ret = -ENOSPC;
+
+ if (bufstate->filled + 4 >= VIOMMU_PROBE_SIZE) {
+ /* Even the property header cannot be filled */
+ bufstate->error = true;
+ goto out;
+ }
+
+ switch (type) {
+ case VIRTIO_IOMMU_PROBE_T_NONE:
+ ret = virtio_iommu_fill_none_prop(bufstate);
+ break;
+ case VIRTIO_IOMMU_PROBE_T_RESV_MEM:
+ {
+ viommu_endpoint *ep = bufstate->endpoint;
+
+ g_tree_foreach(ep->reserved_regions,
+ virtio_iommu_fill_resv_mem_prop,
+ bufstate);
+ if (!bufstate->error) {
+ ret = 0;
+ }
+ break;
+ }
+ default:
+ ret = -ENOENT;
+ break;
+ }
+out:
+ if (ret) {
+ error_report("%s property of type=%d could not be filled (%d),"
+ " remaining size = 0x%lx",
+ __func__, type, ret, bufstate->filled);
+ }
+ return ret;
+}
+
+/**
+ * virtio_iommu_probe - Fill the probe request buffer with all
+ * the properties the device is able to return and add a NONE
+ * property at the end.
+ */
+static int virtio_iommu_probe(VirtIOIOMMU *s,
+ struct virtio_iommu_req_probe *req,
+ uint8_t *buf)
+{
+ uint32_t ep_id = le32_to_cpu(req->endpoint);
+ int16_t prop_types = SUPPORTED_PROBE_PROPERTIES, type;
+ viommu_property_buffer bufstate;
+ viommu_endpoint *ep;
+ int ret;
+
+ ep = virtio_iommu_get_endpoint(s, ep_id);
+
+ bufstate.start = buf;
+ bufstate.filled = 0;
+ bufstate.error = false;
+ bufstate.endpoint = ep;
+
+ while ((type = ctz32(prop_types)) != 32) {
+ ret = virtio_iommu_fill_property(1 << type, &bufstate);
+ if (ret) {
+ break;
+ }
+ prop_types &= ~(1 << type);
+ }
+ virtio_iommu_fill_property(VIRTIO_IOMMU_PROBE_T_NONE, &bufstate);
+
+ return VIRTIO_IOMMU_S_OK;
+}
+
#define get_payload_size(req) (\
sizeof((req)) - sizeof(struct virtio_iommu_req_tail))
@@ -425,6 +572,24 @@ static int virtio_iommu_handle_unmap(VirtIOIOMMU *s,
return virtio_iommu_unmap(s, &req);
}
+static int virtio_iommu_handle_probe(VirtIOIOMMU *s,
+ struct iovec *iov,
+ unsigned int iov_cnt,
+ uint8_t *buf)
+{
+ struct virtio_iommu_req_probe req;
+ size_t sz, payload_sz;
+
+ payload_sz = sizeof(req);
+
+ sz = iov_to_buf(iov, iov_cnt, 0, &req, payload_sz);
+ if (sz != payload_sz) {
+ return VIRTIO_IOMMU_S_INVAL;
+ }
+
+ return virtio_iommu_probe(s, &req, buf);
+}
+
static void virtio_iommu_handle_command(VirtIODevice *vdev, VirtQueue *vq)
{
VirtIOIOMMU *s = VIRTIO_IOMMU(vdev);
@@ -469,16 +634,32 @@ static void virtio_iommu_handle_command(VirtIODevice *vdev, VirtQueue *vq)
case VIRTIO_IOMMU_T_UNMAP:
tail.status = virtio_iommu_handle_unmap(s, iov, iov_cnt);
break;
+ case VIRTIO_IOMMU_T_PROBE:
+ {
+ struct virtio_iommu_req_tail *ptail;
+ uint8_t *buf = g_malloc0(s->config.probe_size + sizeof(tail));
+
+ ptail = (struct virtio_iommu_req_tail *)
+ (buf + s->config.probe_size);
+ ptail->status = virtio_iommu_handle_probe(s, iov, iov_cnt, buf);
+
+ sz = iov_from_buf(elem->in_sg, elem->in_num, 0,
+ buf, s->config.probe_size + sizeof(tail));
+ g_free(buf);
+ assert(sz == s->config.probe_size + sizeof(tail));
+ goto push;
+ }
default:
tail.status = VIRTIO_IOMMU_S_UNSUPP;
}
- qemu_mutex_unlock(&s->mutex);
sz = iov_from_buf(elem->in_sg, elem->in_num, 0,
&tail, sizeof(tail));
assert(sz == sizeof(tail));
- virtqueue_push(vq, elem, sizeof(tail));
+push:
+ qemu_mutex_unlock(&s->mutex);
+ virtqueue_push(vq, elem, sz);
virtio_notify(vdev, vq);
g_free(elem);
}
@@ -575,6 +756,7 @@ static uint64_t virtio_iommu_get_features(VirtIODevice *vdev, uint64_t f,
virtio_add_feature(&f, VIRTIO_RING_F_INDIRECT_DESC);
virtio_add_feature(&f, VIRTIO_IOMMU_F_INPUT_RANGE);
virtio_add_feature(&f, VIRTIO_IOMMU_F_MAP_UNMAP);
+ virtio_add_feature(&f, VIRTIO_IOMMU_F_PROBE);
return f;
}
@@ -619,6 +801,7 @@ static void virtio_iommu_device_realize(DeviceState *dev, Error **errp)
s->config.page_size_mask = TARGET_PAGE_MASK;
s->config.input_range.end = -1UL;
+ s->config.probe_size = VIOMMU_PROBE_SIZE;
qemu_mutex_init(&s->mutex);
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-devel] [RFC v7 10/16] virtio-iommu: Add an msi_bypass property
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (8 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 09/16] virtio-iommu: Implement probe request Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 11/16] virtio-iommu: Implement fault reporting Eric Auger
` (5 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: wei, kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
In case the msi_bypass property is set, it means we need
to register the IOAPIC MSI window as a reserved region:
0xFEE00000 - 0xFEEFFFFF.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
---
hw/virtio/virtio-iommu.c | 52 ++++++++++++++++++++++++++++++++++++++++
include/hw/virtio/virtio-iommu.h | 1 +
2 files changed, 53 insertions(+)
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index 0291a04..ec0cf1e 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -42,6 +42,9 @@
#define VIOMMU_DEFAULT_QUEUE_SIZE 256
#define VIOMMU_PROBE_SIZE 512
+#define IOAPIC_RANGE_START (0xfee00000)
+#define IOAPIC_RANGE_SIZE (0x100000)
+
#define SUPPORTED_PROBE_PROPERTIES (\
VIRTIO_IOMMU_PROBE_T_NONE | \
VIRTIO_IOMMU_PROBE_T_RESV_MEM)
@@ -104,6 +107,25 @@ static void virtio_iommu_detach_endpoint_from_domain(viommu_endpoint *ep)
ep->domain = NULL;
}
+static void virtio_iommu_register_resv_region(viommu_endpoint *ep,
+ uint8_t subtype,
+ uint64_t start, uint64_t end)
+{
+ viommu_interval *interval;
+ struct virtio_iommu_probe_resv_mem *reg;
+
+ interval = g_malloc0(sizeof(*interval));
+ interval->low = start;
+ interval->high = end;
+
+ reg = g_malloc0(sizeof(*reg));
+ reg->subtype = subtype;
+ reg->start = cpu_to_le64(start);
+ reg->end = cpu_to_le64(end);
+
+ g_tree_insert(ep->reserved_regions, interval, reg);
+}
+
static viommu_endpoint *virtio_iommu_get_endpoint(VirtIOIOMMU *s,
uint32_t ep_id)
{
@@ -121,6 +143,12 @@ static viommu_endpoint *virtio_iommu_get_endpoint(VirtIOIOMMU *s,
ep->reserved_regions = g_tree_new_full((GCompareDataFunc)interval_cmp,
NULL, (GDestroyNotify)g_free,
(GDestroyNotify)g_free);
+ if (s->msi_bypass) {
+ virtio_iommu_register_resv_region(ep, VIRTIO_IOMMU_RESV_MEM_T_MSI,
+ IOAPIC_RANGE_START,
+ IOAPIC_RANGE_SIZE);
+ }
+
return ep;
}
@@ -841,8 +869,32 @@ static void virtio_iommu_set_status(VirtIODevice *vdev, uint8_t status)
trace_virtio_iommu_device_status(status);
}
+static bool virtio_iommu_get_msi_bypass(Object *obj, Error **errp)
+{
+ VirtIOIOMMU *s = VIRTIO_IOMMU(obj);
+
+ return s->msi_bypass;
+}
+
+static void virtio_iommu_set_msi_bypass(Object *obj, bool value, Error **errp)
+{
+ VirtIOIOMMU *s = VIRTIO_IOMMU(obj);
+
+ s->msi_bypass = value;
+}
+
static void virtio_iommu_instance_init(Object *obj)
{
+ VirtIOIOMMU *s = VIRTIO_IOMMU(obj);
+
+ object_property_add_bool(obj, "msi_bypass", virtio_iommu_get_msi_bypass,
+ virtio_iommu_set_msi_bypass, NULL);
+ object_property_set_description(obj, "msi_bypass",
+ "Indicates whether msis are bypassed by "
+ "the IOMMU. Default is YES",
+ NULL);
+
+ s->msi_bypass = true;
}
static const VMStateDescription vmstate_virtio_iommu = {
diff --git a/include/hw/virtio/virtio-iommu.h b/include/hw/virtio/virtio-iommu.h
index 913e96b..aa20ba4 100644
--- a/include/hw/virtio/virtio-iommu.h
+++ b/include/hw/virtio/virtio-iommu.h
@@ -58,6 +58,7 @@ typedef struct VirtIOIOMMU {
GTree *domains;
QemuMutex mutex;
GTree *endpoints;
+ bool msi_bypass;
} VirtIOIOMMU;
#endif
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-devel] [RFC v7 11/16] virtio-iommu: Implement fault reporting
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (9 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 10/16] virtio-iommu: Add an msi_bypass property Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 12/16] virtio_iommu: Handle reserved regions in translation process Eric Auger
` (4 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: wei, kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
The event queue allows to report asynchronous errors.
The translate function now injects faults when relevant.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
hw/virtio/trace-events | 1 +
hw/virtio/virtio-iommu.c | 67 +++++++++++++++++++++++++++++++++++++++++++++---
2 files changed, 65 insertions(+), 3 deletions(-)
diff --git a/hw/virtio/trace-events b/hw/virtio/trace-events
index 69aba56..9a60366 100644
--- a/hw/virtio/trace-events
+++ b/hw/virtio/trace-events
@@ -69,3 +69,4 @@ virtio_iommu_unmap_inc_interval(uint64_t low, uint64_t high) "Unmap inc [0x%"PRI
virtio_iommu_translate_out(uint64_t virt_addr, uint64_t phys_addr, uint32_t sid) "0x%"PRIx64" -> 0x%"PRIx64 " for sid=%d"
virtio_iommu_fill_resv_property(uint32_t devid, uint8_t subtype, uint64_t start, uint64_t end, uint32_t flags, size_t filled) "dev= %d, subtype=%d start=0x%"PRIx64" end=0x%"PRIx64" flags=%d filled=0x%lx"
virtio_iommu_fill_none_property(uint32_t devid) "devid=%d"
+virtio_iommu_report_fault(uint8_t reason, uint32_t flags, uint32_t endpoint, uint64_t addr) "FAULT reason=%d flags=%d endpoint=%d address =0x%"PRIx64
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index ec0cf1e..7b77b3b 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -693,16 +693,62 @@ push:
}
}
+static void virtio_iommu_report_fault(VirtIOIOMMU *viommu, uint8_t reason,
+ uint32_t flags, uint32_t endpoint,
+ uint64_t address)
+{
+ VirtIODevice *vdev = &viommu->parent_obj;
+ VirtQueue *vq = viommu->event_vq;
+ struct virtio_iommu_fault fault;
+ VirtQueueElement *elem;
+ size_t sz;
+
+ memset(&fault, 0, sizeof(fault));
+ fault.reason = reason;
+ fault.flags = flags;
+ fault.endpoint = endpoint;
+ fault.address = address;
+
+ for (;;) {
+ elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
+
+ if (!elem) {
+ virtio_error(vdev,
+ "no buffer available in event queue to report event");
+ return;
+ }
+
+ if (iov_size(elem->in_sg, elem->in_num) < sizeof(fault)) {
+ virtio_error(vdev, "error buffer of wrong size");
+ virtqueue_detach_element(vq, elem, 0);
+ g_free(elem);
+ continue;
+ }
+ break;
+ }
+ /* we have a buffer to fill in */
+ sz = iov_from_buf(elem->in_sg, elem->in_num, 0,
+ &fault, sizeof(fault));
+ assert(sz == sizeof(fault));
+
+ trace_virtio_iommu_report_fault(reason, flags, endpoint, address);
+ virtqueue_push(vq, elem, sz);
+ virtio_notify(vdev, vq);
+ g_free(elem);
+
+}
+
static IOMMUTLBEntry virtio_iommu_translate(IOMMUMemoryRegion *mr, hwaddr addr,
IOMMUAccessFlags flag,
int iommu_idx)
{
IOMMUDevice *sdev = container_of(mr, IOMMUDevice, iommu_mr);
VirtIOIOMMU *s = sdev->viommu;
- uint32_t sid;
+ uint32_t sid, flags;
viommu_endpoint *ep;
viommu_mapping *mapping;
viommu_interval interval;
+ bool read_fault, write_fault;
interval.low = addr;
interval.high = addr + 1;
@@ -723,6 +769,8 @@ static IOMMUTLBEntry virtio_iommu_translate(IOMMUMemoryRegion *mr, hwaddr addr,
ep = g_tree_lookup(s->endpoints, GUINT_TO_POINTER(sid));
if (!ep) {
error_report("%s sid=%d is not known!!", __func__, sid);
+ virtio_iommu_report_fault(s, VIRTIO_IOMMU_FAULT_R_UNKNOWN,
+ 0, sid, 0);
goto unlock;
}
@@ -730,6 +778,8 @@ static IOMMUTLBEntry virtio_iommu_translate(IOMMUMemoryRegion *mr, hwaddr addr,
qemu_log_mask(LOG_GUEST_ERROR,
"%s %02x:%02x.%01x not attached to any domain\n",
__func__, PCI_BUS_NUM(sid), PCI_SLOT(sid), PCI_FUNC(sid));
+ virtio_iommu_report_fault(s, VIRTIO_IOMMU_FAULT_R_DOMAIN,
+ 0, sid, 0);
goto unlock;
}
@@ -738,14 +788,25 @@ static IOMMUTLBEntry virtio_iommu_translate(IOMMUMemoryRegion *mr, hwaddr addr,
qemu_log_mask(LOG_GUEST_ERROR,
"%s no mapping for 0x%"PRIx64" for sid=%d\n",
__func__, addr, sid);
+ virtio_iommu_report_fault(s, VIRTIO_IOMMU_FAULT_R_MAPPING,
+ 0, sid, addr);
goto unlock;
}
- if (((flag & IOMMU_RO) && !(mapping->flags & VIRTIO_IOMMU_MAP_F_READ)) ||
- ((flag & IOMMU_WO) && !(mapping->flags & VIRTIO_IOMMU_MAP_F_WRITE))) {
+ read_fault = (flag & IOMMU_RO) &&
+ !(mapping->flags & VIRTIO_IOMMU_MAP_F_READ);
+ write_fault = (flag & IOMMU_WO) &&
+ !(mapping->flags & VIRTIO_IOMMU_MAP_F_WRITE);
+
+ flags = read_fault ? VIRTIO_IOMMU_FAULT_F_READ : 0;
+ flags |= write_fault ? VIRTIO_IOMMU_FAULT_F_WRITE : 0;
+ if (flags) {
qemu_log_mask(LOG_GUEST_ERROR,
"Permission error on 0x%"PRIx64"(%d): allowed=%d\n",
addr, flag, mapping->flags);
+ flags |= VIRTIO_IOMMU_FAULT_F_ADDRESS;
+ virtio_iommu_report_fault(s, VIRTIO_IOMMU_FAULT_R_MAPPING,
+ flags, sid, addr);
goto unlock;
}
entry.translated_addr = addr - mapping->virt_addr + mapping->phys_addr;
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 12/16] virtio_iommu: Handle reserved regions in translation process
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (10 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 11/16] virtio-iommu: Implement fault reporting Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 13/16] qdev: export qbus_find_recursive Eric Auger
` (3 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
When translating an address we need to check if it belongs to
a reserved virtual address range. If it does, there are 2 cases:
- it belongs to a RESERVED region: the guest should neither use
this address in a MAP not instruct the end-point to DMA on
them. We report an error
- It belongs to an MSI region: we bypass the translation.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
hw/virtio/virtio-iommu.c | 16 ++++++++++++++++
1 file changed, 16 insertions(+)
diff --git a/hw/virtio/virtio-iommu.c b/hw/virtio/virtio-iommu.c
index 7b77b3b..6a1d214 100644
--- a/hw/virtio/virtio-iommu.c
+++ b/hw/virtio/virtio-iommu.c
@@ -749,6 +749,7 @@ static IOMMUTLBEntry virtio_iommu_translate(IOMMUMemoryRegion *mr, hwaddr addr,
viommu_mapping *mapping;
viommu_interval interval;
bool read_fault, write_fault;
+ struct virtio_iommu_probe_resv_mem *reg;
interval.low = addr;
interval.high = addr + 1;
@@ -774,6 +775,21 @@ static IOMMUTLBEntry virtio_iommu_translate(IOMMUMemoryRegion *mr, hwaddr addr,
goto unlock;
}
+ reg = g_tree_lookup(ep->reserved_regions, (gpointer)(&interval));
+ if (reg) {
+ switch (reg->subtype) {
+ case VIRTIO_IOMMU_RESV_MEM_T_MSI:
+ entry.perm = flag;
+ break;
+ case VIRTIO_IOMMU_RESV_MEM_T_RESERVED:
+ default:
+ virtio_iommu_report_fault(s, VIRTIO_IOMMU_FAULT_R_MAPPING,
+ 0, sid, addr);
+ break;
+ }
+ goto unlock;
+ }
+
if (!ep->domain) {
qemu_log_mask(LOG_GUEST_ERROR,
"%s %02x:%02x.%01x not attached to any domain\n",
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 13/16] qdev: export qbus_find_recursive
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (11 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 12/16] virtio_iommu: Handle reserved regions in translation process Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 14/16] hw/arm/virt: Add virtio-iommu to the virt board Eric Auger
` (2 subsequent siblings)
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
We intend to create the virtio-iommu from the virt machine
realize() code and not by passing the -device virtio-iommu-device
option. That way the instantiation of the virtio-iommu can
depend on a virt machine option, as it is currently done for
the smmuv3 iommu.
Its parent bus, the virtio-bus will need to be located and
set. We intend to locate it by using qbus_find_recursive().
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
include/hw/qdev-core.h | 3 +++
qdev-monitor.c | 5 ++---
2 files changed, 5 insertions(+), 3 deletions(-)
diff --git a/include/hw/qdev-core.h b/include/hw/qdev-core.h
index f1fd0f8..f359c52 100644
--- a/include/hw/qdev-core.h
+++ b/include/hw/qdev-core.h
@@ -377,6 +377,9 @@ void qbus_reset_all_fn(void *opaque);
/* This should go away once we get rid of the NULL bus hack */
BusState *sysbus_get_default(void);
+BusState *qbus_find_recursive(BusState *bus, const char *name,
+ const char *bus_typename);
+
char *qdev_get_fw_dev_path(DeviceState *dev);
char *qdev_get_own_fw_dev_path_from_handler(BusState *bus, DeviceState *dev);
diff --git a/qdev-monitor.c b/qdev-monitor.c
index 61e0300..666e439 100644
--- a/qdev-monitor.c
+++ b/qdev-monitor.c
@@ -410,8 +410,8 @@ static inline bool qbus_is_full(BusState *bus)
* If more than one exists, prefer one that can take another device.
* Return the bus if found, else %NULL.
*/
-static BusState *qbus_find_recursive(BusState *bus, const char *name,
- const char *bus_typename)
+BusState *qbus_find_recursive(BusState *bus, const char *name,
+ const char *bus_typename)
{
BusChild *kid;
BusState *pick, *child, *ret;
@@ -567,7 +567,6 @@ DeviceState *qdev_device_add(QemuOpts *opts, Error **errp)
error_setg(errp, QERR_MISSING_PARAMETER, "driver");
return NULL;
}
-
/* find driver */
dc = qdev_get_device_class(&driver, errp);
if (!dc) {
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 14/16] hw/arm/virt: Add virtio-iommu to the virt board
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (12 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 13/16] qdev: export qbus_find_recursive Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 15/16] hw/arm/virt-acpi-build: Add virtio-iommu node in IORT table Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 16/16] hw/arm/virt: Allow virtio-iommu instantiation Eric Auger
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
Both the virtio-iommu device and its dedicated mmio
transport get instantiated when requested.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
v6 -> v7:
- align to the smmu instantiation code
v4 -> v5:
- VirtMachineClass no_iommu added in this patch
- Use object_resolve_path_type
---
hw/arm/virt.c | 51 ++++++++++++++++++++++++++++++++++++++++++++++++++-
include/hw/arm/virt.h | 1 +
2 files changed, 51 insertions(+), 1 deletion(-)
diff --git a/hw/arm/virt.c b/hw/arm/virt.c
index 281ddcd..dd3cc71 100644
--- a/hw/arm/virt.c
+++ b/hw/arm/virt.c
@@ -29,6 +29,7 @@
*/
#include "qemu/osdep.h"
+#include "monitor/qdev.h"
#include "qapi/error.h"
#include "hw/sysbus.h"
#include "hw/arm/arm.h"
@@ -59,6 +60,7 @@
#include "qapi/visitor.h"
#include "standard-headers/linux/input.h"
#include "hw/arm/smmuv3.h"
+#include "hw/virtio/virtio-iommu.h"
#define DEFINE_VIRT_MACHINE_LATEST(major, minor, latest) \
static void virt_##major##_##minor##_class_init(ObjectClass *oc, \
@@ -141,6 +143,7 @@ static const MemMapEntry a15memmap[] = {
[VIRT_GPIO] = { 0x09030000, 0x00001000 },
[VIRT_SECURE_UART] = { 0x09040000, 0x00001000 },
[VIRT_SMMU] = { 0x09050000, 0x00020000 },
+ [VIRT_VIRTIO_IOMMU] = { 0x09070000, 0x00000200 },
[VIRT_MMIO] = { 0x0a000000, 0x00000200 },
/* ...repeating for a total of NUM_VIRTIO_TRANSPORTS, each of that size */
[VIRT_PLATFORM_BUS] = { 0x0c000000, 0x02000000 },
@@ -165,6 +168,7 @@ static const int a15irqmap[] = {
[VIRT_MMIO] = 16, /* ...to 16 + NUM_VIRTIO_TRANSPORTS - 1 */
[VIRT_GIC_V2M] = 48, /* ...to 48 + NUM_GICV2M_SPIS - 1 */
[VIRT_SMMU] = 74, /* ...to 74 + NUM_SMMU_IRQS - 1 */
+ [VIRT_VIRTIO_IOMMU] = 75,
[VIRT_PLATFORM_BUS] = 112, /* ...to 112 + PLATFORM_BUS_NUM_IRQS -1 */
};
@@ -1047,6 +1051,42 @@ static void create_smmu(const VirtMachineState *vms, qemu_irq *pic,
g_free(node);
}
+static void create_virtio_iommu(VirtMachineState *vms, qemu_irq *pic,
+ PCIBus *bus)
+{
+ const char compat[] = "virtio,mmio";
+ int irq = vms->irqmap[VIRT_VIRTIO_IOMMU];
+ hwaddr base = vms->memmap[VIRT_VIRTIO_IOMMU].base;
+ hwaddr size = vms->memmap[VIRT_VIRTIO_IOMMU].size;
+ DeviceState *dev;
+ BusState *virtio_bus;
+ char *node;
+
+ sysbus_create_simple("virtio-mmio", base, pic[irq]);
+
+ virtio_bus = qbus_find_recursive(sysbus_get_default(), NULL, "virtio-bus");
+ dev = DEVICE(object_new("virtio-iommu-device"));
+ qdev_set_parent_bus(dev, virtio_bus);
+ object_property_set_link(OBJECT(dev), OBJECT(bus), "primary-bus",
+ &error_abort);
+ object_property_set_bool(OBJECT(dev), false, "msi_bypass", &error_fatal);
+ object_property_set_bool(OBJECT(dev), true, "realized", &error_abort);
+
+ node = g_strdup_printf("/virtio_mmio@%" PRIx64, base);
+ qemu_fdt_add_subnode(vms->fdt, node);
+ qemu_fdt_setprop(vms->fdt, node, "compatible", compat, sizeof(compat));
+ qemu_fdt_setprop_sized_cells(vms->fdt, node, "reg", 2, base, 2, size);
+
+ qemu_fdt_setprop_cells(vms->fdt, node, "interrupts",
+ GIC_FDT_IRQ_TYPE_SPI, irq, GIC_FDT_IRQ_FLAGS_EDGE_LO_HI);
+
+ qemu_fdt_setprop(vms->fdt, node, "dma-coherent", NULL, 0);
+ qemu_fdt_setprop_cell(vms->fdt, node, "#iommu-cells", 1);
+ qemu_fdt_setprop_cell(vms->fdt, node, "phandle", vms->iommu_phandle);
+ g_free(node);
+}
+
+
static void create_pcie(VirtMachineState *vms, qemu_irq *pic)
{
hwaddr base_mmio = vms->memmap[VIRT_PCIE_MMIO].base;
@@ -1167,7 +1207,16 @@ static void create_pcie(VirtMachineState *vms, qemu_irq *pic)
if (vms->iommu) {
vms->iommu_phandle = qemu_fdt_alloc_phandle(vms->fdt);
- create_smmu(vms, pic, pci->bus);
+ switch (vms->iommu) {
+ case VIRT_IOMMU_SMMUV3:
+ create_smmu(vms, pic, pci->bus);
+ break;
+ case VIRT_IOMMU_VIRTIO:
+ create_virtio_iommu(vms, pic, pci->bus);
+ break;
+ default:
+ g_assert_not_reached();
+ }
qemu_fdt_setprop_cells(vms->fdt, nodename, "iommu-map",
0x0, vms->iommu_phandle, 0x0, 0x10000);
diff --git a/include/hw/arm/virt.h b/include/hw/arm/virt.h
index 9a870cc..837c135 100644
--- a/include/hw/arm/virt.h
+++ b/include/hw/arm/virt.h
@@ -64,6 +64,7 @@ enum {
VIRT_GIC_REDIST,
VIRT_GIC_REDIST2,
VIRT_SMMU,
+ VIRT_VIRTIO_IOMMU,
VIRT_UART,
VIRT_MMIO,
VIRT_RTC,
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-arm] [RFC v7 15/16] hw/arm/virt-acpi-build: Add virtio-iommu node in IORT table
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (13 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 14/16] hw/arm/virt: Add virtio-iommu to the virt board Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 16/16] hw/arm/virt: Allow virtio-iommu instantiation Eric Auger
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
This patch builds the virtio-iommu node in the ACPI IORT table.
The RID space of the root complex, which spans 0x0-0x10000
maps to streamid space 0x0-0x10000 in smmuv3, which in turn
maps to deviceid space 0x0-0x10000 in the ITS group.
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
hw/arm/virt-acpi-build.c | 39 ++++++++++++++++++++++++++++++++-------
include/hw/acpi/acpi-defs.h | 21 ++++++++++++++++++++-
2 files changed, 52 insertions(+), 8 deletions(-)
diff --git a/hw/arm/virt-acpi-build.c b/hw/arm/virt-acpi-build.c
index 6ea47e2..a856a31 100644
--- a/hw/arm/virt-acpi-build.c
+++ b/hw/arm/virt-acpi-build.c
@@ -403,14 +403,13 @@ build_iort(GArray *table_data, BIOSLinker *linker, VirtMachineState *vms)
AcpiIortIdMapping *idmap;
AcpiIortItsGroup *its;
AcpiIortTable *iort;
- AcpiIortSmmu3 *smmu;
- size_t node_size, iort_node_offset, iort_length, smmu_offset = 0;
+ size_t node_size, iort_node_offset, iort_length, iommu_offset = 0;
AcpiIortRC *rc;
iort = acpi_data_push(table_data, sizeof(*iort));
- if (vms->iommu == VIRT_IOMMU_SMMUV3) {
- nb_nodes = 3; /* RC, ITS, SMMUv3 */
+ if (vms->iommu) {
+ nb_nodes = 3; /* RC, ITS, IOMMU */
} else {
nb_nodes = 2; /* RC, ITS */
}
@@ -435,10 +434,11 @@ build_iort(GArray *table_data, BIOSLinker *linker, VirtMachineState *vms)
its->identifiers[0] = 0; /* MADT translation_id */
if (vms->iommu == VIRT_IOMMU_SMMUV3) {
+ AcpiIortSmmu3 *smmu;
int irq = vms->irqmap[VIRT_SMMU];
/* SMMUv3 node */
- smmu_offset = iort_node_offset + node_size;
+ iommu_offset = iort_node_offset + node_size;
node_size = sizeof(*smmu) + sizeof(*idmap);
iort_length += node_size;
smmu = acpi_data_push(table_data, node_size);
@@ -460,6 +460,31 @@ build_iort(GArray *table_data, BIOSLinker *linker, VirtMachineState *vms)
idmap->output_base = 0;
/* output IORT node is the ITS group node (the first node) */
idmap->output_reference = cpu_to_le32(iort_node_offset);
+ } else if (vms->iommu == VIRT_IOMMU_VIRTIO) {
+ AcpiIortPVIommu *iommu;
+ int irq = vms->irqmap[VIRT_VIRTIO_IOMMU];
+
+ /* Para-virtualized IOMMU node */
+ iommu_offset = iort_node_offset + node_size;
+ node_size = sizeof(*iommu) + sizeof(*idmap);
+ iort_length += node_size;
+ iommu = acpi_data_push(table_data, node_size);
+
+ iommu->type = ACPI_IORT_NODE_PARAVIRT;
+ iommu->length = cpu_to_le16(node_size);
+ iommu->base_address = cpu_to_le64(vms->memmap[VIRT_VIRTIO_IOMMU].base);
+ iommu->span = cpu_to_le64(vms->memmap[VIRT_VIRTIO_IOMMU].size);
+ iommu->model = ACPI_IORT_NODE_PV_VIRTIO_IOMMU;
+ iommu->flags = ACPI_IORT_NODE_PV_CACHE_COHERENT;
+ iommu->gsiv = cpu_to_le64(irq);
+
+ /* Identity RID mapping covering the whole input RID range */
+ idmap = &iommu->id_mapping_array[0];
+ idmap->input_base = 0;
+ idmap->id_count = cpu_to_le32(0xFFFF);
+ idmap->output_base = 0;
+ /* output IORT node is the ITS group node (the first node) */
+ idmap->output_reference = cpu_to_le32(iort_node_offset);
}
/* Root Complex Node */
@@ -483,9 +508,9 @@ build_iort(GArray *table_data, BIOSLinker *linker, VirtMachineState *vms)
idmap->id_count = cpu_to_le32(0xFFFF);
idmap->output_base = 0;
- if (vms->iommu == VIRT_IOMMU_SMMUV3) {
+ if (vms->iommu) {
/* output IORT node is the smmuv3 node */
- idmap->output_reference = cpu_to_le32(smmu_offset);
+ idmap->output_reference = cpu_to_le32(iommu_offset);
} else {
/* output IORT node is the ITS group node (the first node) */
idmap->output_reference = cpu_to_le32(iort_node_offset);
diff --git a/include/hw/acpi/acpi-defs.h b/include/hw/acpi/acpi-defs.h
index af8e023..1046409 100644
--- a/include/hw/acpi/acpi-defs.h
+++ b/include/hw/acpi/acpi-defs.h
@@ -601,7 +601,8 @@ enum {
ACPI_IORT_NODE_NAMED_COMPONENT = 0x01,
ACPI_IORT_NODE_PCI_ROOT_COMPLEX = 0x02,
ACPI_IORT_NODE_SMMU = 0x03,
- ACPI_IORT_NODE_SMMU_V3 = 0x04
+ ACPI_IORT_NODE_SMMU_V3 = 0x04,
+ ACPI_IORT_NODE_PARAVIRT = 0x80
};
struct AcpiIortIdMapping {
@@ -628,6 +629,24 @@ struct AcpiIortItsGroup {
} QEMU_PACKED;
typedef struct AcpiIortItsGroup AcpiIortItsGroup;
+struct AcpiIortPVIommu {
+ ACPI_IORT_NODE_HEADER_DEF
+ uint64_t base_address;
+ uint64_t span;
+ uint32_t model;
+ uint32_t flags;
+ uint64_t gsiv;
+ uint64_t reserved2;
+ AcpiIortIdMapping id_mapping_array[0];
+} QEMU_PACKED;
+typedef struct AcpiIortPVIommu AcpiIortPVIommu;
+
+enum {
+ ACPI_IORT_NODE_PV_VIRTIO_IOMMU = 0x00,
+};
+
+#define ACPI_IORT_NODE_PV_CACHE_COHERENT (1 << 0)
+
struct AcpiIortSmmu3 {
ACPI_IORT_NODE_HEADER_DEF
uint64_t base_address;
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
* [Qemu-devel] [RFC v7 16/16] hw/arm/virt: Allow virtio-iommu instantiation
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
` (14 preceding siblings ...)
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 15/16] hw/arm/virt-acpi-build: Add virtio-iommu node in IORT table Eric Auger
@ 2018-08-06 20:14 ` Eric Auger
15 siblings, 0 replies; 17+ messages in thread
From: Eric Auger @ 2018-08-06 20:14 UTC (permalink / raw)
To: eric.auger.pro, eric.auger, qemu-devel, qemu-arm, peter.maydell,
alex.williamson, mst, jean-philippe.brucker
Cc: wei, kevin.tian, tn, will.deacon, drjones, peterx, linuc.decode,
bharat.bhushan
The virtio-iommu now can be instantiated by adding the virt
machine option "-M virt,iommu=virtio"
Signed-off-by: Eric Auger <eric.auger@redhat.com>
---
hw/arm/virt.c | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/hw/arm/virt.c b/hw/arm/virt.c
index dd3cc71..25f7c21 100644
--- a/hw/arm/virt.c
+++ b/hw/arm/virt.c
@@ -1679,6 +1679,8 @@ static char *virt_get_iommu(Object *obj, Error **errp)
return g_strdup("none");
case VIRT_IOMMU_SMMUV3:
return g_strdup("smmuv3");
+ case VIRT_IOMMU_VIRTIO:
+ return g_strdup("virtio");
default:
g_assert_not_reached();
}
@@ -1690,11 +1692,13 @@ static void virt_set_iommu(Object *obj, const char *value, Error **errp)
if (!strcmp(value, "smmuv3")) {
vms->iommu = VIRT_IOMMU_SMMUV3;
+ } else if (!strcmp(value, "virtio")) {
+ vms->iommu = VIRT_IOMMU_VIRTIO;
} else if (!strcmp(value, "none")) {
vms->iommu = VIRT_IOMMU_NONE;
} else {
error_setg(errp, "Invalid iommu value");
- error_append_hint(errp, "Valid values are none, smmuv3.\n");
+ error_append_hint(errp, "Valid values are none, smmuv3, virtio.\n");
}
}
@@ -1872,7 +1876,7 @@ static void virt_3_0_instance_init(Object *obj)
object_property_add_str(obj, "iommu", virt_get_iommu, virt_set_iommu, NULL);
object_property_set_description(obj, "iommu",
"Set the IOMMU type. "
- "Valid values are none and smmuv3",
+ "Valid values are none, smmuv3, virtio",
NULL);
vms->memmap = a15memmap;
--
2.5.5
^ permalink raw reply related [flat|nested] 17+ messages in thread
end of thread, other threads:[~2018-08-06 20:30 UTC | newest]
Thread overview: 17+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2018-08-06 20:14 [Qemu-arm] [RFC v7 00/16] VIRTIO-IOMMU device Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 01/16] linux-headers: Partial update for virtio-iommu v0.7 Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 02/16] virtio-iommu: Add skeleton Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 03/16] virtio-iommu: Decode the command payload Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 04/16] virtio-iommu: Add the iommu regions Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 05/16] virtio-iommu: Endpoint and domains structs and helpers Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 06/16] virtio-iommu: Implement attach/detach command Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 07/16] virtio-iommu: Implement map/unmap Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 08/16] virtio-iommu: Implement translate Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 09/16] virtio-iommu: Implement probe request Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 10/16] virtio-iommu: Add an msi_bypass property Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 11/16] virtio-iommu: Implement fault reporting Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 12/16] virtio_iommu: Handle reserved regions in translation process Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 13/16] qdev: export qbus_find_recursive Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 14/16] hw/arm/virt: Add virtio-iommu to the virt board Eric Auger
2018-08-06 20:14 ` [Qemu-arm] [RFC v7 15/16] hw/arm/virt-acpi-build: Add virtio-iommu node in IORT table Eric Auger
2018-08-06 20:14 ` [Qemu-devel] [RFC v7 16/16] hw/arm/virt: Allow virtio-iommu instantiation Eric Auger
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).