vDPA shadow virtqueue
Subsystems (2)
v6 cover vDPA shadow virtqueue
This series enable shadow virtqueue (SVQ) for vhost-vdpa devices. This is intended as a new method of tracking the memory the devices touch during a migration process: Instead of relay on vhost device's dirty logging capability, SVQ intercepts the VQ dataplane forwarding the descriptors between VM and device. This way qemu is the effective writer of guests memory, like in qemu's virtio device operation.
When SVQ is enabled qemu offers a new virtual address space to the device to read and write into, and it maps new vrings and the guest memory in it. SVQ also intercepts kicks and calls between the device and the guest. Used buffers relay would cause dirty memory being tracked.
This effectively means that vDPA device passthrough is intercepted by qemu. While SVQ should only be enabled at migration time, the switching from regular mode to SVQ mode is left for a future series.
It is based on the ideas of DPDK SW assisted LM, in the series of DPDK's https://patchwork.dpdk.org/cover/48370/ . However, these does not map the shadow vq in guest's VA, but in qemu's.
For qemu to use shadow virtqueues the guest virtio driver must not use features like event_idx.
SVQ needs to be enabled with cmdline:
-netdev type=vhost-vdpa,vhostdev=vhost-vdpa-0,id=vhost-vdpa0,svq=on
The first three patches enables notifications forwarding with assistance of qemu. It's easy to enable only this if the relevant cmdline part of the last patch is applied on top of these.
Next four patches implement the actual buffer forwarding. However, address are not translated from HVA so they will need a host device with an iommu allowing them to access all of the HVA range.
The last part of the series uses properly the host iommu, so qemu creates a new iova address space in the device's range and translates the buffers in it. Finally, it adds the cmdline parameter.
Some simple performance tests with netperf were done. They used a nested guest with vp_vdpa, vhost-kernel at L0 host. Starting with no svq and a baseline average of ~9009.96Mbps:
Recv Send Send Socket Socket Message Elapsed Size Size Size Time Throughput bytes bytes bytes secs. 10^6bits/sec 131072 16384 16384 30.01 9061.03 131072 16384 16384 30.01 8962.94 131072 16384 16384 30.01 9005.92
To enable SVQ buffers forwarding reduce throughput to an average of ~7730.7mbps:
Recv Send Send Socket Socket Message Elapsed Size Size Size Time Throughput bytes bytes bytes secs. 10^6bits/sec 131072 16384 16384 30.01 7689.72 131072 16384 16384 30.00 7752.07 131072 16384 16384 30.01 7750.30
However, many performance improvements were left out of this series for simplicity, so difference should shrink in the future.
Comments are welcome.
TODO on future series:
* Event, indirect, packed, and others features of virtio.
* To support different set of features between the device<->SVQ and the SVQ<->guest communication.
* Support of device host notifier memory regions.
* To sepparate buffers forwarding in its own AIO context, so we can throw more threads to that task and we don't need to stop the main event loop.
* Support multiqueue virtio-net vdpa.
* Proper documentation.
Changes from v5:
* Add proper casting on 32 bits compilations.
* Fix merge conflict adding qemu_memalign header
Changes from v4:
* Iterate iova->hva tree instead on maintain own tree so we support HVA overlaps.
* Fix: Errno completion at failure.
* Rename x-svq to svq, so changes to stable does not affect cmdline parameter.
Changes from v3:
* Add @unstable feature to NetdevVhostVDPAOptions.x-svq.
* Fix uncomplete mapping (by 1 byte) of memory regions if svq is enabled. v3 link:
https://lore.kernel.org/qemu-devel/[email protected]/
Changes from v2:
* Less assertions and more error handling in iova tree code.
* Better documentation, both fixing errors and making @param: format
* Homogeneize SVQ avail_idx_shadow and shadow_used_idx to make shadow a prefix at both times.
* Fix: Fo not use VirtQueueElement->len field, track separatedly.
* Split vhost_svq_{enable,disable}_notification, so the code looks more like the kernel driver code.
* Small improvements.
v2 link:
https://lore.kernel.org/all/CAJaqyWfXHE0C54R_-OiwJzjC0gPpkE3eX0L8BeeZXGm1ERYPtA@mail.gmail.com/
Changes from v1:
* Feature set at device->SVQ is now the same as SVQ->guest.
* Size of SVQ is not max available device size anymore, but guest's negotiated.
* Add VHOST_FILE_UNBIND kick and call fd treatment.
* Make SVQ a public struct
* Come back to previous approach to iova-tree
* Some assertions are now fail paths. Some errors are now log_guest.
* Only mask _F_LOG feature at vdpa_set_features svq enable path.
* Refactor some errors and messages. Add missing error unwindings.
* Add memory barrier at _F_NO_NOTIFY set.
* Stop checking for features flags out of transport range. v1 link:
https://lore.kernel.org/virtualization/[email protected]/
Changes from v4 RFC:
* Support of allocating / freeing iova ranges in IOVA tree. Extending already present iova-tree for that.
* Proper validation of guest features. Now SVQ can negotiate a different set of features with the device when enabled.
* Support of host notifiers memory regions
* Handling of SVQ full queue in case guest's descriptors span to different memory regions (qemu's VA chunks).
* Flush pending used buffers at end of SVQ operation.
* QMP command now looks by NetClientState name. Other devices will need to implement it's way to enable vdpa.
* Rename QMP command to set, so it looks more like a way of working
* Better use of qemu error system
* Make a few assertions proper error-handling paths.
* Add more documentation
* Less coupling of virtio / vhost, that could cause friction on changes
* Addressed many other small comments and small fixes.
Changes from v3 RFC:
* Move everything to vhost-vdpa backend. A big change, this allowed some cleanup but more code has been added in other places.
* More use of glib utilities, especially to manage memory.
v3 link:
https://lists.nongnu.org/archive/html/qemu-devel/2021-05/msg06032.html
Changes from v2 RFC:
* Adding vhost-vdpa devices support
* Fixed some memory leaks pointed by different comments
v2 link:
https://lists.nongnu.org/archive/html/qemu-devel/2021-03/msg05600.html
Changes from v1 RFC:
* Use QMP instead of migration to start SVQ mode.
* Only accepting IOMMU devices, closer behavior with target devices
(vDPA)
* Fix invalid masking/unmasking of vhost call fd.
* Use of proper methods for synchronization.
* No need to modify VirtIO device code, all of the changes are contained in vhost code.
* Delete superfluous code.
* An intermediate RFC was sent with only the notifications forwarding changes. It can be seen in
https://patchew.org/QEMU/[email protected]/
v1 link:
https://lists.gnu.org/archive/html/qemu-devel/2020-11/msg05372.html
Eugenio Pérez (20):
virtio: Add VIRTIO_F_QUEUE_STATE
virtio-net: Honor VIRTIO_CONFIG_S_DEVICE_STOPPED
virtio: Add virtio_queue_is_host_notifier_enabled
vhost: Make vhost_virtqueue_{start,stop} public
vhost: Add x-vhost-enable-shadow-vq qmp
vhost: Add VhostShadowVirtqueue
vdpa: Register vdpa devices in a list
vhost: Route guest->host notification through shadow virtqueue Add vhost_svq_get_svq_call_notifier
Add vhost_svq_set_guest_call_notifier
vdpa: Save call_fd in vhost-vdpa
vhost-vdpa: Take into account SVQ in vhost_vdpa_set_vring_call
vhost: Route host->guest notification through shadow virtqueue
virtio: Add vhost_shadow_vq_get_vring_addr
vdpa: Save host and guest features
vhost: Add vhost_svq_valid_device_features to shadow vq
vhost: Shadow virtqueue buffers forwarding
vhost: Add VhostIOVATree
vhost: Use a tree to store memory mappings
vdpa: Add custom IOTLB translations to SVQ
Eugenio Pérez (15):
vhost: Add VhostShadowVirtqueue
vhost: Add Shadow VirtQueue kick forwarding capabilities
vhost: Add Shadow VirtQueue call forwarding capabilities
vhost: Add vhost_svq_valid_features to shadow vq
virtio: Add vhost_svq_get_vring_addr
vdpa: adapt vhost_ops callbacks to svq
vhost: Shadow virtqueue buffers forwarding
util: Add iova_tree_alloc_map
util: add iova_tree_find_iova
vhost: Add VhostIOVATree
vdpa: Add custom IOTLB translations to SVQ
vdpa: Adapt vhost_vdpa_get_vring_base to SVQ
vdpa: Never set log_base addr if SVQ is enabled
vdpa: Expose VHOST_F_LOG_ALL on SVQ
vdpa: Add x-svq to NetdevVhostVDPAOptions
qapi/net.json | 8 +- hw/virtio/vhost-iova-tree.h | 27 ++ hw/virtio/vhost-shadow-virtqueue.h | 87 ++++ include/hw/virtio/vhost-vdpa.h | 8 + include/qemu/iova-tree.h | 38 +- hw/virtio/vhost-iova-tree.c | 110 +++++ hw/virtio/vhost-shadow-virtqueue.c | 636 +++++++++++++++++++++++++++++ hw/virtio/vhost-vdpa.c | 522 ++++++++++++++++++++++- net/vhost-vdpa.c | 48 ++- util/iova-tree.c | 170 ++++++++ hw/virtio/meson.build | 2 +- 11 files changed, 1630 insertions(+), 26 deletions(-) create mode 100644 hw/virtio/vhost-iova-tree.h create mode 100644 hw/virtio/vhost-shadow-virtqueue.h create mode 100644 hw/virtio/vhost-iova-tree.c create mode 100644 hw/virtio/vhost-shadow-virtqueue.c
Signature · 1 line
2.27.0
PATCH v6 1/15 vhost: Add VhostShadowVirtqueue
Vhost shadow virtqueue (SVQ) is an intermediate jump for virtqueue notifications and buffers, allowing qemu to track them. While qemu is forwarding the buffers and virtqueue changes, it is able to commit the memory it's being dirtied, the same way regular qemu's VirtIO devices do.
This commit only exposes basic SVQ allocation and free. Next patches of the series add functionality like notifications and buffers forwarding.
--- hw/virtio/vhost-shadow-virtqueue.h | 28 ++++++++++++++ hw/virtio/vhost-shadow-virtqueue.c | 62 ++++++++++++++++++++++++++++++ hw/virtio/meson.build | 2 +- 3 files changed, 91 insertions(+), 1 deletion(-) create mode 100644 hw/virtio/vhost-shadow-virtqueue.h create mode 100644 hw/virtio/vhost-shadow-virtqueue.c
hw/virtio/vhost-shadow-virtqueue.h new file +28 -0
@@ -0,0 +1,28 @@ +/* +* vhost shadow virtqueue +* +* SPDX-FileCopyrightText: Red Hat, Inc. 2021 +* SPDX-FileContributor: Author: Eugenio Pérez <[email protected]> +* +* SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#ifndef VHOST_SHADOW_VIRTQUEUE_H +#define VHOST_SHADOW_VIRTQUEUE_H + +#include "qemu/event_notifier.h" + +/* Shadow virtqueue to relay notifications */ +typedef struct VhostShadowVirtqueue { +/* Shadow kick notifier, sent to vhost */ +EventNotifier hdev_kick; +/* Shadow call notifier, sent to vhost */ +EventNotifier hdev_call; +}VhostShadowVirtqueue ; + +VhostShadowVirtqueue *vhost_svq_new (void ); + +void vhost_svq_free (gpointer vq); +G_DEFINE_AUTOPTR_CLEANUP_FUNC (VhostShadowVirtqueue, vhost_svq_free); + +#endif
hw/virtio/vhost-shadow-virtqueue.c new file +62 -0
62 lines not on this page · raw message
hw/virtio/meson.build +1 -1
@@ -11,7 +11,7 @@ softmmu_ss.add(when: 'CONFIG_ALL', if_true: files('vhost-stub.c')) virtio_ss = ss.source_set() virtio_ss.add(files('virtio.c')) -virtio_ss.add(when: 'CONFIG_VHOST', if_true: files('vhost.c', 'vhost-backend.c')) +virtio_ss.add(when: 'CONFIG_VHOST', if_true: files('vhost.c', 'vhost-backend.c', 'vhost-shadow-virtqueue.c')) virtio_ss.add(when: 'CONFIG_VHOST_USER', if_true: files('vhost-user.c')) virtio_ss.add(when: 'CONFIG_VHOST_VDPA', if_true: files('vhost-vdpa.c')) virtio_ss.add(when: 'CONFIG_VIRTIO_BALLOON', if_true: files('virtio-balloon.c'))
Signature · 1 line
2.27.0
PATCH v6 2/15 vhost: Add Shadow VirtQueue kick forwarding capabilities
In reply to Eugenio PérezAt this mode no buffer forwarding will be performed in SVQ mode: Qemu will just forward the guest's kicks to the device.
Host memory notifiers regions are left out for simplicity, and they will not be addressed in this series.
--- hw/virtio/vhost-shadow-virtqueue.h | 14 +++ include/hw/virtio/vhost-vdpa.h | 4 + hw/virtio/vhost-shadow-virtqueue.c | 55 +++++++++++ hw/virtio/vhost-vdpa.c | 144 ++++++++++++++++++++++++++++- 4 files changed, 215 insertions(+), 2 deletions(-)
hw/virtio/vhost-shadow-virtqueue.h +14 -0
@@ -18,8 +18,22 @@ typedef struct VhostShadowVirtqueue {EventNotifier hdev_kick;/* Shadow call notifier, sent to vhost */ EventNotifier hdev_call; + +/* +* Borrowed virtqueue's guest to host notifier. To borrow it in this event +* notifier allows to recover the VhostShadowVirtqueue from the event loop +* easily. If we use the VirtQueue's one, we don't have an easy way to +* retrieve VhostShadowVirtqueue. +* +* So shadow virtqueue must not clean it, or we would lose VirtQueue one. +*/ +EventNotifier svq_kick; } VhostShadowVirtqueue; +void vhost_svq_set_svq_kick_fd (VhostShadowVirtqueue *svq,int svq_kick_fd); + +void vhost_svq_stop (VhostShadowVirtqueue *svq); +VhostShadowVirtqueue *vhost_svq_new (void );void vhost_svq_free (gpointer vq);
include/hw/virtio/vhost-vdpa.h +4 -0
@@ -12,6 +12,8 @@#ifndef HW_VIRTIO_VHOST_VDPA_H #define HW_VIRTIO_VHOST_VDPA_H +#include <gmodule.h> +#include "hw/virtio/virtio.h" #include "standard-headers/linux/vhost_types.h"
@@ -27,6 +29,8 @@ typedef struct vhost_vdpa {bool iotlb_batch_begin_sent;MemoryListener listener;struct vhost_vdpa_iova_range iova_range; +bool shadow_vqs_enabled; +GPtrArray *shadow_vqs;struct vhost_dev *dev;VhostVDPAHostNotifier notifier[VIRTIO_QUEUE_MAX ]; } VhostVDPA;
hw/virtio/vhost-shadow-virtqueue.c +55 -0
73 lines not on this page · raw message
hw/virtio/vhost-vdpa.c +142 -2
224 lines not on this page · raw message
Signature · 1 line
2.27.0
PATCH v6 3/15 vhost: Add Shadow VirtQueue call forwarding capabilities
In reply to Eugenio PérezThis will make qemu aware of the device used buffers, allowing it to write the guest memory with its contents if needed.
--- hw/virtio/vhost-shadow-virtqueue.h | 4 ++++ hw/virtio/vhost-shadow-virtqueue.c | 38 ++++++++++++++++++++++++++++++ hw/virtio/vhost-vdpa.c | 31 ++++++++++++++++++++++-- 3 files changed, 71 insertions(+), 2 deletions(-)
hw/virtio/vhost-shadow-virtqueue.h +4 -0
@@ -28,9 +28,13 @@ typedef struct VhostShadowVirtqueue {* So shadow virtqueue must not clean it, or we would lose VirtQueue one. */ EventNotifier svq_kick; + +/* Guest's call notifier, where the SVQ calls guest. */ +EventNotifier svq_call; } VhostShadowVirtqueue;void vhost_svq_set_svq_kick_fd (VhostShadowVirtqueue *svq,int svq_kick_fd); +void vhost_svq_set_svq_call_fd (VhostShadowVirtqueue *svq,int call_fd);void vhost_svq_stop (VhostShadowVirtqueue *svq);
hw/virtio/vhost-shadow-virtqueue.c +38 -0
@@ -26,6 +26,42 @@ static void vhost_handle_guest_kick(EventNotifier *n)event_notifier_set (&svq->hdev_kick); } +/** +* Forward vhost notifications +* +* @n: hdev call event notifier, the one that device set to notify svq. +*/ +static void vhost_svq_handle_call (EventNotifier *n) +{ +VhostShadowVirtqueue *svq =container_of (n, VhostShadowVirtqueue, + hdev_call); +event_notifier_test_and_clear (n); +event_notifier_set (&svq->svq_call); +} + +/** +* Set the call notifier for the SVQ to call the guest +* +* @svq: Shadow virtqueue +* @call_fd: call notifier +* +* Called on BQL context. +*/ +void vhost_svq_set_svq_call_fd (VhostShadowVirtqueue *svq,int call_fd) +{ +if (call_fd ==VHOST_FILE_UNBIND ) { +/* +* Fail event_notifier_set if called handling device call. +* +* SVQ still needs device notifications, since it needs to keep +* forwarding used buffers even with the unbind. +*/ +memset (&svq->svq_call,0 ,sizeof (svq->svq_call)); + }else { +event_notifier_init_fd (&svq->svq_call, call_fd); + } +} +/** * Set a new file descriptor for the guest to kick the SVQ and notify for avail *
@@ -93,6 +129,7 @@ VhostShadowVirtqueue *vhost_svq_new(void) }event_notifier_init_fd (&svq->svq_kick,VHOST_FILE_UNBIND ); +event_notifier_set_handler (&svq->hdev_call, vhost_svq_handle_call);return g_steal_pointer (&svq); err_init_hdev_call:
@@ -112,6 +149,7 @@ void vhost_svq_free(gpointer pvq)VhostShadowVirtqueue *vq = pvq;vhost_svq_stop (vq);event_notifier_cleanup (&vq->hdev_kick); +event_notifier_set_handler (&vq->hdev_call,NULL );event_notifier_cleanup (&vq->hdev_call);g_free (vq); }
hw/virtio/vhost-vdpa.c +29 -2
@@ -725,6 +725,13 @@ static int vhost_vdpa_set_vring_dev_kick(struct vhost_dev *dev,return vhost_vdpa_call (dev,VHOST_SET_VRING_KICK , file); } +static int vhost_vdpa_set_vring_dev_call (struct vhost_dev *dev, +struct vhost_vring_file *file) +{ +trace_vhost_vdpa_set_vring_call (dev, file->index, file->fd); +return vhost_vdpa_call (dev,VHOST_SET_VRING_CALL , file); +} +/** * Set the shadow virtqueue descriptors to the device *
@@ -732,6 +739,9 @@ static int vhost_vdpa_set_vring_dev_kick(struct vhost_dev *dev,* @svq: The shadow virtqueue * @idx: The index of the virtqueue in the vhost device * @errp: Error +* +* Note that this function does not rewind kick file descriptor if cannot set +* call one. */ static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, VhostShadowVirtqueue *svq, unsigned idx,
@@ -747,6 +757,14 @@ static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, r =vhost_vdpa_set_vring_dev_kick (dev, &file);if (unlikely (r !=0 )) {error_setg_errno (errp, -r,"Can't set device kick fd" ); +return false; + } + + event_notifier = &svq->hdev_call; + file.fd =event_notifier_get_fd (event_notifier); + r =vhost_vdpa_set_vring_dev_call (dev, &file); +if (unlikely (r !=0 )) { +error_setg_errno (errp, -r,"Can't set device call fd" ); }return r ==0 ;
@@ -872,8 +890,17 @@ static int vhost_vdpa_set_vring_kick(struct vhost_dev *dev,static int vhost_vdpa_set_vring_call (struct vhost_dev *dev,struct vhost_vring_file *file) { -trace_vhost_vdpa_set_vring_call (dev, file->index, file->fd); -return vhost_vdpa_call (dev,VHOST_SET_VRING_CALL , file); +struct vhost_vdpa *v = dev->opaque; + +if (v->shadow_vqs_enabled) { +int vdpa_idx = file->index - dev->vq_index; +VhostShadowVirtqueue *svq =g_ptr_array_index (v->shadow_vqs, vdpa_idx); + +vhost_svq_set_svq_call_fd (svq, file->fd); +return 0 ; + }else { +return vhost_vdpa_set_vring_dev_call (dev, file); + } } static int vhost_vdpa_get_features(struct vhost_dev *dev,
Signature · 1 line
2.27.0
PATCH v6 4/15 vhost: Add vhost_svq_valid_features to shadow vq
In reply to Eugenio PérezThis allows SVQ to negotiate features with the guest and the device. For the device, SVQ is a driver. While this function bypasses all non-transport features, it needs to disable the features that SVQ does not support when forwarding buffers. This includes packed vq layout, indirect descriptors or event idx.
Future changes can add support to offer more features to the guest, since the use of VirtQueue gives this for free. This is left out at the moment for simplicity.
--- hw/virtio/vhost-shadow-virtqueue.h | 2 ++ hw/virtio/vhost-shadow-virtqueue.c | 44 ++++++++++++++++++++++++++++++ hw/virtio/vhost-vdpa.c | 15 ++++++++++ 3 files changed, 61 insertions(+)
hw/virtio/vhost-shadow-virtqueue.h +2 -0
@@ -33,6 +33,8 @@ typedef struct VhostShadowVirtqueue {EventNotifier svq_call; } VhostShadowVirtqueue; +bool vhost_svq_valid_features (uint64_t features,Error **errp); +void vhost_svq_set_svq_kick_fd (VhostShadowVirtqueue *svq,int svq_kick_fd);void vhost_svq_set_svq_call_fd (VhostShadowVirtqueue *svq,int call_fd);
hw/virtio/vhost-shadow-virtqueue.c +44 -0
53 lines not on this page · raw message
hw/virtio/vhost-vdpa.c +15 -0
@@ -348,11 +348,26 @@ static int vhost_vdpa_init_svq(struct vhost_dev *hdev, struct vhost_vdpa *v, Error **errp) {g_autoptr (GPtrArray) shadow_vqs =NULL ; +uint64_t dev_features, svq_features; +int r; +bool ok;if (!v->shadow_vqs_enabled) {return 0 ; } + r = hdev->vhost_ops->vhost_get_features (hdev, &dev_features); +if (r !=0 ) { +error_setg_errno (errp, -r,"Can't get vdpa device features" ); +return r; + } + + svq_features = dev_features; + ok =vhost_svq_valid_features (svq_features, errp); +if (unlikely (!ok)) { +return -1 ; + } + shadow_vqs =g_ptr_array_new_full (hdev->nvqs, vhost_svq_free);for (unsigned n =0 ; n < hdev->nvqs; ++n) {g_autoptr (VhostShadowVirtqueue) svq =vhost_svq_new ();
Signature · 1 line
2.27.0
PATCH v6 5/15 virtio: Add vhost_svq_get_vring_addr
In reply to Eugenio PérezIt reports the shadow virtqueue address from qemu virtual address space.
Since this will be different from the guest's vaddr, but the device can access it, SVQ takes special care about its alignment & lack of garbage data. It assumes that IOMMU will work in host_page_size ranges for that.
--- hw/virtio/vhost-shadow-virtqueue.h | 9 +++++++++ hw/virtio/vhost-shadow-virtqueue.c | 29 +++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+)
hw/virtio/vhost-shadow-virtqueue.h +9 -0
@@ -11,9 +11,14 @@#define VHOST_SHADOW_VIRTQUEUE_H #include "qemu/event_notifier.h" +#include "hw/virtio/virtio.h" +#include "standard-headers/linux/vhost_types.h" /* Shadow virtqueue to relay notifications */ typedef struct VhostShadowVirtqueue { + /* Shadow vring */ + struct vring vring; + /* Shadow kick notifier, sent to vhost */ EventNotifier hdev_kick; /* Shadow call notifier, sent to vhost */
@@ -37,6 +42,10 @@ bool vhost_svq_valid_features(uint64_t features, Error **errp);void vhost_svq_set_svq_kick_fd (VhostShadowVirtqueue *svq,int svq_kick_fd);void vhost_svq_set_svq_call_fd (VhostShadowVirtqueue *svq,int call_fd); +void vhost_svq_get_vring_addr (const VhostShadowVirtqueue *svq, +struct vhost_vring_addr *addr); +size_t vhost_svq_driver_area_size (const VhostShadowVirtqueue *svq); +size_t vhost_svq_device_area_size (const VhostShadowVirtqueue *svq);void vhost_svq_stop (VhostShadowVirtqueue *svq);
hw/virtio/vhost-shadow-virtqueue.c +29 -0
@@ -106,6 +106,35 @@ void vhost_svq_set_svq_call_fd(VhostShadowVirtqueue *svq, int call_fd) } } +/** +* Get the shadow vq vring address. +* @svq: Shadow virtqueue +* @addr: Destination to store address +*/ +void vhost_svq_get_vring_addr (const VhostShadowVirtqueue *svq, +struct vhost_vring_addr *addr) +{ + addr->desc_user_addr = (uint64_t )(intptr_t )svq->vring.desc; + addr->avail_user_addr = (uint64_t )(intptr_t )svq->vring.avail; + addr->used_user_addr = (uint64_t )(intptr_t )svq->vring.used; +} + +size_t vhost_svq_driver_area_size (const VhostShadowVirtqueue *svq) +{ +size_t desc_size =sizeof (vring_desc_t) * svq->vring.num; +size_t avail_size = offsetof(vring_avail_t , ring) + +sizeof (uint16_t ) * svq->vring.num; + +return ROUND_UP (desc_size + avail_size, qemu_real_host_page_size); +} + +size_t vhost_svq_device_area_size (const VhostShadowVirtqueue *svq) +{ +size_t used_size = offsetof(vring_used_t , ring) + +sizeof (vring_used_elem_t) * svq->vring.num; +return ROUND_UP (used_size, qemu_real_host_page_size); +} +/** * Set a new file descriptor for the guest to kick the SVQ and notify for avail *
Signature · 1 line
2.27.0
PATCH v6 6/15 vdpa: adapt vhost_ops callbacks to svq
In reply to Eugenio PérezFirst half of the buffers forwarding part, preparing vhost-vdpa callbacks to SVQ to offer it. QEMU cannot enable it at this moment, so this is effectively dead code at the moment, but it helps to reduce patch size.
--- hw/virtio/vhost-vdpa.c | 48 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 41 insertions(+), 7 deletions(-)
hw/virtio/vhost-vdpa.c +41 -7
@@ -733,6 +733,13 @@ static int vhost_vdpa_get_config(struct vhost_dev *dev, uint8_t *config,return ret; } +static int vhost_vdpa_set_dev_vring_base (struct vhost_dev *dev, +struct vhost_vring_state *ring) +{ +trace_vhost_vdpa_set_vring_base (dev, ring->index, ring->num); +return vhost_vdpa_call (dev,VHOST_SET_VRING_BASE , ring); +} +static int vhost_vdpa_set_vring_dev_kick (struct vhost_dev *dev,struct vhost_vring_file *file) {
@@ -747,6 +754,18 @@ static int vhost_vdpa_set_vring_dev_call(struct vhost_dev *dev,return vhost_vdpa_call (dev,VHOST_SET_VRING_CALL , file); } +static int vhost_vdpa_set_vring_dev_addr (struct vhost_dev *dev, +struct vhost_vring_addr *addr) +{ +trace_vhost_vdpa_set_vring_addr (dev, addr->index, addr->flags, + addr->desc_user_addr, addr->used_user_addr, + addr->avail_user_addr, + addr->log_guest_addr); + +return vhost_vdpa_call (dev,VHOST_SET_VRING_ADDR , addr); + +} +/** * Set the shadow virtqueue descriptors to the device *
@@ -856,11 +875,17 @@ static int vhost_vdpa_set_log_base(struct vhost_dev *dev, uint64_t base,static int vhost_vdpa_set_vring_addr (struct vhost_dev *dev,struct vhost_vring_addr *addr) { -trace_vhost_vdpa_set_vring_addr (dev, addr->index, addr->flags, - addr->desc_user_addr, addr->used_user_addr, - addr->avail_user_addr, - addr->log_guest_addr); -return vhost_vdpa_call (dev,VHOST_SET_VRING_ADDR , addr); +struct vhost_vdpa *v = dev->opaque; + +if (v->shadow_vqs_enabled) { +/* +* Device vring addr was set at device start. SVQ base is handled by +* VirtQueue code. +*/ +return 0 ; + } + +return vhost_vdpa_set_vring_dev_addr (dev, addr); } static int vhost_vdpa_set_vring_num(struct vhost_dev *dev,
@@ -873,8 +898,17 @@ static int vhost_vdpa_set_vring_num(struct vhost_dev *dev,static int vhost_vdpa_set_vring_base (struct vhost_dev *dev,struct vhost_vring_state *ring) { -trace_vhost_vdpa_set_vring_base (dev, ring->index, ring->num); -return vhost_vdpa_call (dev,VHOST_SET_VRING_BASE , ring); +struct vhost_vdpa *v = dev->opaque; + +if (v->shadow_vqs_enabled) { +/* +* Device vring base was set at device start. SVQ base is handled by +* VirtQueue code. +*/ +return 0 ; + } + +return vhost_vdpa_set_dev_vring_base (dev, ring); } static int vhost_vdpa_get_vring_base(struct vhost_dev *dev,
Signature · 1 line
2.27.0
PATCH v6 7/15 vhost: Shadow virtqueue buffers forwarding
In reply to Eugenio PérezInitial version of shadow virtqueue that actually forward buffers. There is no iommu support at the moment, and that will be addressed in future patches of this series. Since all vhost-vdpa devices use forced IOMMU, this means that SVQ is not usable at this point of the series on any device.
For simplicity it only supports modern devices, that expects vring in little endian, with split ring and no event idx or indirect descriptors. Support for them will not be added in this series.
It reuses the VirtQueue code for the device part. The driver part is based on Linux's virtio_ring driver, but with stripped functionality and optimizations so it's easier to review.
However, forwarding buffers have some particular pieces: One of the most unexpected ones is that a guest's buffer can expand through more than one descriptor in SVQ. While this is handled gracefully by qemu's emulated virtio devices, it may cause unexpected SVQ queue full. This patch also solves it by checking for this condition at both guest's kicks and device's calls. The code may be more elegant in the future if SVQ code runs in its own iocontext.
--- hw/virtio/vhost-shadow-virtqueue.h | 26 +++ hw/virtio/vhost-shadow-virtqueue.c | 352 ++++++++++++++++++++++++++++- hw/virtio/vhost-vdpa.c | 155 ++++++++++++- 3 files changed, 522 insertions(+), 11 deletions(-)
hw/virtio/vhost-shadow-virtqueue.h +26 -0
@@ -36,6 +36,30 @@ typedef struct VhostShadowVirtqueue {/* Guest's call notifier, where the SVQ calls guest. */ EventNotifier svq_call; + +/* Virtio queue shadowing */ +VirtQueue *vq; + +/* Virtio device */ +VirtIODevice *vdev; + +/* Map for use the guest's descriptors */ +VirtQueueElement **ring_id_maps; + +/* Next VirtQueue element that guest made available */ +VirtQueueElement *next_guest_avail_elem; + +/* Next head to expose to the device */ +uint16_t shadow_avail_idx; + +/* Next free descriptor */ +uint16_t free_head; + +/* Last seen used idx */ +uint16_t shadow_used_idx; + +/* Next head to consume from the device */ +uint16_t last_used_idx; } VhostShadowVirtqueue;bool vhost_svq_valid_features (uint64_t features,Error **errp);
@@ -47,6 +71,8 @@ void vhost_svq_get_vring_addr(const VhostShadowVirtqueue *svq,size_t vhost_svq_driver_area_size (const VhostShadowVirtqueue *svq);size_t vhost_svq_device_area_size (const VhostShadowVirtqueue *svq); +void vhost_svq_start (VhostShadowVirtqueue *svq,VirtIODevice *vdev, +VirtQueue *vq);void vhost_svq_stop (VhostShadowVirtqueue *svq);VhostShadowVirtqueue *vhost_svq_new (void );
hw/virtio/vhost-shadow-virtqueue.c +346 -6
393 lines not on this page · raw message
hw/virtio/vhost-vdpa.c +150 -5
188 lines not on this page · raw message
Signature · 1 line
2.27.0
PATCH v6 8/15 util: Add iova_tree_alloc_map
In reply to Eugenio PérezThis iova tree function allows it to look for a hole in allocated regions and return a totally new translation for a given translated address.
It's usage is mainly to allow devices to access qemu address space, remapping guest's one into a new iova space where qemu can add chunks of addresses.
--- include/qemu/iova-tree.h | 18 ++++++ util/iova-tree.c | 136 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 154 insertions(+)
include/qemu/iova-tree.h +18 -0
@@ -29,6 +29,7 @@#define IOVA_OK (0)#define IOVA_ERR_INVALID (-1)/* Invalid parameters */ #define IOVA_ERR_OVERLAP (-2)/* IOVA range overlapped */ +#define IOVA_ERR_NOMEM (-3)/* Cannot allocate */ typedef struct IOVATree IOVATree ; typedef struct DMAMap {
@@ -119,6 +120,23 @@ const DMAMap *iova_tree_find_address(const IOVATree *tree, hwaddr iova);*/ void iova_tree_foreach (IOVATree *tree,iova_tree_iterator iterator); +/** +* iova_tree_alloc_map: +* +* @tree: the iova tree to allocate from +* @map: the new map (as translated addr & size) to allocate in the iova region +* @iova_begin: the minimum address of the allocation +* @iova_end: the maximum addressable direction of the allocation +* +* Allocates a new region of a given size, between iova_min and iova_max. +* +* Return: Same as iova_tree_insert, but cannot overlap and can return error if +* iova tree is out of free contiguous range. The caller gets the assigned iova +* in map->iova. +*/ +int iova_tree_alloc_map (IOVATree *tree,DMAMap *map,hwaddr iova_begin, +hwaddr iova_end); +/** * iova_tree_destroy: *
util/iova-tree.c +136 -0
148 lines not on this page · raw message
Signature · 1 line
2.27.0
PATCH v6 9/15 util: add iova_tree_find_iova
In reply to Eugenio PérezThis function does the reverse operation of iova_tree_find: To look for a mapping that match a translated address so we can do the reverse.
This have linear complexity instead of logarithmic, but it supports overlapping HVA. Future developments could reduce it.
--- include/qemu/iova-tree.h | 20 +++++++++++++++++++- util/iova-tree.c | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 1 deletion(-)
include/qemu/iova-tree.h +19 -1
@@ -83,7 +83,7 @@ int iova_tree_remove(IOVATree *tree, const DMAMap *map);* @tree: the iova tree to search from * @map: the mapping to search * -* Search for a mapping in the iova tree that overlaps with the +* Search for a mapping in the iova tree that iova overlaps with the * mapping range specified. Only the first found mapping will be * returned. *
@@ -95,6 +95,24 @@ int iova_tree_remove(IOVATree *tree, const DMAMap *map);*/ const DMAMap *iova_tree_find (const IOVATree *tree,const DMAMap *map); +/** +* iova_tree_find_iova: +* +* @tree: the iova tree to search from +* @map: the mapping to search +* +* Search for a mapping in the iova tree that translated_addr overlaps with the +* mapping range specified. Only the first found mapping will be +* returned. +* +* Return: DMAMap pointer if found, or NULL if not found. Note that +* the returned DMAMap pointer is maintained internally. User should +* only read the content but never modify or free the content. Also, +* user is responsible to make sure the pointer is valid (say, no +* concurrent deletion in progress). +*/ +const DMAMap *iova_tree_find_iova (const IOVATree *tree,const DMAMap *map); +/** * iova_tree_find_address: *
util/iova-tree.c +34 -0
@@ -37,6 +37,11 @@ struct IOVATreeAllocArgs {bool iova_found; }; +typedef struct IOVATreeFindIOVAArgs { +const DMAMap *needle; +const DMAMap *result; +}IOVATreeFindIOVAArgs ; +/** * Iterate args to the next hole *
@@ -81,6 +86,35 @@ const DMAMap *iova_tree_find(const IOVATree *tree, const DMAMap *map)return g_tree_lookup (tree->tree, map); } +static gboolean iova_tree_find_address_iterator (gpointer key,gpointer value, +gpointer data) +{ +const DMAMap *map = key; +IOVATreeFindIOVAArgs *args = data; +const DMAMap *needle; + +g_assert (key == value); + + needle = args->needle; +if (map->translated_addr + map->size < needle->translated_addr || + needle->translated_addr + needle->size < map->translated_addr) { +return false; + } + + args->result = map; +return true; +} + +const DMAMap *iova_tree_find_iova (const IOVATree *tree,const DMAMap *map) +{ +IOVATreeFindIOVAArgs args = { + .needle = map, + }; + +g_tree_foreach (tree->tree, iova_tree_find_address_iterator, &args); +return args.result; +} +const DMAMap *iova_tree_find_address (const IOVATree *tree,hwaddr iova) {const DMAMap map = { .iova = iova, .size =0 };
Signature · 1 line
2.27.0
PATCH v6 10/15 vhost: Add VhostIOVATree
In reply to Eugenio PérezThis tree is able to look for a translated address from an IOVA address.
At first glance it is similar to util/iova-tree. However, SVQ working on devices with limited IOVA space need more capabilities, like allocating IOVA chunks or performing reverse translations (qemu addresses to iova).
The allocation capability, as "assign a free IOVA address to this chunk of memory in qemu's address space" allows shadow virtqueue to create a new address space that is not restricted by guest's addressable one, so we can allocate shadow vqs vrings outside of it.
It duplicates the tree so it can search efficiently in both directions, and it will signal overlap if iova or the translated address is present in any tree.
--- hw/virtio/vhost-iova-tree.h | 27 +++++++++ hw/virtio/vhost-iova-tree.c | 110 ++++++++++++++++++++++++++++++++++++ hw/virtio/meson.build | 2 +- 3 files changed, 138 insertions(+), 1 deletion(-) create mode 100644 hw/virtio/vhost-iova-tree.h create mode 100644 hw/virtio/vhost-iova-tree.c
hw/virtio/vhost-iova-tree.h new file +27 -0
@@ -0,0 +1,27 @@ +/* +* vhost software live migration iova tree +* +* SPDX-FileCopyrightText: Red Hat, Inc. 2021 +* SPDX-FileContributor: Author: Eugenio Pérez <[email protected]> +* +* SPDX-License-Identifier: GPL-2.0-or-later +*/ + +#ifndef HW_VIRTIO_VHOST_IOVA_TREE_H +#define HW_VIRTIO_VHOST_IOVA_TREE_H + +#include "qemu/iova-tree.h" +#include "exec/memory.h" + +typedef struct VhostIOVATree VhostIOVATree ; + +VhostIOVATree *vhost_iova_tree_new (uint64_t iova_first,uint64_t iova_last); +void vhost_iova_tree_delete (VhostIOVATree *iova_tree); +G_DEFINE_AUTOPTR_CLEANUP_FUNC (VhostIOVATree, vhost_iova_tree_delete); + +const DMAMap *vhost_iova_tree_find_iova (const VhostIOVATree *iova_tree, +const DMAMap *map); +int vhost_iova_tree_map_alloc (VhostIOVATree *iova_tree,DMAMap *map); +void vhost_iova_tree_remove (VhostIOVATree *iova_tree,const DMAMap *map); + +#endif
hw/virtio/vhost-iova-tree.c new file +110 -0
110 lines not on this page · raw message
hw/virtio/meson.build +1 -1
@@ -11,7 +11,7 @@ softmmu_ss.add(when: 'CONFIG_ALL', if_true: files('vhost-stub.c')) virtio_ss = ss.source_set() virtio_ss.add(files('virtio.c')) -virtio_ss.add(when: 'CONFIG_VHOST', if_true: files('vhost.c', 'vhost-backend.c', 'vhost-shadow-virtqueue.c')) +virtio_ss.add(when: 'CONFIG_VHOST', if_true: files('vhost.c', 'vhost-backend.c', 'vhost-shadow-virtqueue.c', 'vhost-iova-tree.c')) virtio_ss.add(when: 'CONFIG_VHOST_USER', if_true: files('vhost-user.c')) virtio_ss.add(when: 'CONFIG_VHOST_VDPA', if_true: files('vhost-vdpa.c')) virtio_ss.add(when: 'CONFIG_VIRTIO_BALLOON', if_true: files('virtio-balloon.c'))
Signature · 1 line
2.27.0
PATCH v6 11/15 vdpa: Add custom IOTLB translations to SVQ
In reply to Eugenio PérezUse translations added in VhostIOVATree in SVQ.
Only introduce usage here, not allocation and deallocation. As with previous patches, we use the dead code paths of shadow_vqs_enabled to avoid commiting too many changes at once. These are impossible to take at the moment.
--- hw/virtio/vhost-shadow-virtqueue.h | 6 +- include/hw/virtio/vhost-vdpa.h | 3 + hw/virtio/vhost-shadow-virtqueue.c | 86 +++++++++++++++++--- hw/virtio/vhost-vdpa.c | 122 ++++++++++++++++++++++++----- 4 files changed, 187 insertions(+), 30 deletions(-)
hw/virtio/vhost-shadow-virtqueue.h +5 -1
@@ -13,6 +13,7 @@#include "qemu/event_notifier.h" #include "hw/virtio/virtio.h" #include "standard-headers/linux/vhost_types.h" +#include "hw/virtio/vhost-iova-tree.h" /* Shadow virtqueue to relay notifications */ typedef struct VhostShadowVirtqueue {
@@ -43,6 +44,9 @@ typedef struct VhostShadowVirtqueue {/* Virtio device */ VirtIODevice *vdev; +/* IOVA mapping */ +VhostIOVATree *iova_tree; +/* Map for use the guest's descriptors */ VirtQueueElement **ring_id_maps;
@@ -75,7 +79,7 @@ void vhost_svq_start(VhostShadowVirtqueue *svq, VirtIODevice *vdev, VirtQueue *vq);void vhost_svq_stop (VhostShadowVirtqueue *svq); -VhostShadowVirtqueue *vhost_svq_new (void ); +VhostShadowVirtqueue *vhost_svq_new (VhostIOVATree *iova_tree);void vhost_svq_free (gpointer vq);G_DEFINE_AUTOPTR_CLEANUP_FUNC (VhostShadowVirtqueue, vhost_svq_free);
include/hw/virtio/vhost-vdpa.h +3 -0
@@ -14,6 +14,7 @@#include <gmodule.h> +#include "hw/virtio/vhost-iova-tree.h" #include "hw/virtio/virtio.h" #include "standard-headers/linux/vhost_types.h"
@@ -30,6 +31,8 @@ typedef struct vhost_vdpa {MemoryListener listener;struct vhost_vdpa_iova_range iova_range;bool shadow_vqs_enabled; +/* IOVA mapping used by the Shadow Virtqueue */ +VhostIOVATree *iova_tree;GPtrArray *shadow_vqs;struct vhost_dev *dev;VhostVDPAHostNotifier notifier[VIRTIO_QUEUE_MAX ];
hw/virtio/vhost-shadow-virtqueue.c +77 -9
132 lines not on this page · raw message
hw/virtio/vhost-vdpa.c +102 -20
182 lines not on this page · raw message
Signature · 1 line
2.27.0
PATCH v6 12/15 vdpa: Adapt vhost_vdpa_get_vring_base to SVQ
In reply to Eugenio PérezThis is needed to achieve migration, so the destination can restore its index.
Setting base as last used idx, so destination will see as available all the entries that the device did not use, including the in-flight processing ones.
This is ok for networking, but other kinds of devices might have problems with these retransmissions.
--- hw/virtio/vhost-vdpa.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+)
hw/virtio/vhost-vdpa.c +17 -0
@@ -1141,8 +1141,25 @@ static int vhost_vdpa_set_vring_base(struct vhost_dev *dev,static int vhost_vdpa_get_vring_base (struct vhost_dev *dev,struct vhost_vring_state *ring) { +struct vhost_vdpa *v = dev->opaque;int ret; +if (v->shadow_vqs_enabled) { +VhostShadowVirtqueue *svq =g_ptr_array_index (v->shadow_vqs, + ring->index); + +/* +* Setting base as last used idx, so destination will see as available +* all the entries that the device did not use, including the in-flight +* processing ones. +* +* TODO: This is ok for networking, but other kinds of devices might +* have problems with these retransmissions. +*/ + ring->num = svq->last_used_idx; +return 0 ; + } + ret =vhost_vdpa_call (dev,VHOST_GET_VRING_BASE , ring);trace_vhost_vdpa_get_vring_base (dev, ring->index, ring->num);return ret;
Signature · 1 line
2.27.0
PATCH v6 13/15 vdpa: Never set log_base addr if SVQ is enabled
In reply to Eugenio PérezSetting the log address would make the device start reporting invalid dirty memory because the SVQ vrings are located in qemu's memory.
--- hw/virtio/vhost-vdpa.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
hw/virtio/vhost-vdpa.c +2 -1
@@ -1090,7 +1090,8 @@ static int vhost_vdpa_dev_start(struct vhost_dev *dev, bool started)static int vhost_vdpa_set_log_base (struct vhost_dev *dev,uint64_t base,struct vhost_log *log) { -if (vhost_vdpa_one_time_request (dev)) { +struct vhost_vdpa *v = dev->opaque; +if (v->shadow_vqs_enabled ||vhost_vdpa_one_time_request (dev)) {return 0 ; }
Signature · 1 line
2.27.0
PATCH v6 14/15 vdpa: Expose VHOST_F_LOG_ALL on SVQ
In reply to Eugenio PérezSVQ is able to log the dirty bits by itself, so let's use it to not block migration.
Also, ignore set and clear of VHOST_F_LOG_ALL on set_features if SVQ is enabled. Even if the device supports it, the reports would be nonsense because SVQ memory is in the qemu region.
The log region is still allocated. Future changes might skip that, but this series is already long enough.
--- include/hw/virtio/vhost-vdpa.h | 1 + hw/virtio/vhost-vdpa.c | 39 ++++++++++++++++++++++++++++++---- 2 files changed, 36 insertions(+), 4 deletions(-)
include/hw/virtio/vhost-vdpa.h +1 -0
@@ -30,6 +30,7 @@ typedef struct vhost_vdpa {bool iotlb_batch_begin_sent;MemoryListener listener;struct vhost_vdpa_iova_range iova_range; +uint64_t acked_features;bool shadow_vqs_enabled;/* IOVA mapping used by the Shadow Virtqueue */ VhostIOVATree *iova_tree;
hw/virtio/vhost-vdpa.c +35 -4
@@ -373,6 +373,16 @@ static bool vhost_vdpa_one_time_request(struct vhost_dev *dev)return v->index !=0 ; } +static int vhost_vdpa_get_dev_features (struct vhost_dev *dev, +uint64_t *features) +{ +int ret; + + ret =vhost_vdpa_call (dev,VHOST_GET_FEATURES , features); +trace_vhost_vdpa_get_features (dev, *features); +return ret; +} +static int vhost_vdpa_init_svq (struct vhost_dev *hdev,struct vhost_vdpa *v,Error **errp) {
@@ -385,7 +395,7 @@ static int vhost_vdpa_init_svq(struct vhost_dev *hdev, struct vhost_vdpa *v,return 0 ; } - r = hdev->vhost_ops->vhost_get_features (hdev, &dev_features); + r =vhost_vdpa_get_dev_features (hdev, &dev_features);if (r !=0 ) {error_setg_errno (errp, -r,"Can't get vdpa device features" );return r;
@@ -610,12 +620,29 @@ static int vhost_vdpa_set_mem_table(struct vhost_dev *dev,static int vhost_vdpa_set_features (struct vhost_dev *dev,uint64_t features) { +struct vhost_vdpa *v = dev->opaque;int ret;if (vhost_vdpa_one_time_request (dev)) {return 0 ; } +if (v->shadow_vqs_enabled) { +if ((v->acked_features ^ features) ==BIT_ULL (VHOST_F_LOG_ALL )) { +/* +* QEMU is just trying to enable or disable logging. SVQ handles +* this sepparately, so no need to forward this. +*/ + v->acked_features = features; +return 0 ; + } + + v->acked_features = features; + +/* We must not ack _F_LOG if SVQ is enabled */ + features &= ~BIT_ULL (VHOST_F_LOG_ALL ); + } +trace_vhost_vdpa_set_features (dev, features); ret =vhost_vdpa_call (dev,VHOST_SET_FEATURES , &features);if (ret) {
@@ -1200,10 +1227,14 @@ static int vhost_vdpa_set_vring_call(struct vhost_dev *dev,static int vhost_vdpa_get_features (struct vhost_dev *dev,uint64_t *features) { -int ret; +struct vhost_vdpa *v = dev->opaque; +int ret =vhost_vdpa_get_dev_features (dev, features); + +if (ret ==0 && v->shadow_vqs_enabled) { +/* Add SVQ logging capabilities */ + *features |=BIT_ULL (VHOST_F_LOG_ALL ); + } - ret =vhost_vdpa_call (dev,VHOST_GET_FEATURES , features); -trace_vhost_vdpa_get_features (dev, *features);return ret; }
Signature · 1 line
2.27.0
PATCH v6 15/15 vdpa: Add x-svq to NetdevVhostVDPAOptions
In reply to Eugenio PérezFinally offering the possibility to enable SVQ from the command line.
--- qapi/net.json | 8 +++++++- net/vhost-vdpa.c | 48 ++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 47 insertions(+), 9 deletions(-)
qapi/net.json +7 -1
@@ -445,12 +445,18 @@ # @queues: number of queues to be created for multiqueue vhost-vdpa # (default: 1) # +# @x-svq: Start device with (experimental) shadow virtqueue. (Since 7.1) +# +# Features: +# @unstable: Member @x-svq is experimental. +# # Since: 5.1 ## { 'struct': 'NetdevVhostVDPAOptions', 'data': { '*vhostdev': 'str', - '*queues': 'int' } } + '*queues': 'int', + '*x-svq': {'type': 'bool', 'features' : [ 'unstable'] } } } ## # @NetClientDriver:
net/vhost-vdpa.c +40 -8
101 lines not on this page · raw message
Signature · 1 line
2.27.0
Re: [PATCH v6 15/15] vdpa: Add x-svq to NetdevVhostVDPAOptions
Quoted 144 lines · Eugenio Pérez
Finally offering the possibility to enable SVQ from the command line.
Signed-off-by Eugenio Pérez <[email protected]>--- qapi/net.json | 8 +++++++- net/vhost-vdpa.c | 48 ++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 47 insertions(+), 9 deletions(-)qapi/net.json +7
-1@@ -445,12 +445,18 @@ # @queues: number of queues to be created for multiqueue vhost-vdpa # (default: 1) # +# @x-svq: Start device with (experimental) shadow virtqueue. (Since 7.1) +# +# Features: +# @unstable: Member @x-svq is experimental. +# # Since: 5.1 ## { 'struct': 'NetdevVhostVDPAOptions', 'data': { '*vhostdev': 'str', - '*queues': 'int' } } + '*queues': 'int', + '*x-svq': {'type': 'bool', 'features' : [ 'unstable'] } } } ## # @NetClientDriver:net/vhost-vdpa.c +40
-9@@ -127,7 +127,11 @@ err_init:static void vhost_vdpa_cleanup (NetClientState *nc) {VhostVDPAState *s =DO_UPCAST (VhostVDPAState, nc, nc); +struct vhost_dev *dev = s->vhost_vdpa.dev; +if (dev && dev->vq_index + dev->nvqs == dev->vq_index_end) { +g_clear_pointer (&s->vhost_vdpa.iova_tree, vhost_iova_tree_delete); + }if (s->vhost_net) {vhost_net_cleanup (s->vhost_net);g_free (s->vhost_net);@@ -187,13 +191,23 @@ static NetClientInfo net_vhost_vdpa_info = { .check_peer_type = vhost_vdpa_check_peer_type, }; +static int vhost_vdpa_get_iova_range (int fd, +struct vhost_vdpa_iova_range *iova_range) +{ +int ret =ioctl (fd,VHOST_VDPA_GET_IOVA_RANGE , iova_range); + +return ret <0 ? -errno :0 ; +} +static NetClientState *net_vhost_vdpa_init (NetClientState *peer, -const char *device, -const char *name, -int vdpa_device_fd, -int queue_pair_index, -int nvqs, -bool is_datapath) +const char *device, +const char *name, +int vdpa_device_fd, +int queue_pair_index, +int nvqs, +bool is_datapath, +bool svq, +VhostIOVATree *iova_tree) {NetClientState *nc =NULL ;VhostVDPAState *s;@@ -211,6 +225,8 @@ static NetClientState *net_vhost_vdpa_init(NetClientState *peer, s->vhost_vdpa.device_fd = vdpa_device_fd; s->vhost_vdpa.index = queue_pair_index; + s->vhost_vdpa.shadow_vqs_enabled = svq; + s->vhost_vdpa.iova_tree = iova_tree; ret =vhost_vdpa_add (nc, (void *)&s->vhost_vdpa, queue_pair_index, nvqs);if (ret) {qemu_del_net_client (nc);@@ -266,6 +282,7 @@ int net_init_vhost_vdpa(const Netdev *netdev, const char *name, g_autofree NetClientState **ncs = NULL;NetClientState *nc;int queue_pairs, i, has_cvq =0 ; +g_autoptr (VhostIOVATree) iova_tree =NULL ;assert (netdev->type ==NET_CLIENT_DRIVER_VHOST_VDPA ); opts = &netdev->u.vhost_vdpa;@@ -285,29 +302,44 @@ int net_init_vhost_vdpa(const Netdev *netdev, const char *name,qemu_close (vdpa_device_fd);return queue_pairs; } +if (opts->x_svq) { +struct vhost_vdpa_iova_range iova_range; + +if (has_cvq) { +error_setg (errp,"vdpa svq does not work with cvq" ); + goto err_svq; + } +vhost_vdpa_get_iova_range (vdpa_device_fd, &iova_range); + iova_tree =vhost_iova_tree_new (iova_range.first, iova_range.last); + } ncs =g_malloc0 (sizeof (*ncs) * queue_pairs);for (i =0 ; i < queue_pairs; i++) { ncs[i] =net_vhost_vdpa_init (peer,TYPE_VHOST_VDPA , name, - vdpa_device_fd, i,2 , true); + vdpa_device_fd, i,2 , true, opts->x_svq, + iova_tree);if (!ncs[i]) goto err; }if (has_cvq) { nc =net_vhost_vdpa_init (peer,TYPE_VHOST_VDPA , name, - vdpa_device_fd, i,1 , false); + vdpa_device_fd, i,1 , false, opts->x_svq, + iova_tree);if (!nc) goto err; } + iova_tree =NULL ;return 0 ; err:if (i) {qemu_del_net_client (ncs[0 ]); } + +err_svq:qemu_close (vdpa_device_fd);return -1 ; --
Quoted 3 lines
2.27.0
Sorry, I added this last one by mistake. Do I need to resend the series to delete it?
Thanks!