1 | The following changes since commit 97c81ef4b8e203d9620fd46e7eb77004563e3675: | 1 | The following changes since commit 352998df1c53b366413690d95b35f76d0721ebed: |
---|---|---|---|
2 | 2 | ||
3 | Merge tag 'pull-9p-20230706' of https://github.com/cschoenebeck/qemu into staging (2023-07-06 18:19:42 +0100) | 3 | Merge tag 'i2c-20220314' of https://github.com/philmd/qemu into staging (2022-03-14 14:39:33 +0000) |
4 | 4 | ||
5 | are available in the git repository at: | 5 | are available in the git repository at: |
6 | 6 | ||
7 | https://github.com/jasowang/qemu.git tags/net-pull-request | 7 | https://github.com/jasowang/qemu.git tags/net-pull-request |
8 | 8 | ||
9 | for you to fetch changes up to da9f7f7769e8e65f6423095e978f9a375e33515c: | 9 | for you to fetch changes up to 12a195fa343aae2ead1301ce04727bd0ae25eb15: |
10 | 10 | ||
11 | igb: Remove obsolete workaround for Windows (2023-07-07 16:35:12 +0800) | 11 | vdpa: Expose VHOST_F_LOG_ALL on SVQ (2022-03-15 13:57:44 +0800) |
12 | 12 | ||
13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
14 | 14 | ||
15 | Changes since V2: | ||
16 | - fix 32bit build errros | ||
17 | |||
15 | ---------------------------------------------------------------- | 18 | ---------------------------------------------------------------- |
16 | Akihiko Odaki (2): | 19 | Eugenio Pérez (14): |
17 | e1000e: Add ICR clearing by corresponding IMS bit | 20 | vhost: Add VhostShadowVirtqueue |
18 | igb: Remove obsolete workaround for Windows | 21 | vhost: Add Shadow VirtQueue kick forwarding capabilities |
22 | vhost: Add Shadow VirtQueue call forwarding capabilities | ||
23 | vhost: Add vhost_svq_valid_features to shadow vq | ||
24 | virtio: Add vhost_svq_get_vring_addr | ||
25 | vdpa: adapt vhost_ops callbacks to svq | ||
26 | vhost: Shadow virtqueue buffers forwarding | ||
27 | util: Add iova_tree_alloc_map | ||
28 | util: add iova_tree_find_iova | ||
29 | vhost: Add VhostIOVATree | ||
30 | vdpa: Add custom IOTLB translations to SVQ | ||
31 | vdpa: Adapt vhost_vdpa_get_vring_base to SVQ | ||
32 | vdpa: Never set log_base addr if SVQ is enabled | ||
33 | vdpa: Expose VHOST_F_LOG_ALL on SVQ | ||
19 | 34 | ||
20 | Bin Meng (9): | 35 | Jason Wang (1): |
21 | hw/net: e1000: Remove the logic of padding short frames in the receive path | 36 | virtio-net: fix map leaking on error during receive |
22 | hw/net: vmxnet3: Remove the logic of padding short frames in the receive path | ||
23 | hw/net: i82596: Remove the logic of padding short frames in the receive path | ||
24 | hw/net: ne2000: Remove the logic of padding short frames in the receive path | ||
25 | hw/net: pcnet: Remove the logic of padding short frames in the receive path | ||
26 | hw/net: rtl8139: Remove the logic of padding short frames in the receive path | ||
27 | hw/net: sungem: Remove the logic of padding short frames in the receive path | ||
28 | hw/net: sunhme: Remove the logic of padding short frames in the receive path | ||
29 | hw/net: ftgmac100: Drop the small packet check in the receive path | ||
30 | 37 | ||
31 | Laurent Vivier (4): | 38 | hw/net/virtio-net.c | 1 + |
32 | virtio-net: correctly report maximum tx_queue_size value | 39 | hw/virtio/meson.build | 2 +- |
33 | net: socket: prepare to cleanup net_init_socket() | 40 | hw/virtio/vhost-iova-tree.c | 110 +++++++ |
34 | net: socket: move fd type checking to its own function | 41 | hw/virtio/vhost-iova-tree.h | 27 ++ |
35 | net: socket: remove net_init_socket() | 42 | hw/virtio/vhost-shadow-virtqueue.c | 636 +++++++++++++++++++++++++++++++++++++ |
43 | hw/virtio/vhost-shadow-virtqueue.h | 87 +++++ | ||
44 | hw/virtio/vhost-vdpa.c | 522 +++++++++++++++++++++++++++++- | ||
45 | include/hw/virtio/vhost-vdpa.h | 8 + | ||
46 | include/qemu/iova-tree.h | 38 ++- | ||
47 | util/iova-tree.c | 170 ++++++++++ | ||
48 | 10 files changed, 1584 insertions(+), 17 deletions(-) | ||
49 | create mode 100644 hw/virtio/vhost-iova-tree.c | ||
50 | create mode 100644 hw/virtio/vhost-iova-tree.h | ||
51 | create mode 100644 hw/virtio/vhost-shadow-virtqueue.c | ||
52 | create mode 100644 hw/virtio/vhost-shadow-virtqueue.h | ||
36 | 53 | ||
37 | hw/net/e1000.c | 11 +---------- | 54 | |
38 | hw/net/e1000e_core.c | 38 +++++++++++++++++++++++++++++++------ | 55 | |
39 | hw/net/ftgmac100.c | 8 -------- | ||
40 | hw/net/i82596.c | 18 ------------------ | ||
41 | hw/net/igb_core.c | 7 +------ | ||
42 | hw/net/ne2000.c | 12 ------------ | ||
43 | hw/net/pcnet.c | 9 --------- | ||
44 | hw/net/rtl8139.c | 12 ------------ | ||
45 | hw/net/sungem.c | 14 -------------- | ||
46 | hw/net/sunhme.c | 11 ----------- | ||
47 | hw/net/trace-events | 1 + | ||
48 | hw/net/virtio-net.c | 4 ++-- | ||
49 | hw/net/vmxnet3.c | 10 ---------- | ||
50 | net/socket.c | 53 +++++++++++++++++++++++++++------------------------- | ||
51 | 14 files changed, 65 insertions(+), 143 deletions(-) | diff view generated by jsdifflib |
1 | From: Laurent Vivier <lvivier@redhat.com> | 1 | Commit bedd7e93d0196 ("virtio-net: fix use after unmap/free for sg") |
---|---|---|---|
2 | tries to fix the use after free of the sg by caching the virtqueue | ||
3 | elements in an array and unmap them at once after receiving the | ||
4 | packets, But it forgot to unmap the cached elements on error which | ||
5 | will lead to leaking of mapping and other unexpected results. | ||
2 | 6 | ||
3 | Maximum value for tx_queue_size depends on the backend type. | 7 | Fixing this by detaching the cached elements on error. This addresses |
4 | 1024 for vDPA/vhost-user, 256 for all the others. | 8 | CVE-2022-26353. |
5 | 9 | ||
6 | The value is returned by virtio_net_max_tx_queue_size() to set the | 10 | Reported-by: Victor Tom <vv474172261@gmail.com> |
7 | parameter: | ||
8 | |||
9 | n->net_conf.tx_queue_size = MIN(virtio_net_max_tx_queue_size(n), | ||
10 | n->net_conf.tx_queue_size); | ||
11 | |||
12 | But the parameter checking uses VIRTQUEUE_MAX_SIZE (1024). | ||
13 | |||
14 | So the parameter is silently ignored and ethtool reports a different | ||
15 | value than the one provided by the user. | ||
16 | |||
17 | ... -netdev tap,... -device virtio-net,tx_queue_size=1024 | ||
18 | |||
19 | # ethtool -g enp0s2 | ||
20 | Ring parameters for enp0s2: | ||
21 | Pre-set maximums: | ||
22 | RX: 256 | ||
23 | RX Mini: n/a | ||
24 | RX Jumbo: n/a | ||
25 | TX: 256 | ||
26 | Current hardware settings: | ||
27 | RX: 256 | ||
28 | RX Mini: n/a | ||
29 | RX Jumbo: n/a | ||
30 | TX: 256 | ||
31 | |||
32 | ... -netdev vhost-user,... -device virtio-net,tx_queue_size=2048 | ||
33 | |||
34 | Invalid tx_queue_size (= 2048), must be a power of 2 between 256 and 1024 | ||
35 | |||
36 | With this patch the correct maximum value is checked and displayed. | ||
37 | |||
38 | For vDPA/vhost-user: | ||
39 | |||
40 | Invalid tx_queue_size (= 2048), must be a power of 2 between 256 and 1024 | ||
41 | |||
42 | For all the others: | ||
43 | |||
44 | Invalid tx_queue_size (= 512), must be a power of 2 between 256 and 256 | ||
45 | |||
46 | Fixes: 2eef278b9e63 ("virtio-net: fix tx queue size for !vhost-user") | ||
47 | Cc: mst@redhat.com | ||
48 | Cc: qemu-stable@nongnu.org | 11 | Cc: qemu-stable@nongnu.org |
49 | Signed-off-by: Laurent Vivier <lvivier@redhat.com> | 12 | Fixes: CVE-2022-26353 |
13 | Fixes: bedd7e93d0196 ("virtio-net: fix use after unmap/free for sg") | ||
14 | Reviewed-by: Michael S. Tsirkin <mst@redhat.com> | ||
50 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 15 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
51 | --- | 16 | --- |
52 | hw/net/virtio-net.c | 4 ++-- | 17 | hw/net/virtio-net.c | 1 + |
53 | 1 file changed, 2 insertions(+), 2 deletions(-) | 18 | 1 file changed, 1 insertion(+) |
54 | 19 | ||
55 | diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c | 20 | diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c |
56 | index XXXXXXX..XXXXXXX 100644 | 21 | index XXXXXXX..XXXXXXX 100644 |
57 | --- a/hw/net/virtio-net.c | 22 | --- a/hw/net/virtio-net.c |
58 | +++ b/hw/net/virtio-net.c | 23 | +++ b/hw/net/virtio-net.c |
59 | @@ -XXX,XX +XXX,XX @@ static void virtio_net_device_realize(DeviceState *dev, Error **errp) | 24 | @@ -XXX,XX +XXX,XX @@ static ssize_t virtio_net_receive_rcu(NetClientState *nc, const uint8_t *buf, |
25 | |||
26 | err: | ||
27 | for (j = 0; j < i; j++) { | ||
28 | + virtqueue_detach_element(q->rx_vq, elems[j], lens[j]); | ||
29 | g_free(elems[j]); | ||
60 | } | 30 | } |
61 | 31 | ||
62 | if (n->net_conf.tx_queue_size < VIRTIO_NET_TX_QUEUE_MIN_SIZE || | ||
63 | - n->net_conf.tx_queue_size > VIRTQUEUE_MAX_SIZE || | ||
64 | + n->net_conf.tx_queue_size > virtio_net_max_tx_queue_size(n) || | ||
65 | !is_power_of_2(n->net_conf.tx_queue_size)) { | ||
66 | error_setg(errp, "Invalid tx_queue_size (= %" PRIu16 "), " | ||
67 | "must be a power of 2 between %d and %d", | ||
68 | n->net_conf.tx_queue_size, VIRTIO_NET_TX_QUEUE_MIN_SIZE, | ||
69 | - VIRTQUEUE_MAX_SIZE); | ||
70 | + virtio_net_max_tx_queue_size(n)); | ||
71 | virtio_cleanup(vdev); | ||
72 | return; | ||
73 | } | ||
74 | -- | 32 | -- |
75 | 2.7.4 | 33 | 2.7.4 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | Vhost shadow virtqueue (SVQ) is an intermediate jump for virtqueue |
4 | QEMU networking codes, the small packet check logic in the receive | 4 | notifications and buffers, allowing qemu to track them. While qemu is |
5 | path is no longer needed. | 5 | forwarding the buffers and virtqueue changes, it is able to commit the |
6 | memory it's being dirtied, the same way regular qemu's VirtIO devices | ||
7 | do. | ||
6 | 8 | ||
7 | Suggested-by: Cédric Le Goater <clg@kaod.org> | 9 | This commit only exposes basic SVQ allocation and free. Next patches of |
8 | Reviewed-by: Cédric Le Goater <clg@kaod.org> | 10 | the series add functionality like notifications and buffers forwarding. |
9 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | 11 | |
12 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
13 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
10 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 14 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
11 | --- | 15 | --- |
12 | hw/net/ftgmac100.c | 8 -------- | 16 | hw/virtio/meson.build | 2 +- |
13 | 1 file changed, 8 deletions(-) | 17 | hw/virtio/vhost-shadow-virtqueue.c | 62 ++++++++++++++++++++++++++++++++++++++ |
18 | hw/virtio/vhost-shadow-virtqueue.h | 28 +++++++++++++++++ | ||
19 | 3 files changed, 91 insertions(+), 1 deletion(-) | ||
20 | create mode 100644 hw/virtio/vhost-shadow-virtqueue.c | ||
21 | create mode 100644 hw/virtio/vhost-shadow-virtqueue.h | ||
14 | 22 | ||
15 | diff --git a/hw/net/ftgmac100.c b/hw/net/ftgmac100.c | 23 | diff --git a/hw/virtio/meson.build b/hw/virtio/meson.build |
16 | index XXXXXXX..XXXXXXX 100644 | 24 | index XXXXXXX..XXXXXXX 100644 |
17 | --- a/hw/net/ftgmac100.c | 25 | --- a/hw/virtio/meson.build |
18 | +++ b/hw/net/ftgmac100.c | 26 | +++ b/hw/virtio/meson.build |
19 | @@ -XXX,XX +XXX,XX @@ static ssize_t ftgmac100_receive(NetClientState *nc, const uint8_t *buf, | 27 | @@ -XXX,XX +XXX,XX @@ softmmu_ss.add(when: 'CONFIG_ALL', if_true: files('vhost-stub.c')) |
20 | return -1; | 28 | |
21 | } | 29 | virtio_ss = ss.source_set() |
22 | 30 | virtio_ss.add(files('virtio.c')) | |
23 | - /* TODO : Pad to minimum Ethernet frame length */ | 31 | -virtio_ss.add(when: 'CONFIG_VHOST', if_true: files('vhost.c', 'vhost-backend.c')) |
24 | - /* handle small packets. */ | 32 | +virtio_ss.add(when: 'CONFIG_VHOST', if_true: files('vhost.c', 'vhost-backend.c', 'vhost-shadow-virtqueue.c')) |
25 | - if (size < 10) { | 33 | virtio_ss.add(when: 'CONFIG_VHOST_USER', if_true: files('vhost-user.c')) |
26 | - qemu_log_mask(LOG_GUEST_ERROR, "%s: dropped frame of %zd bytes\n", | 34 | virtio_ss.add(when: 'CONFIG_VHOST_VDPA', if_true: files('vhost-vdpa.c')) |
27 | - __func__, size); | 35 | virtio_ss.add(when: 'CONFIG_VIRTIO_BALLOON', if_true: files('virtio-balloon.c')) |
28 | - return size; | 36 | diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c |
29 | - } | 37 | new file mode 100644 |
30 | - | 38 | index XXXXXXX..XXXXXXX |
31 | if (!ftgmac100_filter(s, buf, size)) { | 39 | --- /dev/null |
32 | return size; | 40 | +++ b/hw/virtio/vhost-shadow-virtqueue.c |
33 | } | 41 | @@ -XXX,XX +XXX,XX @@ |
42 | +/* | ||
43 | + * vhost shadow virtqueue | ||
44 | + * | ||
45 | + * SPDX-FileCopyrightText: Red Hat, Inc. 2021 | ||
46 | + * SPDX-FileContributor: Author: Eugenio Pérez <eperezma@redhat.com> | ||
47 | + * | ||
48 | + * SPDX-License-Identifier: GPL-2.0-or-later | ||
49 | + */ | ||
50 | + | ||
51 | +#include "qemu/osdep.h" | ||
52 | +#include "hw/virtio/vhost-shadow-virtqueue.h" | ||
53 | + | ||
54 | +#include "qemu/error-report.h" | ||
55 | + | ||
56 | +/** | ||
57 | + * Creates vhost shadow virtqueue, and instructs the vhost device to use the | ||
58 | + * shadow methods and file descriptors. | ||
59 | + * | ||
60 | + * Returns the new virtqueue or NULL. | ||
61 | + * | ||
62 | + * In case of error, reason is reported through error_report. | ||
63 | + */ | ||
64 | +VhostShadowVirtqueue *vhost_svq_new(void) | ||
65 | +{ | ||
66 | + g_autofree VhostShadowVirtqueue *svq = g_new0(VhostShadowVirtqueue, 1); | ||
67 | + int r; | ||
68 | + | ||
69 | + r = event_notifier_init(&svq->hdev_kick, 0); | ||
70 | + if (r != 0) { | ||
71 | + error_report("Couldn't create kick event notifier: %s (%d)", | ||
72 | + g_strerror(errno), errno); | ||
73 | + goto err_init_hdev_kick; | ||
74 | + } | ||
75 | + | ||
76 | + r = event_notifier_init(&svq->hdev_call, 0); | ||
77 | + if (r != 0) { | ||
78 | + error_report("Couldn't create call event notifier: %s (%d)", | ||
79 | + g_strerror(errno), errno); | ||
80 | + goto err_init_hdev_call; | ||
81 | + } | ||
82 | + | ||
83 | + return g_steal_pointer(&svq); | ||
84 | + | ||
85 | +err_init_hdev_call: | ||
86 | + event_notifier_cleanup(&svq->hdev_kick); | ||
87 | + | ||
88 | +err_init_hdev_kick: | ||
89 | + return NULL; | ||
90 | +} | ||
91 | + | ||
92 | +/** | ||
93 | + * Free the resources of the shadow virtqueue. | ||
94 | + * | ||
95 | + * @pvq: gpointer to SVQ so it can be used by autofree functions. | ||
96 | + */ | ||
97 | +void vhost_svq_free(gpointer pvq) | ||
98 | +{ | ||
99 | + VhostShadowVirtqueue *vq = pvq; | ||
100 | + event_notifier_cleanup(&vq->hdev_kick); | ||
101 | + event_notifier_cleanup(&vq->hdev_call); | ||
102 | + g_free(vq); | ||
103 | +} | ||
104 | diff --git a/hw/virtio/vhost-shadow-virtqueue.h b/hw/virtio/vhost-shadow-virtqueue.h | ||
105 | new file mode 100644 | ||
106 | index XXXXXXX..XXXXXXX | ||
107 | --- /dev/null | ||
108 | +++ b/hw/virtio/vhost-shadow-virtqueue.h | ||
109 | @@ -XXX,XX +XXX,XX @@ | ||
110 | +/* | ||
111 | + * vhost shadow virtqueue | ||
112 | + * | ||
113 | + * SPDX-FileCopyrightText: Red Hat, Inc. 2021 | ||
114 | + * SPDX-FileContributor: Author: Eugenio Pérez <eperezma@redhat.com> | ||
115 | + * | ||
116 | + * SPDX-License-Identifier: GPL-2.0-or-later | ||
117 | + */ | ||
118 | + | ||
119 | +#ifndef VHOST_SHADOW_VIRTQUEUE_H | ||
120 | +#define VHOST_SHADOW_VIRTQUEUE_H | ||
121 | + | ||
122 | +#include "qemu/event_notifier.h" | ||
123 | + | ||
124 | +/* Shadow virtqueue to relay notifications */ | ||
125 | +typedef struct VhostShadowVirtqueue { | ||
126 | + /* Shadow kick notifier, sent to vhost */ | ||
127 | + EventNotifier hdev_kick; | ||
128 | + /* Shadow call notifier, sent to vhost */ | ||
129 | + EventNotifier hdev_call; | ||
130 | +} VhostShadowVirtqueue; | ||
131 | + | ||
132 | +VhostShadowVirtqueue *vhost_svq_new(void); | ||
133 | + | ||
134 | +void vhost_svq_free(gpointer vq); | ||
135 | +G_DEFINE_AUTOPTR_CLEANUP_FUNC(VhostShadowVirtqueue, vhost_svq_free); | ||
136 | + | ||
137 | +#endif | ||
34 | -- | 138 | -- |
35 | 2.7.4 | 139 | 2.7.4 |
36 | 140 | ||
37 | 141 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | At this mode no buffer forwarding will be performed in SVQ mode: Qemu |
4 | QEMU networking codes, remove the same logic in the NIC codes. | 4 | will just forward the guest's kicks to the device. |
5 | 5 | ||
6 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | 6 | Host memory notifiers regions are left out for simplicity, and they will |
7 | not be addressed in this series. | ||
8 | |||
9 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
10 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 11 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
8 | --- | 12 | --- |
9 | hw/net/sungem.c | 14 -------------- | 13 | hw/virtio/vhost-shadow-virtqueue.c | 55 ++++++++++++++ |
10 | 1 file changed, 14 deletions(-) | 14 | hw/virtio/vhost-shadow-virtqueue.h | 14 ++++ |
11 | 15 | hw/virtio/vhost-vdpa.c | 144 ++++++++++++++++++++++++++++++++++++- | |
12 | diff --git a/hw/net/sungem.c b/hw/net/sungem.c | 16 | include/hw/virtio/vhost-vdpa.h | 4 ++ |
17 | 4 files changed, 215 insertions(+), 2 deletions(-) | ||
18 | |||
19 | diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c | ||
13 | index XXXXXXX..XXXXXXX 100644 | 20 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/hw/net/sungem.c | 21 | --- a/hw/virtio/vhost-shadow-virtqueue.c |
15 | +++ b/hw/net/sungem.c | 22 | +++ b/hw/virtio/vhost-shadow-virtqueue.c |
16 | @@ -XXX,XX +XXX,XX @@ static ssize_t sungem_receive(NetClientState *nc, const uint8_t *buf, | 23 | @@ -XXX,XX +XXX,XX @@ |
17 | PCIDevice *d = PCI_DEVICE(s); | 24 | #include "hw/virtio/vhost-shadow-virtqueue.h" |
18 | uint32_t mac_crc, done, kick, max_fsize; | 25 | |
19 | uint32_t fcs_size, ints, rxdma_cfg, rxmac_cfg, csum, coff; | 26 | #include "qemu/error-report.h" |
20 | - uint8_t smallbuf[60]; | 27 | +#include "qemu/main-loop.h" |
21 | struct gem_rxd desc; | 28 | +#include "linux-headers/linux/vhost.h" |
22 | uint64_t dbase, baddr; | 29 | + |
23 | unsigned int rx_cond; | 30 | +/** |
24 | @@ -XXX,XX +XXX,XX @@ static ssize_t sungem_receive(NetClientState *nc, const uint8_t *buf, | 31 | + * Forward guest notifications. |
25 | return size; | 32 | + * |
33 | + * @n: guest kick event notifier, the one that guest set to notify svq. | ||
34 | + */ | ||
35 | +static void vhost_handle_guest_kick(EventNotifier *n) | ||
36 | +{ | ||
37 | + VhostShadowVirtqueue *svq = container_of(n, VhostShadowVirtqueue, svq_kick); | ||
38 | + event_notifier_test_and_clear(n); | ||
39 | + event_notifier_set(&svq->hdev_kick); | ||
40 | +} | ||
41 | + | ||
42 | +/** | ||
43 | + * Set a new file descriptor for the guest to kick the SVQ and notify for avail | ||
44 | + * | ||
45 | + * @svq: The svq | ||
46 | + * @svq_kick_fd: The svq kick fd | ||
47 | + * | ||
48 | + * Note that the SVQ will never close the old file descriptor. | ||
49 | + */ | ||
50 | +void vhost_svq_set_svq_kick_fd(VhostShadowVirtqueue *svq, int svq_kick_fd) | ||
51 | +{ | ||
52 | + EventNotifier *svq_kick = &svq->svq_kick; | ||
53 | + bool poll_stop = VHOST_FILE_UNBIND != event_notifier_get_fd(svq_kick); | ||
54 | + bool poll_start = svq_kick_fd != VHOST_FILE_UNBIND; | ||
55 | + | ||
56 | + if (poll_stop) { | ||
57 | + event_notifier_set_handler(svq_kick, NULL); | ||
58 | + } | ||
59 | + | ||
60 | + /* | ||
61 | + * event_notifier_set_handler already checks for guest's notifications if | ||
62 | + * they arrive at the new file descriptor in the switch, so there is no | ||
63 | + * need to explicitly check for them. | ||
64 | + */ | ||
65 | + if (poll_start) { | ||
66 | + event_notifier_init_fd(svq_kick, svq_kick_fd); | ||
67 | + event_notifier_set(svq_kick); | ||
68 | + event_notifier_set_handler(svq_kick, vhost_handle_guest_kick); | ||
69 | + } | ||
70 | +} | ||
71 | + | ||
72 | +/** | ||
73 | + * Stop the shadow virtqueue operation. | ||
74 | + * @svq: Shadow Virtqueue | ||
75 | + */ | ||
76 | +void vhost_svq_stop(VhostShadowVirtqueue *svq) | ||
77 | +{ | ||
78 | + event_notifier_set_handler(&svq->svq_kick, NULL); | ||
79 | +} | ||
80 | |||
81 | /** | ||
82 | * Creates vhost shadow virtqueue, and instructs the vhost device to use the | ||
83 | @@ -XXX,XX +XXX,XX @@ VhostShadowVirtqueue *vhost_svq_new(void) | ||
84 | goto err_init_hdev_call; | ||
26 | } | 85 | } |
27 | 86 | ||
28 | - /* We don't drop too small frames since we get them in qemu, we pad | 87 | + event_notifier_init_fd(&svq->svq_kick, VHOST_FILE_UNBIND); |
29 | - * them instead. We should probably use the min frame size register | 88 | return g_steal_pointer(&svq); |
30 | - * but I don't want to use a variable size staging buffer and I | 89 | |
31 | - * know both MacOS and Linux use the default 64 anyway. We use 60 | 90 | err_init_hdev_call: |
32 | - * here to account for the non-existent FCS. | 91 | @@ -XXX,XX +XXX,XX @@ err_init_hdev_kick: |
33 | - */ | 92 | void vhost_svq_free(gpointer pvq) |
34 | - if (size < 60) { | 93 | { |
35 | - memcpy(smallbuf, buf, size); | 94 | VhostShadowVirtqueue *vq = pvq; |
36 | - memset(&smallbuf[size], 0, 60 - size); | 95 | + vhost_svq_stop(vq); |
37 | - buf = smallbuf; | 96 | event_notifier_cleanup(&vq->hdev_kick); |
38 | - size = 60; | 97 | event_notifier_cleanup(&vq->hdev_call); |
39 | - } | 98 | g_free(vq); |
40 | - | 99 | diff --git a/hw/virtio/vhost-shadow-virtqueue.h b/hw/virtio/vhost-shadow-virtqueue.h |
41 | /* Get MAC crc */ | 100 | index XXXXXXX..XXXXXXX 100644 |
42 | mac_crc = net_crc32_le(buf, ETH_ALEN); | 101 | --- a/hw/virtio/vhost-shadow-virtqueue.h |
43 | 102 | +++ b/hw/virtio/vhost-shadow-virtqueue.h | |
103 | @@ -XXX,XX +XXX,XX @@ typedef struct VhostShadowVirtqueue { | ||
104 | EventNotifier hdev_kick; | ||
105 | /* Shadow call notifier, sent to vhost */ | ||
106 | EventNotifier hdev_call; | ||
107 | + | ||
108 | + /* | ||
109 | + * Borrowed virtqueue's guest to host notifier. To borrow it in this event | ||
110 | + * notifier allows to recover the VhostShadowVirtqueue from the event loop | ||
111 | + * easily. If we use the VirtQueue's one, we don't have an easy way to | ||
112 | + * retrieve VhostShadowVirtqueue. | ||
113 | + * | ||
114 | + * So shadow virtqueue must not clean it, or we would lose VirtQueue one. | ||
115 | + */ | ||
116 | + EventNotifier svq_kick; | ||
117 | } VhostShadowVirtqueue; | ||
118 | |||
119 | +void vhost_svq_set_svq_kick_fd(VhostShadowVirtqueue *svq, int svq_kick_fd); | ||
120 | + | ||
121 | +void vhost_svq_stop(VhostShadowVirtqueue *svq); | ||
122 | + | ||
123 | VhostShadowVirtqueue *vhost_svq_new(void); | ||
124 | |||
125 | void vhost_svq_free(gpointer vq); | ||
126 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c | ||
127 | index XXXXXXX..XXXXXXX 100644 | ||
128 | --- a/hw/virtio/vhost-vdpa.c | ||
129 | +++ b/hw/virtio/vhost-vdpa.c | ||
130 | @@ -XXX,XX +XXX,XX @@ | ||
131 | #include "hw/virtio/vhost.h" | ||
132 | #include "hw/virtio/vhost-backend.h" | ||
133 | #include "hw/virtio/virtio-net.h" | ||
134 | +#include "hw/virtio/vhost-shadow-virtqueue.h" | ||
135 | #include "hw/virtio/vhost-vdpa.h" | ||
136 | #include "exec/address-spaces.h" | ||
137 | #include "qemu/main-loop.h" | ||
138 | #include "cpu.h" | ||
139 | #include "trace.h" | ||
140 | #include "qemu-common.h" | ||
141 | +#include "qapi/error.h" | ||
142 | |||
143 | /* | ||
144 | * Return one past the end of the end of section. Be careful with uint64_t | ||
145 | @@ -XXX,XX +XXX,XX @@ static bool vhost_vdpa_one_time_request(struct vhost_dev *dev) | ||
146 | return v->index != 0; | ||
147 | } | ||
148 | |||
149 | +static int vhost_vdpa_init_svq(struct vhost_dev *hdev, struct vhost_vdpa *v, | ||
150 | + Error **errp) | ||
151 | +{ | ||
152 | + g_autoptr(GPtrArray) shadow_vqs = NULL; | ||
153 | + | ||
154 | + if (!v->shadow_vqs_enabled) { | ||
155 | + return 0; | ||
156 | + } | ||
157 | + | ||
158 | + shadow_vqs = g_ptr_array_new_full(hdev->nvqs, vhost_svq_free); | ||
159 | + for (unsigned n = 0; n < hdev->nvqs; ++n) { | ||
160 | + g_autoptr(VhostShadowVirtqueue) svq = vhost_svq_new(); | ||
161 | + | ||
162 | + if (unlikely(!svq)) { | ||
163 | + error_setg(errp, "Cannot create svq %u", n); | ||
164 | + return -1; | ||
165 | + } | ||
166 | + g_ptr_array_add(shadow_vqs, g_steal_pointer(&svq)); | ||
167 | + } | ||
168 | + | ||
169 | + v->shadow_vqs = g_steal_pointer(&shadow_vqs); | ||
170 | + return 0; | ||
171 | +} | ||
172 | + | ||
173 | static int vhost_vdpa_init(struct vhost_dev *dev, void *opaque, Error **errp) | ||
174 | { | ||
175 | struct vhost_vdpa *v; | ||
176 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_init(struct vhost_dev *dev, void *opaque, Error **errp) | ||
177 | dev->opaque = opaque ; | ||
178 | v->listener = vhost_vdpa_memory_listener; | ||
179 | v->msg_type = VHOST_IOTLB_MSG_V2; | ||
180 | + ret = vhost_vdpa_init_svq(dev, v, errp); | ||
181 | + if (ret) { | ||
182 | + goto err; | ||
183 | + } | ||
184 | |||
185 | vhost_vdpa_get_iova_range(v); | ||
186 | |||
187 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_init(struct vhost_dev *dev, void *opaque, Error **errp) | ||
188 | VIRTIO_CONFIG_S_DRIVER); | ||
189 | |||
190 | return 0; | ||
191 | + | ||
192 | +err: | ||
193 | + ram_block_discard_disable(false); | ||
194 | + return ret; | ||
195 | } | ||
196 | |||
197 | static void vhost_vdpa_host_notifier_uninit(struct vhost_dev *dev, | ||
198 | @@ -XXX,XX +XXX,XX @@ static void vhost_vdpa_host_notifiers_uninit(struct vhost_dev *dev, int n) | ||
199 | |||
200 | static void vhost_vdpa_host_notifiers_init(struct vhost_dev *dev) | ||
201 | { | ||
202 | + struct vhost_vdpa *v = dev->opaque; | ||
203 | int i; | ||
204 | |||
205 | + if (v->shadow_vqs_enabled) { | ||
206 | + /* FIXME SVQ is not compatible with host notifiers mr */ | ||
207 | + return; | ||
208 | + } | ||
209 | + | ||
210 | for (i = dev->vq_index; i < dev->vq_index + dev->nvqs; i++) { | ||
211 | if (vhost_vdpa_host_notifier_init(dev, i)) { | ||
212 | goto err; | ||
213 | @@ -XXX,XX +XXX,XX @@ err: | ||
214 | return; | ||
215 | } | ||
216 | |||
217 | +static void vhost_vdpa_svq_cleanup(struct vhost_dev *dev) | ||
218 | +{ | ||
219 | + struct vhost_vdpa *v = dev->opaque; | ||
220 | + size_t idx; | ||
221 | + | ||
222 | + if (!v->shadow_vqs) { | ||
223 | + return; | ||
224 | + } | ||
225 | + | ||
226 | + for (idx = 0; idx < v->shadow_vqs->len; ++idx) { | ||
227 | + vhost_svq_stop(g_ptr_array_index(v->shadow_vqs, idx)); | ||
228 | + } | ||
229 | + g_ptr_array_free(v->shadow_vqs, true); | ||
230 | +} | ||
231 | + | ||
232 | static int vhost_vdpa_cleanup(struct vhost_dev *dev) | ||
233 | { | ||
234 | struct vhost_vdpa *v; | ||
235 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_cleanup(struct vhost_dev *dev) | ||
236 | trace_vhost_vdpa_cleanup(dev, v); | ||
237 | vhost_vdpa_host_notifiers_uninit(dev, dev->nvqs); | ||
238 | memory_listener_unregister(&v->listener); | ||
239 | + vhost_vdpa_svq_cleanup(dev); | ||
240 | |||
241 | dev->opaque = NULL; | ||
242 | ram_block_discard_disable(false); | ||
243 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_get_device_id(struct vhost_dev *dev, | ||
244 | return ret; | ||
245 | } | ||
246 | |||
247 | +static void vhost_vdpa_reset_svq(struct vhost_vdpa *v) | ||
248 | +{ | ||
249 | + if (!v->shadow_vqs_enabled) { | ||
250 | + return; | ||
251 | + } | ||
252 | + | ||
253 | + for (unsigned i = 0; i < v->shadow_vqs->len; ++i) { | ||
254 | + VhostShadowVirtqueue *svq = g_ptr_array_index(v->shadow_vqs, i); | ||
255 | + vhost_svq_stop(svq); | ||
256 | + } | ||
257 | +} | ||
258 | + | ||
259 | static int vhost_vdpa_reset_device(struct vhost_dev *dev) | ||
260 | { | ||
261 | + struct vhost_vdpa *v = dev->opaque; | ||
262 | int ret; | ||
263 | uint8_t status = 0; | ||
264 | |||
265 | + vhost_vdpa_reset_svq(v); | ||
266 | + | ||
267 | ret = vhost_vdpa_call(dev, VHOST_VDPA_SET_STATUS, &status); | ||
268 | trace_vhost_vdpa_reset_device(dev, status); | ||
269 | return ret; | ||
270 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_get_config(struct vhost_dev *dev, uint8_t *config, | ||
271 | return ret; | ||
272 | } | ||
273 | |||
274 | +static int vhost_vdpa_set_vring_dev_kick(struct vhost_dev *dev, | ||
275 | + struct vhost_vring_file *file) | ||
276 | +{ | ||
277 | + trace_vhost_vdpa_set_vring_kick(dev, file->index, file->fd); | ||
278 | + return vhost_vdpa_call(dev, VHOST_SET_VRING_KICK, file); | ||
279 | +} | ||
280 | + | ||
281 | +/** | ||
282 | + * Set the shadow virtqueue descriptors to the device | ||
283 | + * | ||
284 | + * @dev: The vhost device model | ||
285 | + * @svq: The shadow virtqueue | ||
286 | + * @idx: The index of the virtqueue in the vhost device | ||
287 | + * @errp: Error | ||
288 | + */ | ||
289 | +static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, | ||
290 | + VhostShadowVirtqueue *svq, unsigned idx, | ||
291 | + Error **errp) | ||
292 | +{ | ||
293 | + struct vhost_vring_file file = { | ||
294 | + .index = dev->vq_index + idx, | ||
295 | + }; | ||
296 | + const EventNotifier *event_notifier = &svq->hdev_kick; | ||
297 | + int r; | ||
298 | + | ||
299 | + file.fd = event_notifier_get_fd(event_notifier); | ||
300 | + r = vhost_vdpa_set_vring_dev_kick(dev, &file); | ||
301 | + if (unlikely(r != 0)) { | ||
302 | + error_setg_errno(errp, -r, "Can't set device kick fd"); | ||
303 | + } | ||
304 | + | ||
305 | + return r == 0; | ||
306 | +} | ||
307 | + | ||
308 | +static bool vhost_vdpa_svqs_start(struct vhost_dev *dev) | ||
309 | +{ | ||
310 | + struct vhost_vdpa *v = dev->opaque; | ||
311 | + Error *err = NULL; | ||
312 | + unsigned i; | ||
313 | + | ||
314 | + if (!v->shadow_vqs) { | ||
315 | + return true; | ||
316 | + } | ||
317 | + | ||
318 | + for (i = 0; i < v->shadow_vqs->len; ++i) { | ||
319 | + VhostShadowVirtqueue *svq = g_ptr_array_index(v->shadow_vqs, i); | ||
320 | + bool ok = vhost_vdpa_svq_setup(dev, svq, i, &err); | ||
321 | + if (unlikely(!ok)) { | ||
322 | + error_reportf_err(err, "Cannot setup SVQ %u: ", i); | ||
323 | + return false; | ||
324 | + } | ||
325 | + } | ||
326 | + | ||
327 | + return true; | ||
328 | +} | ||
329 | + | ||
330 | static int vhost_vdpa_dev_start(struct vhost_dev *dev, bool started) | ||
331 | { | ||
332 | struct vhost_vdpa *v = dev->opaque; | ||
333 | + bool ok; | ||
334 | trace_vhost_vdpa_dev_start(dev, started); | ||
335 | |||
336 | if (started) { | ||
337 | vhost_vdpa_host_notifiers_init(dev); | ||
338 | + ok = vhost_vdpa_svqs_start(dev); | ||
339 | + if (unlikely(!ok)) { | ||
340 | + return -1; | ||
341 | + } | ||
342 | vhost_vdpa_set_vring_ready(dev); | ||
343 | } else { | ||
344 | vhost_vdpa_host_notifiers_uninit(dev, dev->nvqs); | ||
345 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_get_vring_base(struct vhost_dev *dev, | ||
346 | static int vhost_vdpa_set_vring_kick(struct vhost_dev *dev, | ||
347 | struct vhost_vring_file *file) | ||
348 | { | ||
349 | - trace_vhost_vdpa_set_vring_kick(dev, file->index, file->fd); | ||
350 | - return vhost_vdpa_call(dev, VHOST_SET_VRING_KICK, file); | ||
351 | + struct vhost_vdpa *v = dev->opaque; | ||
352 | + int vdpa_idx = file->index - dev->vq_index; | ||
353 | + | ||
354 | + if (v->shadow_vqs_enabled) { | ||
355 | + VhostShadowVirtqueue *svq = g_ptr_array_index(v->shadow_vqs, vdpa_idx); | ||
356 | + vhost_svq_set_svq_kick_fd(svq, file->fd); | ||
357 | + return 0; | ||
358 | + } else { | ||
359 | + return vhost_vdpa_set_vring_dev_kick(dev, file); | ||
360 | + } | ||
361 | } | ||
362 | |||
363 | static int vhost_vdpa_set_vring_call(struct vhost_dev *dev, | ||
364 | diff --git a/include/hw/virtio/vhost-vdpa.h b/include/hw/virtio/vhost-vdpa.h | ||
365 | index XXXXXXX..XXXXXXX 100644 | ||
366 | --- a/include/hw/virtio/vhost-vdpa.h | ||
367 | +++ b/include/hw/virtio/vhost-vdpa.h | ||
368 | @@ -XXX,XX +XXX,XX @@ | ||
369 | #ifndef HW_VIRTIO_VHOST_VDPA_H | ||
370 | #define HW_VIRTIO_VHOST_VDPA_H | ||
371 | |||
372 | +#include <gmodule.h> | ||
373 | + | ||
374 | #include "hw/virtio/virtio.h" | ||
375 | #include "standard-headers/linux/vhost_types.h" | ||
376 | |||
377 | @@ -XXX,XX +XXX,XX @@ typedef struct vhost_vdpa { | ||
378 | bool iotlb_batch_begin_sent; | ||
379 | MemoryListener listener; | ||
380 | struct vhost_vdpa_iova_range iova_range; | ||
381 | + bool shadow_vqs_enabled; | ||
382 | + GPtrArray *shadow_vqs; | ||
383 | struct vhost_dev *dev; | ||
384 | VhostVDPAHostNotifier notifier[VIRTIO_QUEUE_MAX]; | ||
385 | } VhostVDPA; | ||
44 | -- | 386 | -- |
45 | 2.7.4 | 387 | 2.7.4 |
388 | |||
389 | diff view generated by jsdifflib |
1 | From: Akihiko Odaki <akihiko.odaki@daynix.com> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | I confirmed it works with Windows even without this workaround. It is | 3 | This will make qemu aware of the device used buffers, allowing it to |
4 | likely to be a mistake so remove it. | 4 | write the guest memory with its contents if needed. |
5 | 5 | ||
6 | Fixes: 3a977deebe ("Intrdocue igb device emulation") | 6 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> |
7 | Signed-off-by: Akihiko Odaki <akihiko.odaki@daynix.com> | 7 | Acked-by: Michael S. Tsirkin <mst@redhat.com> |
8 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 8 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
9 | --- | 9 | --- |
10 | hw/net/igb_core.c | 7 +------ | 10 | hw/virtio/vhost-shadow-virtqueue.c | 38 ++++++++++++++++++++++++++++++++++++++ |
11 | 1 file changed, 1 insertion(+), 6 deletions(-) | 11 | hw/virtio/vhost-shadow-virtqueue.h | 4 ++++ |
12 | hw/virtio/vhost-vdpa.c | 31 +++++++++++++++++++++++++++++-- | ||
13 | 3 files changed, 71 insertions(+), 2 deletions(-) | ||
12 | 14 | ||
13 | diff --git a/hw/net/igb_core.c b/hw/net/igb_core.c | 15 | diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c |
14 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
15 | --- a/hw/net/igb_core.c | 17 | --- a/hw/virtio/vhost-shadow-virtqueue.c |
16 | +++ b/hw/net/igb_core.c | 18 | +++ b/hw/virtio/vhost-shadow-virtqueue.c |
17 | @@ -XXX,XX +XXX,XX @@ static uint32_t igb_get_status(IGBCore *core, int index) | 19 | @@ -XXX,XX +XXX,XX @@ static void vhost_handle_guest_kick(EventNotifier *n) |
18 | res |= E1000_STATUS_IOV_MODE; | 20 | } |
21 | |||
22 | /** | ||
23 | + * Forward vhost notifications | ||
24 | + * | ||
25 | + * @n: hdev call event notifier, the one that device set to notify svq. | ||
26 | + */ | ||
27 | +static void vhost_svq_handle_call(EventNotifier *n) | ||
28 | +{ | ||
29 | + VhostShadowVirtqueue *svq = container_of(n, VhostShadowVirtqueue, | ||
30 | + hdev_call); | ||
31 | + event_notifier_test_and_clear(n); | ||
32 | + event_notifier_set(&svq->svq_call); | ||
33 | +} | ||
34 | + | ||
35 | +/** | ||
36 | + * Set the call notifier for the SVQ to call the guest | ||
37 | + * | ||
38 | + * @svq: Shadow virtqueue | ||
39 | + * @call_fd: call notifier | ||
40 | + * | ||
41 | + * Called on BQL context. | ||
42 | + */ | ||
43 | +void vhost_svq_set_svq_call_fd(VhostShadowVirtqueue *svq, int call_fd) | ||
44 | +{ | ||
45 | + if (call_fd == VHOST_FILE_UNBIND) { | ||
46 | + /* | ||
47 | + * Fail event_notifier_set if called handling device call. | ||
48 | + * | ||
49 | + * SVQ still needs device notifications, since it needs to keep | ||
50 | + * forwarding used buffers even with the unbind. | ||
51 | + */ | ||
52 | + memset(&svq->svq_call, 0, sizeof(svq->svq_call)); | ||
53 | + } else { | ||
54 | + event_notifier_init_fd(&svq->svq_call, call_fd); | ||
55 | + } | ||
56 | +} | ||
57 | + | ||
58 | +/** | ||
59 | * Set a new file descriptor for the guest to kick the SVQ and notify for avail | ||
60 | * | ||
61 | * @svq: The svq | ||
62 | @@ -XXX,XX +XXX,XX @@ VhostShadowVirtqueue *vhost_svq_new(void) | ||
19 | } | 63 | } |
20 | 64 | ||
21 | - /* | 65 | event_notifier_init_fd(&svq->svq_kick, VHOST_FILE_UNBIND); |
22 | - * Windows driver 12.18.9.23 resets if E1000_STATUS_GIO_MASTER_ENABLE is | 66 | + event_notifier_set_handler(&svq->hdev_call, vhost_svq_handle_call); |
23 | - * left set after E1000_CTRL_LRST is set. | 67 | return g_steal_pointer(&svq); |
24 | - */ | 68 | |
25 | - if (!(core->mac[CTRL] & E1000_CTRL_GIO_MASTER_DISABLE) && | 69 | err_init_hdev_call: |
26 | - !(core->mac[CTRL] & E1000_CTRL_LRST)) { | 70 | @@ -XXX,XX +XXX,XX @@ void vhost_svq_free(gpointer pvq) |
27 | + if (!(core->mac[CTRL] & E1000_CTRL_GIO_MASTER_DISABLE)) { | 71 | VhostShadowVirtqueue *vq = pvq; |
28 | res |= E1000_STATUS_GIO_MASTER_ENABLE; | 72 | vhost_svq_stop(vq); |
73 | event_notifier_cleanup(&vq->hdev_kick); | ||
74 | + event_notifier_set_handler(&vq->hdev_call, NULL); | ||
75 | event_notifier_cleanup(&vq->hdev_call); | ||
76 | g_free(vq); | ||
77 | } | ||
78 | diff --git a/hw/virtio/vhost-shadow-virtqueue.h b/hw/virtio/vhost-shadow-virtqueue.h | ||
79 | index XXXXXXX..XXXXXXX 100644 | ||
80 | --- a/hw/virtio/vhost-shadow-virtqueue.h | ||
81 | +++ b/hw/virtio/vhost-shadow-virtqueue.h | ||
82 | @@ -XXX,XX +XXX,XX @@ typedef struct VhostShadowVirtqueue { | ||
83 | * So shadow virtqueue must not clean it, or we would lose VirtQueue one. | ||
84 | */ | ||
85 | EventNotifier svq_kick; | ||
86 | + | ||
87 | + /* Guest's call notifier, where the SVQ calls guest. */ | ||
88 | + EventNotifier svq_call; | ||
89 | } VhostShadowVirtqueue; | ||
90 | |||
91 | void vhost_svq_set_svq_kick_fd(VhostShadowVirtqueue *svq, int svq_kick_fd); | ||
92 | +void vhost_svq_set_svq_call_fd(VhostShadowVirtqueue *svq, int call_fd); | ||
93 | |||
94 | void vhost_svq_stop(VhostShadowVirtqueue *svq); | ||
95 | |||
96 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c | ||
97 | index XXXXXXX..XXXXXXX 100644 | ||
98 | --- a/hw/virtio/vhost-vdpa.c | ||
99 | +++ b/hw/virtio/vhost-vdpa.c | ||
100 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_vring_dev_kick(struct vhost_dev *dev, | ||
101 | return vhost_vdpa_call(dev, VHOST_SET_VRING_KICK, file); | ||
102 | } | ||
103 | |||
104 | +static int vhost_vdpa_set_vring_dev_call(struct vhost_dev *dev, | ||
105 | + struct vhost_vring_file *file) | ||
106 | +{ | ||
107 | + trace_vhost_vdpa_set_vring_call(dev, file->index, file->fd); | ||
108 | + return vhost_vdpa_call(dev, VHOST_SET_VRING_CALL, file); | ||
109 | +} | ||
110 | + | ||
111 | /** | ||
112 | * Set the shadow virtqueue descriptors to the device | ||
113 | * | ||
114 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_vring_dev_kick(struct vhost_dev *dev, | ||
115 | * @svq: The shadow virtqueue | ||
116 | * @idx: The index of the virtqueue in the vhost device | ||
117 | * @errp: Error | ||
118 | + * | ||
119 | + * Note that this function does not rewind kick file descriptor if cannot set | ||
120 | + * call one. | ||
121 | */ | ||
122 | static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, | ||
123 | VhostShadowVirtqueue *svq, unsigned idx, | ||
124 | @@ -XXX,XX +XXX,XX @@ static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, | ||
125 | r = vhost_vdpa_set_vring_dev_kick(dev, &file); | ||
126 | if (unlikely(r != 0)) { | ||
127 | error_setg_errno(errp, -r, "Can't set device kick fd"); | ||
128 | + return false; | ||
129 | + } | ||
130 | + | ||
131 | + event_notifier = &svq->hdev_call; | ||
132 | + file.fd = event_notifier_get_fd(event_notifier); | ||
133 | + r = vhost_vdpa_set_vring_dev_call(dev, &file); | ||
134 | + if (unlikely(r != 0)) { | ||
135 | + error_setg_errno(errp, -r, "Can't set device call fd"); | ||
29 | } | 136 | } |
30 | 137 | ||
138 | return r == 0; | ||
139 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_vring_kick(struct vhost_dev *dev, | ||
140 | static int vhost_vdpa_set_vring_call(struct vhost_dev *dev, | ||
141 | struct vhost_vring_file *file) | ||
142 | { | ||
143 | - trace_vhost_vdpa_set_vring_call(dev, file->index, file->fd); | ||
144 | - return vhost_vdpa_call(dev, VHOST_SET_VRING_CALL, file); | ||
145 | + struct vhost_vdpa *v = dev->opaque; | ||
146 | + | ||
147 | + if (v->shadow_vqs_enabled) { | ||
148 | + int vdpa_idx = file->index - dev->vq_index; | ||
149 | + VhostShadowVirtqueue *svq = g_ptr_array_index(v->shadow_vqs, vdpa_idx); | ||
150 | + | ||
151 | + vhost_svq_set_svq_call_fd(svq, file->fd); | ||
152 | + return 0; | ||
153 | + } else { | ||
154 | + return vhost_vdpa_set_vring_dev_call(dev, file); | ||
155 | + } | ||
156 | } | ||
157 | |||
158 | static int vhost_vdpa_get_features(struct vhost_dev *dev, | ||
31 | -- | 159 | -- |
32 | 2.7.4 | 160 | 2.7.4 |
161 | |||
162 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | This allows SVQ to negotiate features with the guest and the device. For |
4 | QEMU networking codes, remove the same logic in the NIC codes. | 4 | the device, SVQ is a driver. While this function bypasses all |
5 | non-transport features, it needs to disable the features that SVQ does | ||
6 | not support when forwarding buffers. This includes packed vq layout, | ||
7 | indirect descriptors or event idx. | ||
5 | 8 | ||
6 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | 9 | Future changes can add support to offer more features to the guest, |
10 | since the use of VirtQueue gives this for free. This is left out at the | ||
11 | moment for simplicity. | ||
12 | |||
13 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
14 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 15 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
8 | --- | 16 | --- |
9 | hw/net/rtl8139.c | 12 ------------ | 17 | hw/virtio/vhost-shadow-virtqueue.c | 44 ++++++++++++++++++++++++++++++++++++++ |
10 | 1 file changed, 12 deletions(-) | 18 | hw/virtio/vhost-shadow-virtqueue.h | 2 ++ |
19 | hw/virtio/vhost-vdpa.c | 15 +++++++++++++ | ||
20 | 3 files changed, 61 insertions(+) | ||
11 | 21 | ||
12 | diff --git a/hw/net/rtl8139.c b/hw/net/rtl8139.c | 22 | diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c |
13 | index XXXXXXX..XXXXXXX 100644 | 23 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/hw/net/rtl8139.c | 24 | --- a/hw/virtio/vhost-shadow-virtqueue.c |
15 | +++ b/hw/net/rtl8139.c | 25 | +++ b/hw/virtio/vhost-shadow-virtqueue.c |
16 | @@ -XXX,XX +XXX,XX @@ static ssize_t rtl8139_do_receive(NetClientState *nc, const uint8_t *buf, size_t | 26 | @@ -XXX,XX +XXX,XX @@ |
17 | 27 | #include "hw/virtio/vhost-shadow-virtqueue.h" | |
18 | uint32_t packet_header = 0; | 28 | |
19 | 29 | #include "qemu/error-report.h" | |
20 | - uint8_t buf1[MIN_BUF_SIZE + VLAN_HLEN]; | 30 | +#include "qapi/error.h" |
21 | static const uint8_t broadcast_macaddr[6] = | 31 | #include "qemu/main-loop.h" |
22 | { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; | 32 | #include "linux-headers/linux/vhost.h" |
23 | 33 | ||
24 | @@ -XXX,XX +XXX,XX @@ static ssize_t rtl8139_do_receive(NetClientState *nc, const uint8_t *buf, size_t | 34 | /** |
25 | } | 35 | + * Validate the transport device features that both guests can use with the SVQ |
36 | + * and SVQs can use with the device. | ||
37 | + * | ||
38 | + * @dev_features: The features | ||
39 | + * @errp: Error pointer | ||
40 | + */ | ||
41 | +bool vhost_svq_valid_features(uint64_t features, Error **errp) | ||
42 | +{ | ||
43 | + bool ok = true; | ||
44 | + uint64_t svq_features = features; | ||
45 | + | ||
46 | + for (uint64_t b = VIRTIO_TRANSPORT_F_START; b <= VIRTIO_TRANSPORT_F_END; | ||
47 | + ++b) { | ||
48 | + switch (b) { | ||
49 | + case VIRTIO_F_ANY_LAYOUT: | ||
50 | + continue; | ||
51 | + | ||
52 | + case VIRTIO_F_ACCESS_PLATFORM: | ||
53 | + /* SVQ trust in the host's IOMMU to translate addresses */ | ||
54 | + case VIRTIO_F_VERSION_1: | ||
55 | + /* SVQ trust that the guest vring is little endian */ | ||
56 | + if (!(svq_features & BIT_ULL(b))) { | ||
57 | + svq_features |= BIT_ULL(b); | ||
58 | + ok = false; | ||
59 | + } | ||
60 | + continue; | ||
61 | + | ||
62 | + default: | ||
63 | + if (svq_features & BIT_ULL(b)) { | ||
64 | + svq_features &= ~BIT_ULL(b); | ||
65 | + ok = false; | ||
66 | + } | ||
67 | + } | ||
68 | + } | ||
69 | + | ||
70 | + if (!ok) { | ||
71 | + error_setg(errp, "SVQ Invalid device feature flags, offer: 0x%"PRIx64 | ||
72 | + ", ok: 0x%"PRIx64, features, svq_features); | ||
73 | + } | ||
74 | + return ok; | ||
75 | +} | ||
76 | + | ||
77 | +/** | ||
78 | * Forward guest notifications. | ||
79 | * | ||
80 | * @n: guest kick event notifier, the one that guest set to notify svq. | ||
81 | diff --git a/hw/virtio/vhost-shadow-virtqueue.h b/hw/virtio/vhost-shadow-virtqueue.h | ||
82 | index XXXXXXX..XXXXXXX 100644 | ||
83 | --- a/hw/virtio/vhost-shadow-virtqueue.h | ||
84 | +++ b/hw/virtio/vhost-shadow-virtqueue.h | ||
85 | @@ -XXX,XX +XXX,XX @@ typedef struct VhostShadowVirtqueue { | ||
86 | EventNotifier svq_call; | ||
87 | } VhostShadowVirtqueue; | ||
88 | |||
89 | +bool vhost_svq_valid_features(uint64_t features, Error **errp); | ||
90 | + | ||
91 | void vhost_svq_set_svq_kick_fd(VhostShadowVirtqueue *svq, int svq_kick_fd); | ||
92 | void vhost_svq_set_svq_call_fd(VhostShadowVirtqueue *svq, int call_fd); | ||
93 | |||
94 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c | ||
95 | index XXXXXXX..XXXXXXX 100644 | ||
96 | --- a/hw/virtio/vhost-vdpa.c | ||
97 | +++ b/hw/virtio/vhost-vdpa.c | ||
98 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_init_svq(struct vhost_dev *hdev, struct vhost_vdpa *v, | ||
99 | Error **errp) | ||
100 | { | ||
101 | g_autoptr(GPtrArray) shadow_vqs = NULL; | ||
102 | + uint64_t dev_features, svq_features; | ||
103 | + int r; | ||
104 | + bool ok; | ||
105 | |||
106 | if (!v->shadow_vqs_enabled) { | ||
107 | return 0; | ||
26 | } | 108 | } |
27 | 109 | ||
28 | - /* if too small buffer, then expand it | 110 | + r = hdev->vhost_ops->vhost_get_features(hdev, &dev_features); |
29 | - * Include some tailroom in case a vlan tag is later removed. */ | 111 | + if (r != 0) { |
30 | - if (size < MIN_BUF_SIZE + VLAN_HLEN) { | 112 | + error_setg_errno(errp, -r, "Can't get vdpa device features"); |
31 | - memcpy(buf1, buf, size); | 113 | + return r; |
32 | - memset(buf1 + size, 0, MIN_BUF_SIZE + VLAN_HLEN - size); | 114 | + } |
33 | - buf = buf1; | 115 | + |
34 | - if (size < MIN_BUF_SIZE) { | 116 | + svq_features = dev_features; |
35 | - size = MIN_BUF_SIZE; | 117 | + ok = vhost_svq_valid_features(svq_features, errp); |
36 | - } | 118 | + if (unlikely(!ok)) { |
37 | - } | 119 | + return -1; |
38 | - | 120 | + } |
39 | if (rtl8139_cp_receiver_enabled(s)) | 121 | + |
40 | { | 122 | shadow_vqs = g_ptr_array_new_full(hdev->nvqs, vhost_svq_free); |
41 | if (!rtl8139_cp_rx_valid(s)) { | 123 | for (unsigned n = 0; n < hdev->nvqs; ++n) { |
124 | g_autoptr(VhostShadowVirtqueue) svq = vhost_svq_new(); | ||
42 | -- | 125 | -- |
43 | 2.7.4 | 126 | 2.7.4 |
127 | |||
128 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | It reports the shadow virtqueue address from qemu virtual address space. |
4 | QEMU networking codes, remove the same logic in the NIC codes. | ||
5 | 4 | ||
6 | This actually reverts commit 40a87c6c9b11ef9c14e0301f76abf0eb2582f08e. | 5 | Since this will be different from the guest's vaddr, but the device can |
6 | access it, SVQ takes special care about its alignment & lack of garbage | ||
7 | data. It assumes that IOMMU will work in host_page_size ranges for that. | ||
7 | 8 | ||
8 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | 9 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> |
10 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 11 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
10 | --- | 12 | --- |
11 | hw/net/vmxnet3.c | 10 ---------- | 13 | hw/virtio/vhost-shadow-virtqueue.c | 29 +++++++++++++++++++++++++++++ |
12 | 1 file changed, 10 deletions(-) | 14 | hw/virtio/vhost-shadow-virtqueue.h | 9 +++++++++ |
15 | 2 files changed, 38 insertions(+) | ||
13 | 16 | ||
14 | diff --git a/hw/net/vmxnet3.c b/hw/net/vmxnet3.c | 17 | diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c |
15 | index XXXXXXX..XXXXXXX 100644 | 18 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/hw/net/vmxnet3.c | 19 | --- a/hw/virtio/vhost-shadow-virtqueue.c |
17 | +++ b/hw/net/vmxnet3.c | 20 | +++ b/hw/virtio/vhost-shadow-virtqueue.c |
21 | @@ -XXX,XX +XXX,XX @@ void vhost_svq_set_svq_call_fd(VhostShadowVirtqueue *svq, int call_fd) | ||
22 | } | ||
23 | |||
24 | /** | ||
25 | + * Get the shadow vq vring address. | ||
26 | + * @svq: Shadow virtqueue | ||
27 | + * @addr: Destination to store address | ||
28 | + */ | ||
29 | +void vhost_svq_get_vring_addr(const VhostShadowVirtqueue *svq, | ||
30 | + struct vhost_vring_addr *addr) | ||
31 | +{ | ||
32 | + addr->desc_user_addr = (uint64_t)(intptr_t)svq->vring.desc; | ||
33 | + addr->avail_user_addr = (uint64_t)(intptr_t)svq->vring.avail; | ||
34 | + addr->used_user_addr = (uint64_t)(intptr_t)svq->vring.used; | ||
35 | +} | ||
36 | + | ||
37 | +size_t vhost_svq_driver_area_size(const VhostShadowVirtqueue *svq) | ||
38 | +{ | ||
39 | + size_t desc_size = sizeof(vring_desc_t) * svq->vring.num; | ||
40 | + size_t avail_size = offsetof(vring_avail_t, ring) + | ||
41 | + sizeof(uint16_t) * svq->vring.num; | ||
42 | + | ||
43 | + return ROUND_UP(desc_size + avail_size, qemu_real_host_page_size); | ||
44 | +} | ||
45 | + | ||
46 | +size_t vhost_svq_device_area_size(const VhostShadowVirtqueue *svq) | ||
47 | +{ | ||
48 | + size_t used_size = offsetof(vring_used_t, ring) + | ||
49 | + sizeof(vring_used_elem_t) * svq->vring.num; | ||
50 | + return ROUND_UP(used_size, qemu_real_host_page_size); | ||
51 | +} | ||
52 | + | ||
53 | +/** | ||
54 | * Set a new file descriptor for the guest to kick the SVQ and notify for avail | ||
55 | * | ||
56 | * @svq: The svq | ||
57 | diff --git a/hw/virtio/vhost-shadow-virtqueue.h b/hw/virtio/vhost-shadow-virtqueue.h | ||
58 | index XXXXXXX..XXXXXXX 100644 | ||
59 | --- a/hw/virtio/vhost-shadow-virtqueue.h | ||
60 | +++ b/hw/virtio/vhost-shadow-virtqueue.h | ||
18 | @@ -XXX,XX +XXX,XX @@ | 61 | @@ -XXX,XX +XXX,XX @@ |
19 | 62 | #define VHOST_SHADOW_VIRTQUEUE_H | |
20 | #define PCI_DEVICE_ID_VMWARE_VMXNET3_REVISION 0x1 | 63 | |
21 | #define VMXNET3_MSIX_BAR_SIZE 0x2000 | 64 | #include "qemu/event_notifier.h" |
22 | -#define MIN_BUF_SIZE 60 | 65 | +#include "hw/virtio/virtio.h" |
23 | 66 | +#include "standard-headers/linux/vhost_types.h" | |
24 | /* Compatibility flags for migration */ | 67 | |
25 | #define VMXNET3_COMPAT_FLAG_OLD_MSI_OFFSETS_BIT 0 | 68 | /* Shadow virtqueue to relay notifications */ |
26 | @@ -XXX,XX +XXX,XX @@ vmxnet3_receive(NetClientState *nc, const uint8_t *buf, size_t size) | 69 | typedef struct VhostShadowVirtqueue { |
27 | { | 70 | + /* Shadow vring */ |
28 | VMXNET3State *s = qemu_get_nic_opaque(nc); | 71 | + struct vring vring; |
29 | size_t bytes_indicated; | 72 | + |
30 | - uint8_t min_buf[MIN_BUF_SIZE]; | 73 | /* Shadow kick notifier, sent to vhost */ |
31 | 74 | EventNotifier hdev_kick; | |
32 | if (!vmxnet3_can_receive(nc)) { | 75 | /* Shadow call notifier, sent to vhost */ |
33 | VMW_PKPRN("Cannot receive now"); | 76 | @@ -XXX,XX +XXX,XX @@ bool vhost_svq_valid_features(uint64_t features, Error **errp); |
34 | @@ -XXX,XX +XXX,XX @@ vmxnet3_receive(NetClientState *nc, const uint8_t *buf, size_t size) | 77 | |
35 | size -= sizeof(struct virtio_net_hdr); | 78 | void vhost_svq_set_svq_kick_fd(VhostShadowVirtqueue *svq, int svq_kick_fd); |
36 | } | 79 | void vhost_svq_set_svq_call_fd(VhostShadowVirtqueue *svq, int call_fd); |
37 | 80 | +void vhost_svq_get_vring_addr(const VhostShadowVirtqueue *svq, | |
38 | - /* Pad to minimum Ethernet frame length */ | 81 | + struct vhost_vring_addr *addr); |
39 | - if (size < sizeof(min_buf)) { | 82 | +size_t vhost_svq_driver_area_size(const VhostShadowVirtqueue *svq); |
40 | - memcpy(min_buf, buf, size); | 83 | +size_t vhost_svq_device_area_size(const VhostShadowVirtqueue *svq); |
41 | - memset(&min_buf[size], 0, sizeof(min_buf) - size); | 84 | |
42 | - buf = min_buf; | 85 | void vhost_svq_stop(VhostShadowVirtqueue *svq); |
43 | - size = sizeof(min_buf); | ||
44 | - } | ||
45 | - | ||
46 | net_rx_pkt_set_packet_type(s->rx_pkt, | ||
47 | get_eth_packet_type(PKT_GET_ETH_HDR(buf))); | ||
48 | 86 | ||
49 | -- | 87 | -- |
50 | 2.7.4 | 88 | 2.7.4 |
89 | |||
90 | diff view generated by jsdifflib |
1 | From: Laurent Vivier <lvivier@redhat.com> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Move the file descriptor type checking before doing anything with it. | 3 | First half of the buffers forwarding part, preparing vhost-vdpa |
4 | If it's not usable, don't close it as it could be in use by another | 4 | callbacks to SVQ to offer it. QEMU cannot enable it at this moment, so |
5 | part of QEMU, only fail and report an error. | 5 | this is effectively dead code at the moment, but it helps to reduce |
6 | patch size. | ||
6 | 7 | ||
7 | Reviewed-by: David Gibson <david@gibson.dropbear.id.au> | 8 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> |
8 | Signed-off-by: Laurent Vivier <lvivier@redhat.com> | 9 | Acked-by: Michael S. Tsirkin <mst@redhat.com> |
9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 10 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
10 | --- | 11 | --- |
11 | net/socket.c | 43 +++++++++++++++++-------------------------- | 12 | hw/virtio/vhost-vdpa.c | 48 +++++++++++++++++++++++++++++++++++++++++------- |
12 | 1 file changed, 17 insertions(+), 26 deletions(-) | 13 | 1 file changed, 41 insertions(+), 7 deletions(-) |
13 | 14 | ||
14 | diff --git a/net/socket.c b/net/socket.c | 15 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c |
15 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/net/socket.c | 17 | --- a/hw/virtio/vhost-vdpa.c |
17 | +++ b/net/socket.c | 18 | +++ b/hw/virtio/vhost-vdpa.c |
18 | @@ -XXX,XX +XXX,XX @@ static int net_socket_fd_check(int fd, Error **errp) | 19 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_get_config(struct vhost_dev *dev, uint8_t *config, |
19 | return so_type; | 20 | return ret; |
21 | } | ||
22 | |||
23 | +static int vhost_vdpa_set_dev_vring_base(struct vhost_dev *dev, | ||
24 | + struct vhost_vring_state *ring) | ||
25 | +{ | ||
26 | + trace_vhost_vdpa_set_vring_base(dev, ring->index, ring->num); | ||
27 | + return vhost_vdpa_call(dev, VHOST_SET_VRING_BASE, ring); | ||
28 | +} | ||
29 | + | ||
30 | static int vhost_vdpa_set_vring_dev_kick(struct vhost_dev *dev, | ||
31 | struct vhost_vring_file *file) | ||
32 | { | ||
33 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_vring_dev_call(struct vhost_dev *dev, | ||
34 | return vhost_vdpa_call(dev, VHOST_SET_VRING_CALL, file); | ||
20 | } | 35 | } |
21 | 36 | ||
22 | -static NetSocketState *net_socket_fd_init(NetClientState *peer, | 37 | +static int vhost_vdpa_set_vring_dev_addr(struct vhost_dev *dev, |
23 | - const char *model, const char *name, | 38 | + struct vhost_vring_addr *addr) |
24 | - int fd, int is_connected, | 39 | +{ |
25 | - const char *mc, Error **errp) | 40 | + trace_vhost_vdpa_set_vring_addr(dev, addr->index, addr->flags, |
26 | -{ | 41 | + addr->desc_user_addr, addr->used_user_addr, |
27 | - int so_type; | 42 | + addr->avail_user_addr, |
28 | - | 43 | + addr->log_guest_addr); |
29 | - so_type = net_socket_fd_check(fd, errp); | 44 | + |
30 | - if (so_type < 0) { | 45 | + return vhost_vdpa_call(dev, VHOST_SET_VRING_ADDR, addr); |
31 | - close(fd); | 46 | + |
32 | - return NULL; | 47 | +} |
33 | - } | 48 | + |
34 | - switch(so_type) { | 49 | /** |
35 | - case SOCK_DGRAM: | 50 | * Set the shadow virtqueue descriptors to the device |
36 | - return net_socket_fd_init_dgram(peer, model, name, fd, is_connected, | 51 | * |
37 | - mc, errp); | 52 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_log_base(struct vhost_dev *dev, uint64_t base, |
38 | - case SOCK_STREAM: | 53 | static int vhost_vdpa_set_vring_addr(struct vhost_dev *dev, |
39 | - return net_socket_fd_init_stream(peer, model, name, fd, is_connected); | 54 | struct vhost_vring_addr *addr) |
40 | - } | ||
41 | - return NULL; | ||
42 | -} | ||
43 | - | ||
44 | static void net_socket_accept(void *opaque) | ||
45 | { | 55 | { |
46 | NetSocketState *s = opaque; | 56 | - trace_vhost_vdpa_set_vring_addr(dev, addr->index, addr->flags, |
47 | @@ -XXX,XX +XXX,XX @@ int net_init_socket(const Netdev *netdev, const char *name, | 57 | - addr->desc_user_addr, addr->used_user_addr, |
48 | } | 58 | - addr->avail_user_addr, |
49 | 59 | - addr->log_guest_addr); | |
50 | if (sock->fd) { | 60 | - return vhost_vdpa_call(dev, VHOST_SET_VRING_ADDR, addr); |
51 | - int fd, ret; | 61 | + struct vhost_vdpa *v = dev->opaque; |
52 | + int fd, ret, so_type; | 62 | + |
53 | 63 | + if (v->shadow_vqs_enabled) { | |
54 | fd = monitor_fd_param(monitor_cur(), sock->fd, errp); | 64 | + /* |
55 | if (fd == -1) { | 65 | + * Device vring addr was set at device start. SVQ base is handled by |
56 | return -1; | 66 | + * VirtQueue code. |
57 | } | 67 | + */ |
58 | + so_type = net_socket_fd_check(fd, errp); | 68 | + return 0; |
59 | + if (so_type < 0) { | 69 | + } |
60 | + return -1; | 70 | + |
61 | + } | 71 | + return vhost_vdpa_set_vring_dev_addr(dev, addr); |
62 | ret = qemu_socket_try_set_nonblock(fd); | 72 | } |
63 | if (ret < 0) { | 73 | |
64 | error_setg_errno(errp, -ret, "%s: Can't use file descriptor %d", | 74 | static int vhost_vdpa_set_vring_num(struct vhost_dev *dev, |
65 | name, fd); | 75 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_vring_num(struct vhost_dev *dev, |
66 | return -1; | 76 | static int vhost_vdpa_set_vring_base(struct vhost_dev *dev, |
67 | } | 77 | struct vhost_vring_state *ring) |
68 | - if (!net_socket_fd_init(peer, "socket", name, fd, 1, sock->mcast, | 78 | { |
69 | - errp)) { | 79 | - trace_vhost_vdpa_set_vring_base(dev, ring->index, ring->num); |
70 | - return -1; | 80 | - return vhost_vdpa_call(dev, VHOST_SET_VRING_BASE, ring); |
71 | + switch (so_type) { | 81 | + struct vhost_vdpa *v = dev->opaque; |
72 | + case SOCK_DGRAM: | 82 | + |
73 | + if (!net_socket_fd_init_dgram(peer, "socket", name, fd, 1, | 83 | + if (v->shadow_vqs_enabled) { |
74 | + sock->mcast, errp)) { | 84 | + /* |
75 | + return -1; | 85 | + * Device vring base was set at device start. SVQ base is handled by |
76 | + } | 86 | + * VirtQueue code. |
77 | + break; | 87 | + */ |
78 | + case SOCK_STREAM: | 88 | + return 0; |
79 | + if (!net_socket_fd_init_stream(peer, "socket", name, fd, 1)) { | 89 | + } |
80 | + return -1; | 90 | + |
81 | + } | 91 | + return vhost_vdpa_set_dev_vring_base(dev, ring); |
82 | + break; | 92 | } |
83 | } | 93 | |
84 | return 0; | 94 | static int vhost_vdpa_get_vring_base(struct vhost_dev *dev, |
85 | } | ||
86 | -- | 95 | -- |
87 | 2.7.4 | 96 | 2.7.4 |
97 | |||
98 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | Initial version of shadow virtqueue that actually forward buffers. There |
4 | QEMU networking codes, remove the same logic in the NIC codes. | 4 | is no iommu support at the moment, and that will be addressed in future |
5 | 5 | patches of this series. Since all vhost-vdpa devices use forced IOMMU, | |
6 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | 6 | this means that SVQ is not usable at this point of the series on any |
7 | device. | ||
8 | |||
9 | For simplicity it only supports modern devices, that expects vring | ||
10 | in little endian, with split ring and no event idx or indirect | ||
11 | descriptors. Support for them will not be added in this series. | ||
12 | |||
13 | It reuses the VirtQueue code for the device part. The driver part is | ||
14 | based on Linux's virtio_ring driver, but with stripped functionality | ||
15 | and optimizations so it's easier to review. | ||
16 | |||
17 | However, forwarding buffers have some particular pieces: One of the most | ||
18 | unexpected ones is that a guest's buffer can expand through more than | ||
19 | one descriptor in SVQ. While this is handled gracefully by qemu's | ||
20 | emulated virtio devices, it may cause unexpected SVQ queue full. This | ||
21 | patch also solves it by checking for this condition at both guest's | ||
22 | kicks and device's calls. The code may be more elegant in the future if | ||
23 | SVQ code runs in its own iocontext. | ||
24 | |||
25 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
26 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 27 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
8 | --- | 28 | --- |
9 | hw/net/ne2000.c | 12 ------------ | 29 | hw/virtio/vhost-shadow-virtqueue.c | 352 ++++++++++++++++++++++++++++++++++++- |
10 | 1 file changed, 12 deletions(-) | 30 | hw/virtio/vhost-shadow-virtqueue.h | 26 +++ |
11 | 31 | hw/virtio/vhost-vdpa.c | 155 +++++++++++++++- | |
12 | diff --git a/hw/net/ne2000.c b/hw/net/ne2000.c | 32 | 3 files changed, 522 insertions(+), 11 deletions(-) |
33 | |||
34 | diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c | ||
13 | index XXXXXXX..XXXXXXX 100644 | 35 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/hw/net/ne2000.c | 36 | --- a/hw/virtio/vhost-shadow-virtqueue.c |
15 | +++ b/hw/net/ne2000.c | 37 | +++ b/hw/virtio/vhost-shadow-virtqueue.c |
16 | @@ -XXX,XX +XXX,XX @@ static int ne2000_buffer_full(NE2000State *s) | 38 | @@ -XXX,XX +XXX,XX @@ |
17 | return 0; | 39 | #include "qemu/error-report.h" |
40 | #include "qapi/error.h" | ||
41 | #include "qemu/main-loop.h" | ||
42 | +#include "qemu/log.h" | ||
43 | +#include "qemu/memalign.h" | ||
44 | #include "linux-headers/linux/vhost.h" | ||
45 | |||
46 | /** | ||
47 | @@ -XXX,XX +XXX,XX @@ bool vhost_svq_valid_features(uint64_t features, Error **errp) | ||
18 | } | 48 | } |
19 | 49 | ||
20 | -#define MIN_BUF_SIZE 60 | 50 | /** |
21 | - | 51 | - * Forward guest notifications. |
22 | ssize_t ne2000_receive(NetClientState *nc, const uint8_t *buf, size_t size_) | 52 | + * Number of descriptors that the SVQ can make available from the guest. |
53 | + * | ||
54 | + * @svq: The svq | ||
55 | + */ | ||
56 | +static uint16_t vhost_svq_available_slots(const VhostShadowVirtqueue *svq) | ||
57 | +{ | ||
58 | + return svq->vring.num - (svq->shadow_avail_idx - svq->shadow_used_idx); | ||
59 | +} | ||
60 | + | ||
61 | +static void vhost_vring_write_descs(VhostShadowVirtqueue *svq, | ||
62 | + const struct iovec *iovec, size_t num, | ||
63 | + bool more_descs, bool write) | ||
64 | +{ | ||
65 | + uint16_t i = svq->free_head, last = svq->free_head; | ||
66 | + unsigned n; | ||
67 | + uint16_t flags = write ? cpu_to_le16(VRING_DESC_F_WRITE) : 0; | ||
68 | + vring_desc_t *descs = svq->vring.desc; | ||
69 | + | ||
70 | + if (num == 0) { | ||
71 | + return; | ||
72 | + } | ||
73 | + | ||
74 | + for (n = 0; n < num; n++) { | ||
75 | + if (more_descs || (n + 1 < num)) { | ||
76 | + descs[i].flags = flags | cpu_to_le16(VRING_DESC_F_NEXT); | ||
77 | + } else { | ||
78 | + descs[i].flags = flags; | ||
79 | + } | ||
80 | + descs[i].addr = cpu_to_le64((hwaddr)(intptr_t)iovec[n].iov_base); | ||
81 | + descs[i].len = cpu_to_le32(iovec[n].iov_len); | ||
82 | + | ||
83 | + last = i; | ||
84 | + i = cpu_to_le16(descs[i].next); | ||
85 | + } | ||
86 | + | ||
87 | + svq->free_head = le16_to_cpu(descs[last].next); | ||
88 | +} | ||
89 | + | ||
90 | +static bool vhost_svq_add_split(VhostShadowVirtqueue *svq, | ||
91 | + VirtQueueElement *elem, unsigned *head) | ||
92 | +{ | ||
93 | + unsigned avail_idx; | ||
94 | + vring_avail_t *avail = svq->vring.avail; | ||
95 | + | ||
96 | + *head = svq->free_head; | ||
97 | + | ||
98 | + /* We need some descriptors here */ | ||
99 | + if (unlikely(!elem->out_num && !elem->in_num)) { | ||
100 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
101 | + "Guest provided element with no descriptors"); | ||
102 | + return false; | ||
103 | + } | ||
104 | + | ||
105 | + vhost_vring_write_descs(svq, elem->out_sg, elem->out_num, elem->in_num > 0, | ||
106 | + false); | ||
107 | + vhost_vring_write_descs(svq, elem->in_sg, elem->in_num, false, true); | ||
108 | + | ||
109 | + /* | ||
110 | + * Put the entry in the available array (but don't update avail->idx until | ||
111 | + * they do sync). | ||
112 | + */ | ||
113 | + avail_idx = svq->shadow_avail_idx & (svq->vring.num - 1); | ||
114 | + avail->ring[avail_idx] = cpu_to_le16(*head); | ||
115 | + svq->shadow_avail_idx++; | ||
116 | + | ||
117 | + /* Update the avail index after write the descriptor */ | ||
118 | + smp_wmb(); | ||
119 | + avail->idx = cpu_to_le16(svq->shadow_avail_idx); | ||
120 | + | ||
121 | + return true; | ||
122 | +} | ||
123 | + | ||
124 | +static bool vhost_svq_add(VhostShadowVirtqueue *svq, VirtQueueElement *elem) | ||
125 | +{ | ||
126 | + unsigned qemu_head; | ||
127 | + bool ok = vhost_svq_add_split(svq, elem, &qemu_head); | ||
128 | + if (unlikely(!ok)) { | ||
129 | + return false; | ||
130 | + } | ||
131 | + | ||
132 | + svq->ring_id_maps[qemu_head] = elem; | ||
133 | + return true; | ||
134 | +} | ||
135 | + | ||
136 | +static void vhost_svq_kick(VhostShadowVirtqueue *svq) | ||
137 | +{ | ||
138 | + /* | ||
139 | + * We need to expose the available array entries before checking the used | ||
140 | + * flags | ||
141 | + */ | ||
142 | + smp_mb(); | ||
143 | + if (svq->vring.used->flags & VRING_USED_F_NO_NOTIFY) { | ||
144 | + return; | ||
145 | + } | ||
146 | + | ||
147 | + event_notifier_set(&svq->hdev_kick); | ||
148 | +} | ||
149 | + | ||
150 | +/** | ||
151 | + * Forward available buffers. | ||
152 | + * | ||
153 | + * @svq: Shadow VirtQueue | ||
154 | + * | ||
155 | + * Note that this function does not guarantee that all guest's available | ||
156 | + * buffers are available to the device in SVQ avail ring. The guest may have | ||
157 | + * exposed a GPA / GIOVA contiguous buffer, but it may not be contiguous in | ||
158 | + * qemu vaddr. | ||
159 | + * | ||
160 | + * If that happens, guest's kick notifications will be disabled until the | ||
161 | + * device uses some buffers. | ||
162 | + */ | ||
163 | +static void vhost_handle_guest_kick(VhostShadowVirtqueue *svq) | ||
164 | +{ | ||
165 | + /* Clear event notifier */ | ||
166 | + event_notifier_test_and_clear(&svq->svq_kick); | ||
167 | + | ||
168 | + /* Forward to the device as many available buffers as possible */ | ||
169 | + do { | ||
170 | + virtio_queue_set_notification(svq->vq, false); | ||
171 | + | ||
172 | + while (true) { | ||
173 | + VirtQueueElement *elem; | ||
174 | + bool ok; | ||
175 | + | ||
176 | + if (svq->next_guest_avail_elem) { | ||
177 | + elem = g_steal_pointer(&svq->next_guest_avail_elem); | ||
178 | + } else { | ||
179 | + elem = virtqueue_pop(svq->vq, sizeof(*elem)); | ||
180 | + } | ||
181 | + | ||
182 | + if (!elem) { | ||
183 | + break; | ||
184 | + } | ||
185 | + | ||
186 | + if (elem->out_num + elem->in_num > vhost_svq_available_slots(svq)) { | ||
187 | + /* | ||
188 | + * This condition is possible since a contiguous buffer in GPA | ||
189 | + * does not imply a contiguous buffer in qemu's VA | ||
190 | + * scatter-gather segments. If that happens, the buffer exposed | ||
191 | + * to the device needs to be a chain of descriptors at this | ||
192 | + * moment. | ||
193 | + * | ||
194 | + * SVQ cannot hold more available buffers if we are here: | ||
195 | + * queue the current guest descriptor and ignore further kicks | ||
196 | + * until some elements are used. | ||
197 | + */ | ||
198 | + svq->next_guest_avail_elem = elem; | ||
199 | + return; | ||
200 | + } | ||
201 | + | ||
202 | + ok = vhost_svq_add(svq, elem); | ||
203 | + if (unlikely(!ok)) { | ||
204 | + /* VQ is broken, just return and ignore any other kicks */ | ||
205 | + return; | ||
206 | + } | ||
207 | + vhost_svq_kick(svq); | ||
208 | + } | ||
209 | + | ||
210 | + virtio_queue_set_notification(svq->vq, true); | ||
211 | + } while (!virtio_queue_empty(svq->vq)); | ||
212 | +} | ||
213 | + | ||
214 | +/** | ||
215 | + * Handle guest's kick. | ||
216 | * | ||
217 | * @n: guest kick event notifier, the one that guest set to notify svq. | ||
218 | */ | ||
219 | -static void vhost_handle_guest_kick(EventNotifier *n) | ||
220 | +static void vhost_handle_guest_kick_notifier(EventNotifier *n) | ||
23 | { | 221 | { |
24 | NE2000State *s = qemu_get_nic_opaque(nc); | 222 | VhostShadowVirtqueue *svq = container_of(n, VhostShadowVirtqueue, svq_kick); |
25 | size_t size = size_; | 223 | event_notifier_test_and_clear(n); |
26 | uint8_t *p; | 224 | - event_notifier_set(&svq->hdev_kick); |
27 | unsigned int total_len, next, avail, len, index, mcast_idx; | 225 | + vhost_handle_guest_kick(svq); |
28 | - uint8_t buf1[60]; | 226 | +} |
29 | static const uint8_t broadcast_macaddr[6] = | 227 | + |
30 | { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; | 228 | +static bool vhost_svq_more_used(VhostShadowVirtqueue *svq) |
31 | 229 | +{ | |
32 | @@ -XXX,XX +XXX,XX @@ ssize_t ne2000_receive(NetClientState *nc, const uint8_t *buf, size_t size_) | 230 | + if (svq->last_used_idx != svq->shadow_used_idx) { |
231 | + return true; | ||
232 | + } | ||
233 | + | ||
234 | + svq->shadow_used_idx = cpu_to_le16(svq->vring.used->idx); | ||
235 | + | ||
236 | + return svq->last_used_idx != svq->shadow_used_idx; | ||
237 | } | ||
238 | |||
239 | /** | ||
240 | - * Forward vhost notifications | ||
241 | + * Enable vhost device calls after disable them. | ||
242 | + * | ||
243 | + * @svq: The svq | ||
244 | + * | ||
245 | + * It returns false if there are pending used buffers from the vhost device, | ||
246 | + * avoiding the possible races between SVQ checking for more work and enabling | ||
247 | + * callbacks. True if SVQ used vring has no more pending buffers. | ||
248 | + */ | ||
249 | +static bool vhost_svq_enable_notification(VhostShadowVirtqueue *svq) | ||
250 | +{ | ||
251 | + svq->vring.avail->flags &= ~cpu_to_le16(VRING_AVAIL_F_NO_INTERRUPT); | ||
252 | + /* Make sure the flag is written before the read of used_idx */ | ||
253 | + smp_mb(); | ||
254 | + return !vhost_svq_more_used(svq); | ||
255 | +} | ||
256 | + | ||
257 | +static void vhost_svq_disable_notification(VhostShadowVirtqueue *svq) | ||
258 | +{ | ||
259 | + svq->vring.avail->flags |= cpu_to_le16(VRING_AVAIL_F_NO_INTERRUPT); | ||
260 | +} | ||
261 | + | ||
262 | +static VirtQueueElement *vhost_svq_get_buf(VhostShadowVirtqueue *svq, | ||
263 | + uint32_t *len) | ||
264 | +{ | ||
265 | + vring_desc_t *descs = svq->vring.desc; | ||
266 | + const vring_used_t *used = svq->vring.used; | ||
267 | + vring_used_elem_t used_elem; | ||
268 | + uint16_t last_used; | ||
269 | + | ||
270 | + if (!vhost_svq_more_used(svq)) { | ||
271 | + return NULL; | ||
272 | + } | ||
273 | + | ||
274 | + /* Only get used array entries after they have been exposed by dev */ | ||
275 | + smp_rmb(); | ||
276 | + last_used = svq->last_used_idx & (svq->vring.num - 1); | ||
277 | + used_elem.id = le32_to_cpu(used->ring[last_used].id); | ||
278 | + used_elem.len = le32_to_cpu(used->ring[last_used].len); | ||
279 | + | ||
280 | + svq->last_used_idx++; | ||
281 | + if (unlikely(used_elem.id >= svq->vring.num)) { | ||
282 | + qemu_log_mask(LOG_GUEST_ERROR, "Device %s says index %u is used", | ||
283 | + svq->vdev->name, used_elem.id); | ||
284 | + return NULL; | ||
285 | + } | ||
286 | + | ||
287 | + if (unlikely(!svq->ring_id_maps[used_elem.id])) { | ||
288 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
289 | + "Device %s says index %u is used, but it was not available", | ||
290 | + svq->vdev->name, used_elem.id); | ||
291 | + return NULL; | ||
292 | + } | ||
293 | + | ||
294 | + descs[used_elem.id].next = svq->free_head; | ||
295 | + svq->free_head = used_elem.id; | ||
296 | + | ||
297 | + *len = used_elem.len; | ||
298 | + return g_steal_pointer(&svq->ring_id_maps[used_elem.id]); | ||
299 | +} | ||
300 | + | ||
301 | +static void vhost_svq_flush(VhostShadowVirtqueue *svq, | ||
302 | + bool check_for_avail_queue) | ||
303 | +{ | ||
304 | + VirtQueue *vq = svq->vq; | ||
305 | + | ||
306 | + /* Forward as many used buffers as possible. */ | ||
307 | + do { | ||
308 | + unsigned i = 0; | ||
309 | + | ||
310 | + vhost_svq_disable_notification(svq); | ||
311 | + while (true) { | ||
312 | + uint32_t len; | ||
313 | + g_autofree VirtQueueElement *elem = vhost_svq_get_buf(svq, &len); | ||
314 | + if (!elem) { | ||
315 | + break; | ||
316 | + } | ||
317 | + | ||
318 | + if (unlikely(i >= svq->vring.num)) { | ||
319 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
320 | + "More than %u used buffers obtained in a %u size SVQ", | ||
321 | + i, svq->vring.num); | ||
322 | + virtqueue_fill(vq, elem, len, i); | ||
323 | + virtqueue_flush(vq, i); | ||
324 | + return; | ||
325 | + } | ||
326 | + virtqueue_fill(vq, elem, len, i++); | ||
327 | + } | ||
328 | + | ||
329 | + virtqueue_flush(vq, i); | ||
330 | + event_notifier_set(&svq->svq_call); | ||
331 | + | ||
332 | + if (check_for_avail_queue && svq->next_guest_avail_elem) { | ||
333 | + /* | ||
334 | + * Avail ring was full when vhost_svq_flush was called, so it's a | ||
335 | + * good moment to make more descriptors available if possible. | ||
336 | + */ | ||
337 | + vhost_handle_guest_kick(svq); | ||
338 | + } | ||
339 | + } while (!vhost_svq_enable_notification(svq)); | ||
340 | +} | ||
341 | + | ||
342 | +/** | ||
343 | + * Forward used buffers. | ||
344 | * | ||
345 | * @n: hdev call event notifier, the one that device set to notify svq. | ||
346 | + * | ||
347 | + * Note that we are not making any buffers available in the loop, there is no | ||
348 | + * way that it runs more than virtqueue size times. | ||
349 | */ | ||
350 | static void vhost_svq_handle_call(EventNotifier *n) | ||
351 | { | ||
352 | VhostShadowVirtqueue *svq = container_of(n, VhostShadowVirtqueue, | ||
353 | hdev_call); | ||
354 | event_notifier_test_and_clear(n); | ||
355 | - event_notifier_set(&svq->svq_call); | ||
356 | + vhost_svq_flush(svq, true); | ||
357 | } | ||
358 | |||
359 | /** | ||
360 | @@ -XXX,XX +XXX,XX @@ void vhost_svq_set_svq_kick_fd(VhostShadowVirtqueue *svq, int svq_kick_fd) | ||
361 | if (poll_start) { | ||
362 | event_notifier_init_fd(svq_kick, svq_kick_fd); | ||
363 | event_notifier_set(svq_kick); | ||
364 | - event_notifier_set_handler(svq_kick, vhost_handle_guest_kick); | ||
365 | + event_notifier_set_handler(svq_kick, vhost_handle_guest_kick_notifier); | ||
366 | + } | ||
367 | +} | ||
368 | + | ||
369 | +/** | ||
370 | + * Start the shadow virtqueue operation. | ||
371 | + * | ||
372 | + * @svq: Shadow Virtqueue | ||
373 | + * @vdev: VirtIO device | ||
374 | + * @vq: Virtqueue to shadow | ||
375 | + */ | ||
376 | +void vhost_svq_start(VhostShadowVirtqueue *svq, VirtIODevice *vdev, | ||
377 | + VirtQueue *vq) | ||
378 | +{ | ||
379 | + size_t desc_size, driver_size, device_size; | ||
380 | + | ||
381 | + svq->next_guest_avail_elem = NULL; | ||
382 | + svq->shadow_avail_idx = 0; | ||
383 | + svq->shadow_used_idx = 0; | ||
384 | + svq->last_used_idx = 0; | ||
385 | + svq->vdev = vdev; | ||
386 | + svq->vq = vq; | ||
387 | + | ||
388 | + svq->vring.num = virtio_queue_get_num(vdev, virtio_get_queue_index(vq)); | ||
389 | + driver_size = vhost_svq_driver_area_size(svq); | ||
390 | + device_size = vhost_svq_device_area_size(svq); | ||
391 | + svq->vring.desc = qemu_memalign(qemu_real_host_page_size, driver_size); | ||
392 | + desc_size = sizeof(vring_desc_t) * svq->vring.num; | ||
393 | + svq->vring.avail = (void *)((char *)svq->vring.desc + desc_size); | ||
394 | + memset(svq->vring.desc, 0, driver_size); | ||
395 | + svq->vring.used = qemu_memalign(qemu_real_host_page_size, device_size); | ||
396 | + memset(svq->vring.used, 0, device_size); | ||
397 | + svq->ring_id_maps = g_new0(VirtQueueElement *, svq->vring.num); | ||
398 | + for (unsigned i = 0; i < svq->vring.num - 1; i++) { | ||
399 | + svq->vring.desc[i].next = cpu_to_le16(i + 1); | ||
400 | } | ||
401 | } | ||
402 | |||
403 | @@ -XXX,XX +XXX,XX @@ void vhost_svq_set_svq_kick_fd(VhostShadowVirtqueue *svq, int svq_kick_fd) | ||
404 | void vhost_svq_stop(VhostShadowVirtqueue *svq) | ||
405 | { | ||
406 | event_notifier_set_handler(&svq->svq_kick, NULL); | ||
407 | + g_autofree VirtQueueElement *next_avail_elem = NULL; | ||
408 | + | ||
409 | + if (!svq->vq) { | ||
410 | + return; | ||
411 | + } | ||
412 | + | ||
413 | + /* Send all pending used descriptors to guest */ | ||
414 | + vhost_svq_flush(svq, false); | ||
415 | + | ||
416 | + for (unsigned i = 0; i < svq->vring.num; ++i) { | ||
417 | + g_autofree VirtQueueElement *elem = NULL; | ||
418 | + elem = g_steal_pointer(&svq->ring_id_maps[i]); | ||
419 | + if (elem) { | ||
420 | + virtqueue_detach_element(svq->vq, elem, 0); | ||
421 | + } | ||
422 | + } | ||
423 | + | ||
424 | + next_avail_elem = g_steal_pointer(&svq->next_guest_avail_elem); | ||
425 | + if (next_avail_elem) { | ||
426 | + virtqueue_detach_element(svq->vq, next_avail_elem, 0); | ||
427 | + } | ||
428 | + svq->vq = NULL; | ||
429 | + g_free(svq->ring_id_maps); | ||
430 | + qemu_vfree(svq->vring.desc); | ||
431 | + qemu_vfree(svq->vring.used); | ||
432 | } | ||
433 | |||
434 | /** | ||
435 | diff --git a/hw/virtio/vhost-shadow-virtqueue.h b/hw/virtio/vhost-shadow-virtqueue.h | ||
436 | index XXXXXXX..XXXXXXX 100644 | ||
437 | --- a/hw/virtio/vhost-shadow-virtqueue.h | ||
438 | +++ b/hw/virtio/vhost-shadow-virtqueue.h | ||
439 | @@ -XXX,XX +XXX,XX @@ typedef struct VhostShadowVirtqueue { | ||
440 | |||
441 | /* Guest's call notifier, where the SVQ calls guest. */ | ||
442 | EventNotifier svq_call; | ||
443 | + | ||
444 | + /* Virtio queue shadowing */ | ||
445 | + VirtQueue *vq; | ||
446 | + | ||
447 | + /* Virtio device */ | ||
448 | + VirtIODevice *vdev; | ||
449 | + | ||
450 | + /* Map for use the guest's descriptors */ | ||
451 | + VirtQueueElement **ring_id_maps; | ||
452 | + | ||
453 | + /* Next VirtQueue element that guest made available */ | ||
454 | + VirtQueueElement *next_guest_avail_elem; | ||
455 | + | ||
456 | + /* Next head to expose to the device */ | ||
457 | + uint16_t shadow_avail_idx; | ||
458 | + | ||
459 | + /* Next free descriptor */ | ||
460 | + uint16_t free_head; | ||
461 | + | ||
462 | + /* Last seen used idx */ | ||
463 | + uint16_t shadow_used_idx; | ||
464 | + | ||
465 | + /* Next head to consume from the device */ | ||
466 | + uint16_t last_used_idx; | ||
467 | } VhostShadowVirtqueue; | ||
468 | |||
469 | bool vhost_svq_valid_features(uint64_t features, Error **errp); | ||
470 | @@ -XXX,XX +XXX,XX @@ void vhost_svq_get_vring_addr(const VhostShadowVirtqueue *svq, | ||
471 | size_t vhost_svq_driver_area_size(const VhostShadowVirtqueue *svq); | ||
472 | size_t vhost_svq_device_area_size(const VhostShadowVirtqueue *svq); | ||
473 | |||
474 | +void vhost_svq_start(VhostShadowVirtqueue *svq, VirtIODevice *vdev, | ||
475 | + VirtQueue *vq); | ||
476 | void vhost_svq_stop(VhostShadowVirtqueue *svq); | ||
477 | |||
478 | VhostShadowVirtqueue *vhost_svq_new(void); | ||
479 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c | ||
480 | index XXXXXXX..XXXXXXX 100644 | ||
481 | --- a/hw/virtio/vhost-vdpa.c | ||
482 | +++ b/hw/virtio/vhost-vdpa.c | ||
483 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_vring_dev_addr(struct vhost_dev *dev, | ||
484 | * Note that this function does not rewind kick file descriptor if cannot set | ||
485 | * call one. | ||
486 | */ | ||
487 | -static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, | ||
488 | - VhostShadowVirtqueue *svq, unsigned idx, | ||
489 | - Error **errp) | ||
490 | +static int vhost_vdpa_svq_set_fds(struct vhost_dev *dev, | ||
491 | + VhostShadowVirtqueue *svq, unsigned idx, | ||
492 | + Error **errp) | ||
493 | { | ||
494 | struct vhost_vring_file file = { | ||
495 | .index = dev->vq_index + idx, | ||
496 | @@ -XXX,XX +XXX,XX @@ static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, | ||
497 | r = vhost_vdpa_set_vring_dev_kick(dev, &file); | ||
498 | if (unlikely(r != 0)) { | ||
499 | error_setg_errno(errp, -r, "Can't set device kick fd"); | ||
500 | - return false; | ||
501 | + return r; | ||
502 | } | ||
503 | |||
504 | event_notifier = &svq->hdev_call; | ||
505 | @@ -XXX,XX +XXX,XX @@ static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, | ||
506 | error_setg_errno(errp, -r, "Can't set device call fd"); | ||
507 | } | ||
508 | |||
509 | + return r; | ||
510 | +} | ||
511 | + | ||
512 | +/** | ||
513 | + * Unmap a SVQ area in the device | ||
514 | + */ | ||
515 | +static bool vhost_vdpa_svq_unmap_ring(struct vhost_vdpa *v, hwaddr iova, | ||
516 | + hwaddr size) | ||
517 | +{ | ||
518 | + int r; | ||
519 | + | ||
520 | + size = ROUND_UP(size, qemu_real_host_page_size); | ||
521 | + r = vhost_vdpa_dma_unmap(v, iova, size); | ||
522 | + return r == 0; | ||
523 | +} | ||
524 | + | ||
525 | +static bool vhost_vdpa_svq_unmap_rings(struct vhost_dev *dev, | ||
526 | + const VhostShadowVirtqueue *svq) | ||
527 | +{ | ||
528 | + struct vhost_vdpa *v = dev->opaque; | ||
529 | + struct vhost_vring_addr svq_addr; | ||
530 | + size_t device_size = vhost_svq_device_area_size(svq); | ||
531 | + size_t driver_size = vhost_svq_driver_area_size(svq); | ||
532 | + bool ok; | ||
533 | + | ||
534 | + vhost_svq_get_vring_addr(svq, &svq_addr); | ||
535 | + | ||
536 | + ok = vhost_vdpa_svq_unmap_ring(v, svq_addr.desc_user_addr, driver_size); | ||
537 | + if (unlikely(!ok)) { | ||
538 | + return false; | ||
539 | + } | ||
540 | + | ||
541 | + return vhost_vdpa_svq_unmap_ring(v, svq_addr.used_user_addr, device_size); | ||
542 | +} | ||
543 | + | ||
544 | +/** | ||
545 | + * Map the shadow virtqueue rings in the device | ||
546 | + * | ||
547 | + * @dev: The vhost device | ||
548 | + * @svq: The shadow virtqueue | ||
549 | + * @addr: Assigned IOVA addresses | ||
550 | + * @errp: Error pointer | ||
551 | + */ | ||
552 | +static bool vhost_vdpa_svq_map_rings(struct vhost_dev *dev, | ||
553 | + const VhostShadowVirtqueue *svq, | ||
554 | + struct vhost_vring_addr *addr, | ||
555 | + Error **errp) | ||
556 | +{ | ||
557 | + struct vhost_vdpa *v = dev->opaque; | ||
558 | + size_t device_size = vhost_svq_device_area_size(svq); | ||
559 | + size_t driver_size = vhost_svq_driver_area_size(svq); | ||
560 | + int r; | ||
561 | + | ||
562 | + ERRP_GUARD(); | ||
563 | + vhost_svq_get_vring_addr(svq, addr); | ||
564 | + | ||
565 | + r = vhost_vdpa_dma_map(v, addr->desc_user_addr, driver_size, | ||
566 | + (void *)(uintptr_t)addr->desc_user_addr, true); | ||
567 | + if (unlikely(r != 0)) { | ||
568 | + error_setg_errno(errp, -r, "Cannot create vq driver region: "); | ||
569 | + return false; | ||
570 | + } | ||
571 | + | ||
572 | + r = vhost_vdpa_dma_map(v, addr->used_user_addr, device_size, | ||
573 | + (void *)(intptr_t)addr->used_user_addr, false); | ||
574 | + if (unlikely(r != 0)) { | ||
575 | + error_setg_errno(errp, -r, "Cannot create vq device region: "); | ||
576 | + } | ||
577 | + | ||
578 | + return r == 0; | ||
579 | +} | ||
580 | + | ||
581 | +static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, | ||
582 | + VhostShadowVirtqueue *svq, unsigned idx, | ||
583 | + Error **errp) | ||
584 | +{ | ||
585 | + uint16_t vq_index = dev->vq_index + idx; | ||
586 | + struct vhost_vring_state s = { | ||
587 | + .index = vq_index, | ||
588 | + }; | ||
589 | + int r; | ||
590 | + | ||
591 | + r = vhost_vdpa_set_dev_vring_base(dev, &s); | ||
592 | + if (unlikely(r)) { | ||
593 | + error_setg_errno(errp, -r, "Cannot set vring base"); | ||
594 | + return false; | ||
595 | + } | ||
596 | + | ||
597 | + r = vhost_vdpa_svq_set_fds(dev, svq, idx, errp); | ||
598 | return r == 0; | ||
599 | } | ||
600 | |||
601 | @@ -XXX,XX +XXX,XX @@ static bool vhost_vdpa_svqs_start(struct vhost_dev *dev) | ||
602 | } | ||
603 | |||
604 | for (i = 0; i < v->shadow_vqs->len; ++i) { | ||
605 | + VirtQueue *vq = virtio_get_queue(dev->vdev, dev->vq_index + i); | ||
606 | VhostShadowVirtqueue *svq = g_ptr_array_index(v->shadow_vqs, i); | ||
607 | + struct vhost_vring_addr addr = { | ||
608 | + .index = i, | ||
609 | + }; | ||
610 | + int r; | ||
611 | bool ok = vhost_vdpa_svq_setup(dev, svq, i, &err); | ||
612 | if (unlikely(!ok)) { | ||
613 | - error_reportf_err(err, "Cannot setup SVQ %u: ", i); | ||
614 | + goto err; | ||
615 | + } | ||
616 | + | ||
617 | + vhost_svq_start(svq, dev->vdev, vq); | ||
618 | + ok = vhost_vdpa_svq_map_rings(dev, svq, &addr, &err); | ||
619 | + if (unlikely(!ok)) { | ||
620 | + goto err_map; | ||
621 | + } | ||
622 | + | ||
623 | + /* Override vring GPA set by vhost subsystem */ | ||
624 | + r = vhost_vdpa_set_vring_dev_addr(dev, &addr); | ||
625 | + if (unlikely(r != 0)) { | ||
626 | + error_setg_errno(&err, -r, "Cannot set device address"); | ||
627 | + goto err_set_addr; | ||
628 | + } | ||
629 | + } | ||
630 | + | ||
631 | + return true; | ||
632 | + | ||
633 | +err_set_addr: | ||
634 | + vhost_vdpa_svq_unmap_rings(dev, g_ptr_array_index(v->shadow_vqs, i)); | ||
635 | + | ||
636 | +err_map: | ||
637 | + vhost_svq_stop(g_ptr_array_index(v->shadow_vqs, i)); | ||
638 | + | ||
639 | +err: | ||
640 | + error_reportf_err(err, "Cannot setup SVQ %u: ", i); | ||
641 | + for (unsigned j = 0; j < i; ++j) { | ||
642 | + VhostShadowVirtqueue *svq = g_ptr_array_index(v->shadow_vqs, j); | ||
643 | + vhost_vdpa_svq_unmap_rings(dev, svq); | ||
644 | + vhost_svq_stop(svq); | ||
645 | + } | ||
646 | + | ||
647 | + return false; | ||
648 | +} | ||
649 | + | ||
650 | +static bool vhost_vdpa_svqs_stop(struct vhost_dev *dev) | ||
651 | +{ | ||
652 | + struct vhost_vdpa *v = dev->opaque; | ||
653 | + | ||
654 | + if (!v->shadow_vqs) { | ||
655 | + return true; | ||
656 | + } | ||
657 | + | ||
658 | + for (unsigned i = 0; i < v->shadow_vqs->len; ++i) { | ||
659 | + VhostShadowVirtqueue *svq = g_ptr_array_index(v->shadow_vqs, i); | ||
660 | + bool ok = vhost_vdpa_svq_unmap_rings(dev, svq); | ||
661 | + if (unlikely(!ok)) { | ||
662 | return false; | ||
33 | } | 663 | } |
34 | } | 664 | } |
35 | 665 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_dev_start(struct vhost_dev *dev, bool started) | |
36 | - | 666 | } |
37 | - /* if too small buffer, then expand it */ | 667 | vhost_vdpa_set_vring_ready(dev); |
38 | - if (size < MIN_BUF_SIZE) { | 668 | } else { |
39 | - memcpy(buf1, buf, size); | 669 | + ok = vhost_vdpa_svqs_stop(dev); |
40 | - memset(buf1 + size, 0, MIN_BUF_SIZE - size); | 670 | + if (unlikely(!ok)) { |
41 | - buf = buf1; | 671 | + return -1; |
42 | - size = MIN_BUF_SIZE; | 672 | + } |
43 | - } | 673 | vhost_vdpa_host_notifiers_uninit(dev, dev->nvqs); |
44 | - | 674 | } |
45 | index = s->curpag << 8; | 675 | |
46 | if (index >= NE2000_PMEM_END) { | ||
47 | index = s->start; | ||
48 | -- | 676 | -- |
49 | 2.7.4 | 677 | 2.7.4 |
678 | |||
679 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | This iova tree function allows it to look for a hole in allocated |
4 | QEMU networking codes, remove the same logic in the NIC codes. | 4 | regions and return a totally new translation for a given translated |
5 | 5 | address. | |
6 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | 6 | |
7 | It's usage is mainly to allow devices to access qemu address space, | ||
8 | remapping guest's one into a new iova space where qemu can add chunks of | ||
9 | addresses. | ||
10 | |||
11 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
12 | Reviewed-by: Peter Xu <peterx@redhat.com> | ||
13 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 14 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
8 | --- | 15 | --- |
9 | hw/net/sunhme.c | 11 ----------- | 16 | include/qemu/iova-tree.h | 18 +++++++ |
10 | 1 file changed, 11 deletions(-) | 17 | util/iova-tree.c | 136 +++++++++++++++++++++++++++++++++++++++++++++++ |
11 | 18 | 2 files changed, 154 insertions(+) | |
12 | diff --git a/hw/net/sunhme.c b/hw/net/sunhme.c | 19 | |
20 | diff --git a/include/qemu/iova-tree.h b/include/qemu/iova-tree.h | ||
13 | index XXXXXXX..XXXXXXX 100644 | 21 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/hw/net/sunhme.c | 22 | --- a/include/qemu/iova-tree.h |
15 | +++ b/hw/net/sunhme.c | 23 | +++ b/include/qemu/iova-tree.h |
16 | @@ -XXX,XX +XXX,XX @@ static inline void sunhme_set_rx_ring_nr(SunHMEState *s, int i) | 24 | @@ -XXX,XX +XXX,XX @@ |
17 | s->erxregs[HME_ERXI_RING >> 2] = ring; | 25 | #define IOVA_OK (0) |
26 | #define IOVA_ERR_INVALID (-1) /* Invalid parameters */ | ||
27 | #define IOVA_ERR_OVERLAP (-2) /* IOVA range overlapped */ | ||
28 | +#define IOVA_ERR_NOMEM (-3) /* Cannot allocate */ | ||
29 | |||
30 | typedef struct IOVATree IOVATree; | ||
31 | typedef struct DMAMap { | ||
32 | @@ -XXX,XX +XXX,XX @@ const DMAMap *iova_tree_find_address(const IOVATree *tree, hwaddr iova); | ||
33 | void iova_tree_foreach(IOVATree *tree, iova_tree_iterator iterator); | ||
34 | |||
35 | /** | ||
36 | + * iova_tree_alloc_map: | ||
37 | + * | ||
38 | + * @tree: the iova tree to allocate from | ||
39 | + * @map: the new map (as translated addr & size) to allocate in the iova region | ||
40 | + * @iova_begin: the minimum address of the allocation | ||
41 | + * @iova_end: the maximum addressable direction of the allocation | ||
42 | + * | ||
43 | + * Allocates a new region of a given size, between iova_min and iova_max. | ||
44 | + * | ||
45 | + * Return: Same as iova_tree_insert, but cannot overlap and can return error if | ||
46 | + * iova tree is out of free contiguous range. The caller gets the assigned iova | ||
47 | + * in map->iova. | ||
48 | + */ | ||
49 | +int iova_tree_alloc_map(IOVATree *tree, DMAMap *map, hwaddr iova_begin, | ||
50 | + hwaddr iova_end); | ||
51 | + | ||
52 | +/** | ||
53 | * iova_tree_destroy: | ||
54 | * | ||
55 | * @tree: the iova tree to destroy | ||
56 | diff --git a/util/iova-tree.c b/util/iova-tree.c | ||
57 | index XXXXXXX..XXXXXXX 100644 | ||
58 | --- a/util/iova-tree.c | ||
59 | +++ b/util/iova-tree.c | ||
60 | @@ -XXX,XX +XXX,XX @@ struct IOVATree { | ||
61 | GTree *tree; | ||
62 | }; | ||
63 | |||
64 | +/* Args to pass to iova_tree_alloc foreach function. */ | ||
65 | +struct IOVATreeAllocArgs { | ||
66 | + /* Size of the desired allocation */ | ||
67 | + size_t new_size; | ||
68 | + | ||
69 | + /* The minimum address allowed in the allocation */ | ||
70 | + hwaddr iova_begin; | ||
71 | + | ||
72 | + /* Map at the left of the hole, can be NULL if "this" is first one */ | ||
73 | + const DMAMap *prev; | ||
74 | + | ||
75 | + /* Map at the right of the hole, can be NULL if "prev" is the last one */ | ||
76 | + const DMAMap *this; | ||
77 | + | ||
78 | + /* If found, we fill in the IOVA here */ | ||
79 | + hwaddr iova_result; | ||
80 | + | ||
81 | + /* Whether have we found a valid IOVA */ | ||
82 | + bool iova_found; | ||
83 | +}; | ||
84 | + | ||
85 | +/** | ||
86 | + * Iterate args to the next hole | ||
87 | + * | ||
88 | + * @args: The alloc arguments | ||
89 | + * @next: The next mapping in the tree. Can be NULL to signal the last one | ||
90 | + */ | ||
91 | +static void iova_tree_alloc_args_iterate(struct IOVATreeAllocArgs *args, | ||
92 | + const DMAMap *next) | ||
93 | +{ | ||
94 | + args->prev = args->this; | ||
95 | + args->this = next; | ||
96 | +} | ||
97 | + | ||
98 | static int iova_tree_compare(gconstpointer a, gconstpointer b, gpointer data) | ||
99 | { | ||
100 | const DMAMap *m1 = a, *m2 = b; | ||
101 | @@ -XXX,XX +XXX,XX @@ int iova_tree_remove(IOVATree *tree, const DMAMap *map) | ||
102 | return IOVA_OK; | ||
18 | } | 103 | } |
19 | 104 | ||
20 | -#define MIN_BUF_SIZE 60 | 105 | +/** |
21 | - | 106 | + * Try to find an unallocated IOVA range between prev and this elements. |
22 | static ssize_t sunhme_receive(NetClientState *nc, const uint8_t *buf, | 107 | + * |
23 | size_t size) | 108 | + * @args: Arguments to allocation |
109 | + * | ||
110 | + * Cases: | ||
111 | + * | ||
112 | + * (1) !prev, !this: No entries allocated, always succeed | ||
113 | + * | ||
114 | + * (2) !prev, this: We're iterating at the 1st element. | ||
115 | + * | ||
116 | + * (3) prev, !this: We're iterating at the last element. | ||
117 | + * | ||
118 | + * (4) prev, this: this is the most common case, we'll try to find a hole | ||
119 | + * between "prev" and "this" mapping. | ||
120 | + * | ||
121 | + * Note that this function assumes the last valid iova is HWADDR_MAX, but it | ||
122 | + * searches linearly so it's easy to discard the result if it's not the case. | ||
123 | + */ | ||
124 | +static void iova_tree_alloc_map_in_hole(struct IOVATreeAllocArgs *args) | ||
125 | +{ | ||
126 | + const DMAMap *prev = args->prev, *this = args->this; | ||
127 | + uint64_t hole_start, hole_last; | ||
128 | + | ||
129 | + if (this && this->iova + this->size < args->iova_begin) { | ||
130 | + return; | ||
131 | + } | ||
132 | + | ||
133 | + hole_start = MAX(prev ? prev->iova + prev->size + 1 : 0, args->iova_begin); | ||
134 | + hole_last = this ? this->iova : HWADDR_MAX; | ||
135 | + | ||
136 | + if (hole_last - hole_start > args->new_size) { | ||
137 | + args->iova_result = hole_start; | ||
138 | + args->iova_found = true; | ||
139 | + } | ||
140 | +} | ||
141 | + | ||
142 | +/** | ||
143 | + * Foreach dma node in the tree, compare if there is a hole with its previous | ||
144 | + * node (or minimum iova address allowed) and the node. | ||
145 | + * | ||
146 | + * @key: Node iterating | ||
147 | + * @value: Node iterating | ||
148 | + * @pargs: Struct to communicate with the outside world | ||
149 | + * | ||
150 | + * Return: false to keep iterating, true if needs break. | ||
151 | + */ | ||
152 | +static gboolean iova_tree_alloc_traverse(gpointer key, gpointer value, | ||
153 | + gpointer pargs) | ||
154 | +{ | ||
155 | + struct IOVATreeAllocArgs *args = pargs; | ||
156 | + DMAMap *node = value; | ||
157 | + | ||
158 | + assert(key == value); | ||
159 | + | ||
160 | + iova_tree_alloc_args_iterate(args, node); | ||
161 | + iova_tree_alloc_map_in_hole(args); | ||
162 | + return args->iova_found; | ||
163 | +} | ||
164 | + | ||
165 | +int iova_tree_alloc_map(IOVATree *tree, DMAMap *map, hwaddr iova_begin, | ||
166 | + hwaddr iova_last) | ||
167 | +{ | ||
168 | + struct IOVATreeAllocArgs args = { | ||
169 | + .new_size = map->size, | ||
170 | + .iova_begin = iova_begin, | ||
171 | + }; | ||
172 | + | ||
173 | + if (unlikely(iova_last < iova_begin)) { | ||
174 | + return IOVA_ERR_INVALID; | ||
175 | + } | ||
176 | + | ||
177 | + /* | ||
178 | + * Find a valid hole for the mapping | ||
179 | + * | ||
180 | + * Assuming low iova_begin, so no need to do a binary search to | ||
181 | + * locate the first node. | ||
182 | + * | ||
183 | + * TODO: Replace all this with g_tree_node_first/next/last when available | ||
184 | + * (from glib since 2.68). To do it with g_tree_foreach complicates the | ||
185 | + * code a lot. | ||
186 | + * | ||
187 | + */ | ||
188 | + g_tree_foreach(tree->tree, iova_tree_alloc_traverse, &args); | ||
189 | + if (!args.iova_found) { | ||
190 | + /* | ||
191 | + * Either tree is empty or the last hole is still not checked. | ||
192 | + * g_tree_foreach does not compare (last, iova_last] range, so we check | ||
193 | + * it here. | ||
194 | + */ | ||
195 | + iova_tree_alloc_args_iterate(&args, NULL); | ||
196 | + iova_tree_alloc_map_in_hole(&args); | ||
197 | + } | ||
198 | + | ||
199 | + if (!args.iova_found || args.iova_result + map->size > iova_last) { | ||
200 | + return IOVA_ERR_NOMEM; | ||
201 | + } | ||
202 | + | ||
203 | + map->iova = args.iova_result; | ||
204 | + return iova_tree_insert(tree, map); | ||
205 | +} | ||
206 | + | ||
207 | void iova_tree_destroy(IOVATree *tree) | ||
24 | { | 208 | { |
25 | @@ -XXX,XX +XXX,XX @@ static ssize_t sunhme_receive(NetClientState *nc, const uint8_t *buf, | 209 | g_tree_destroy(tree->tree); |
26 | dma_addr_t rb, addr; | ||
27 | uint32_t intstatus, status, buffer, buffersize, sum; | ||
28 | uint16_t csum; | ||
29 | - uint8_t buf1[60]; | ||
30 | int nr, cr, len, rxoffset, csum_offset; | ||
31 | |||
32 | trace_sunhme_rx_incoming(size); | ||
33 | @@ -XXX,XX +XXX,XX @@ static ssize_t sunhme_receive(NetClientState *nc, const uint8_t *buf, | ||
34 | |||
35 | trace_sunhme_rx_filter_accept(); | ||
36 | |||
37 | - /* If too small buffer, then expand it */ | ||
38 | - if (size < MIN_BUF_SIZE) { | ||
39 | - memcpy(buf1, buf, size); | ||
40 | - memset(buf1 + size, 0, MIN_BUF_SIZE - size); | ||
41 | - buf = buf1; | ||
42 | - size = MIN_BUF_SIZE; | ||
43 | - } | ||
44 | - | ||
45 | rb = s->erxregs[HME_ERXI_RING >> 2] & HME_ERXI_RING_ADDR; | ||
46 | nr = sunhme_get_rx_ring_count(s); | ||
47 | cr = sunhme_get_rx_ring_nr(s); | ||
48 | -- | 210 | -- |
49 | 2.7.4 | 211 | 2.7.4 |
212 | |||
213 | diff view generated by jsdifflib |
1 | From: Laurent Vivier <lvivier@redhat.com> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Reviewed-by: David Gibson <david@gibson.dropbear.id.au> | 3 | This function does the reverse operation of iova_tree_find: To look for |
4 | Signed-off-by: Laurent Vivier <lvivier@redhat.com> | 4 | a mapping that match a translated address so we can do the reverse. |
5 | |||
6 | This have linear complexity instead of logarithmic, but it supports | ||
7 | overlapping HVA. Future developments could reduce it. | ||
8 | |||
9 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
10 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
5 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 11 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
6 | --- | 12 | --- |
7 | net/socket.c | 28 ++++++++++++++++++++-------- | 13 | include/qemu/iova-tree.h | 20 +++++++++++++++++++- |
8 | 1 file changed, 20 insertions(+), 8 deletions(-) | 14 | util/iova-tree.c | 34 ++++++++++++++++++++++++++++++++++ |
15 | 2 files changed, 53 insertions(+), 1 deletion(-) | ||
9 | 16 | ||
10 | diff --git a/net/socket.c b/net/socket.c | 17 | diff --git a/include/qemu/iova-tree.h b/include/qemu/iova-tree.h |
11 | index XXXXXXX..XXXXXXX 100644 | 18 | index XXXXXXX..XXXXXXX 100644 |
12 | --- a/net/socket.c | 19 | --- a/include/qemu/iova-tree.h |
13 | +++ b/net/socket.c | 20 | +++ b/include/qemu/iova-tree.h |
14 | @@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init_stream(NetClientState *peer, | 21 | @@ -XXX,XX +XXX,XX @@ int iova_tree_remove(IOVATree *tree, const DMAMap *map); |
15 | return s; | 22 | * @tree: the iova tree to search from |
23 | * @map: the mapping to search | ||
24 | * | ||
25 | - * Search for a mapping in the iova tree that overlaps with the | ||
26 | + * Search for a mapping in the iova tree that iova overlaps with the | ||
27 | * mapping range specified. Only the first found mapping will be | ||
28 | * returned. | ||
29 | * | ||
30 | @@ -XXX,XX +XXX,XX @@ int iova_tree_remove(IOVATree *tree, const DMAMap *map); | ||
31 | const DMAMap *iova_tree_find(const IOVATree *tree, const DMAMap *map); | ||
32 | |||
33 | /** | ||
34 | + * iova_tree_find_iova: | ||
35 | + * | ||
36 | + * @tree: the iova tree to search from | ||
37 | + * @map: the mapping to search | ||
38 | + * | ||
39 | + * Search for a mapping in the iova tree that translated_addr overlaps with the | ||
40 | + * mapping range specified. Only the first found mapping will be | ||
41 | + * returned. | ||
42 | + * | ||
43 | + * Return: DMAMap pointer if found, or NULL if not found. Note that | ||
44 | + * the returned DMAMap pointer is maintained internally. User should | ||
45 | + * only read the content but never modify or free the content. Also, | ||
46 | + * user is responsible to make sure the pointer is valid (say, no | ||
47 | + * concurrent deletion in progress). | ||
48 | + */ | ||
49 | +const DMAMap *iova_tree_find_iova(const IOVATree *tree, const DMAMap *map); | ||
50 | + | ||
51 | +/** | ||
52 | * iova_tree_find_address: | ||
53 | * | ||
54 | * @tree: the iova tree to search from | ||
55 | diff --git a/util/iova-tree.c b/util/iova-tree.c | ||
56 | index XXXXXXX..XXXXXXX 100644 | ||
57 | --- a/util/iova-tree.c | ||
58 | +++ b/util/iova-tree.c | ||
59 | @@ -XXX,XX +XXX,XX @@ struct IOVATreeAllocArgs { | ||
60 | bool iova_found; | ||
61 | }; | ||
62 | |||
63 | +typedef struct IOVATreeFindIOVAArgs { | ||
64 | + const DMAMap *needle; | ||
65 | + const DMAMap *result; | ||
66 | +} IOVATreeFindIOVAArgs; | ||
67 | + | ||
68 | /** | ||
69 | * Iterate args to the next hole | ||
70 | * | ||
71 | @@ -XXX,XX +XXX,XX @@ const DMAMap *iova_tree_find(const IOVATree *tree, const DMAMap *map) | ||
72 | return g_tree_lookup(tree->tree, map); | ||
16 | } | 73 | } |
17 | 74 | ||
18 | +static int net_socket_fd_check(int fd, Error **errp) | 75 | +static gboolean iova_tree_find_address_iterator(gpointer key, gpointer value, |
76 | + gpointer data) | ||
19 | +{ | 77 | +{ |
20 | + int so_type, optlen = sizeof(so_type); | 78 | + const DMAMap *map = key; |
79 | + IOVATreeFindIOVAArgs *args = data; | ||
80 | + const DMAMap *needle; | ||
21 | + | 81 | + |
22 | + if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, | 82 | + g_assert(key == value); |
23 | + (socklen_t *)&optlen) < 0) { | 83 | + |
24 | + error_setg(errp, "can't get socket option SO_TYPE"); | 84 | + needle = args->needle; |
25 | + return -1; | 85 | + if (map->translated_addr + map->size < needle->translated_addr || |
86 | + needle->translated_addr + needle->size < map->translated_addr) { | ||
87 | + return false; | ||
26 | + } | 88 | + } |
27 | + if (so_type != SOCK_DGRAM && so_type != SOCK_STREAM) { | 89 | + |
28 | + error_setg(errp, "socket type=%d for fd=%d must be either" | 90 | + args->result = map; |
29 | + " SOCK_DGRAM or SOCK_STREAM", so_type, fd); | 91 | + return true; |
30 | + return -1; | ||
31 | + } | ||
32 | + return so_type; | ||
33 | +} | 92 | +} |
34 | + | 93 | + |
35 | static NetSocketState *net_socket_fd_init(NetClientState *peer, | 94 | +const DMAMap *iova_tree_find_iova(const IOVATree *tree, const DMAMap *map) |
36 | const char *model, const char *name, | 95 | +{ |
37 | int fd, int is_connected, | 96 | + IOVATreeFindIOVAArgs args = { |
38 | const char *mc, Error **errp) | 97 | + .needle = map, |
98 | + }; | ||
99 | + | ||
100 | + g_tree_foreach(tree->tree, iova_tree_find_address_iterator, &args); | ||
101 | + return args.result; | ||
102 | +} | ||
103 | + | ||
104 | const DMAMap *iova_tree_find_address(const IOVATree *tree, hwaddr iova) | ||
39 | { | 105 | { |
40 | - int so_type = -1, optlen=sizeof(so_type); | 106 | const DMAMap map = { .iova = iova, .size = 0 }; |
41 | + int so_type; | ||
42 | |||
43 | - if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, | ||
44 | - (socklen_t *)&optlen)< 0) { | ||
45 | - error_setg(errp, "can't get socket option SO_TYPE"); | ||
46 | + so_type = net_socket_fd_check(fd, errp); | ||
47 | + if (so_type < 0) { | ||
48 | close(fd); | ||
49 | return NULL; | ||
50 | } | ||
51 | @@ -XXX,XX +XXX,XX @@ static NetSocketState *net_socket_fd_init(NetClientState *peer, | ||
52 | mc, errp); | ||
53 | case SOCK_STREAM: | ||
54 | return net_socket_fd_init_stream(peer, model, name, fd, is_connected); | ||
55 | - default: | ||
56 | - error_setg(errp, "socket type=%d for fd=%d must be either" | ||
57 | - " SOCK_DGRAM or SOCK_STREAM", so_type, fd); | ||
58 | - close(fd); | ||
59 | } | ||
60 | return NULL; | ||
61 | } | ||
62 | -- | 107 | -- |
63 | 2.7.4 | 108 | 2.7.4 |
109 | |||
110 | diff view generated by jsdifflib |
1 | From: Laurent Vivier <lvivier@redhat.com> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Use directly net_socket_fd_init_stream() and net_socket_fd_init_dgram() | 3 | This tree is able to look for a translated address from an IOVA address. |
4 | when the socket type is already known. | ||
5 | 4 | ||
6 | Reviewed-by: David Gibson <david@gibson.dropbear.id.au> | 5 | At first glance it is similar to util/iova-tree. However, SVQ working on |
7 | Signed-off-by: Laurent Vivier <lvivier@redhat.com> | 6 | devices with limited IOVA space need more capabilities, like allocating |
7 | IOVA chunks or performing reverse translations (qemu addresses to iova). | ||
8 | |||
9 | The allocation capability, as "assign a free IOVA address to this chunk | ||
10 | of memory in qemu's address space" allows shadow virtqueue to create a | ||
11 | new address space that is not restricted by guest's addressable one, so | ||
12 | we can allocate shadow vqs vrings outside of it. | ||
13 | |||
14 | It duplicates the tree so it can search efficiently in both directions, | ||
15 | and it will signal overlap if iova or the translated address is present | ||
16 | in any tree. | ||
17 | |||
18 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
19 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
8 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 20 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
9 | --- | 21 | --- |
10 | net/socket.c | 6 +++--- | 22 | hw/virtio/meson.build | 2 +- |
11 | 1 file changed, 3 insertions(+), 3 deletions(-) | 23 | hw/virtio/vhost-iova-tree.c | 110 ++++++++++++++++++++++++++++++++++++++++++++ |
24 | hw/virtio/vhost-iova-tree.h | 27 +++++++++++ | ||
25 | 3 files changed, 138 insertions(+), 1 deletion(-) | ||
26 | create mode 100644 hw/virtio/vhost-iova-tree.c | ||
27 | create mode 100644 hw/virtio/vhost-iova-tree.h | ||
12 | 28 | ||
13 | diff --git a/net/socket.c b/net/socket.c | 29 | diff --git a/hw/virtio/meson.build b/hw/virtio/meson.build |
14 | index XXXXXXX..XXXXXXX 100644 | 30 | index XXXXXXX..XXXXXXX 100644 |
15 | --- a/net/socket.c | 31 | --- a/hw/virtio/meson.build |
16 | +++ b/net/socket.c | 32 | +++ b/hw/virtio/meson.build |
17 | @@ -XXX,XX +XXX,XX @@ static int net_socket_connect_init(NetClientState *peer, | 33 | @@ -XXX,XX +XXX,XX @@ softmmu_ss.add(when: 'CONFIG_ALL', if_true: files('vhost-stub.c')) |
18 | break; | 34 | |
19 | } | 35 | virtio_ss = ss.source_set() |
20 | } | 36 | virtio_ss.add(files('virtio.c')) |
21 | - s = net_socket_fd_init(peer, model, name, fd, connected, NULL, errp); | 37 | -virtio_ss.add(when: 'CONFIG_VHOST', if_true: files('vhost.c', 'vhost-backend.c', 'vhost-shadow-virtqueue.c')) |
22 | + s = net_socket_fd_init_stream(peer, model, name, fd, connected); | 38 | +virtio_ss.add(when: 'CONFIG_VHOST', if_true: files('vhost.c', 'vhost-backend.c', 'vhost-shadow-virtqueue.c', 'vhost-iova-tree.c')) |
23 | if (!s) { | 39 | virtio_ss.add(when: 'CONFIG_VHOST_USER', if_true: files('vhost-user.c')) |
24 | return -1; | 40 | virtio_ss.add(when: 'CONFIG_VHOST_VDPA', if_true: files('vhost-vdpa.c')) |
25 | } | 41 | virtio_ss.add(when: 'CONFIG_VIRTIO_BALLOON', if_true: files('virtio-balloon.c')) |
26 | @@ -XXX,XX +XXX,XX @@ static int net_socket_mcast_init(NetClientState *peer, | 42 | diff --git a/hw/virtio/vhost-iova-tree.c b/hw/virtio/vhost-iova-tree.c |
27 | return -1; | 43 | new file mode 100644 |
28 | } | 44 | index XXXXXXX..XXXXXXX |
29 | 45 | --- /dev/null | |
30 | - s = net_socket_fd_init(peer, model, name, fd, 0, NULL, errp); | 46 | +++ b/hw/virtio/vhost-iova-tree.c |
31 | + s = net_socket_fd_init_dgram(peer, model, name, fd, 0, NULL, errp); | 47 | @@ -XXX,XX +XXX,XX @@ |
32 | if (!s) { | 48 | +/* |
33 | return -1; | 49 | + * vhost software live migration iova tree |
34 | } | 50 | + * |
35 | @@ -XXX,XX +XXX,XX @@ static int net_socket_udp_init(NetClientState *peer, | 51 | + * SPDX-FileCopyrightText: Red Hat, Inc. 2021 |
36 | } | 52 | + * SPDX-FileContributor: Author: Eugenio Pérez <eperezma@redhat.com> |
37 | qemu_socket_set_nonblock(fd); | 53 | + * |
38 | 54 | + * SPDX-License-Identifier: GPL-2.0-or-later | |
39 | - s = net_socket_fd_init(peer, model, name, fd, 0, NULL, errp); | 55 | + */ |
40 | + s = net_socket_fd_init_dgram(peer, model, name, fd, 0, NULL, errp); | 56 | + |
41 | if (!s) { | 57 | +#include "qemu/osdep.h" |
42 | return -1; | 58 | +#include "qemu/iova-tree.h" |
43 | } | 59 | +#include "vhost-iova-tree.h" |
60 | + | ||
61 | +#define iova_min_addr qemu_real_host_page_size | ||
62 | + | ||
63 | +/** | ||
64 | + * VhostIOVATree, able to: | ||
65 | + * - Translate iova address | ||
66 | + * - Reverse translate iova address (from translated to iova) | ||
67 | + * - Allocate IOVA regions for translated range (linear operation) | ||
68 | + */ | ||
69 | +struct VhostIOVATree { | ||
70 | + /* First addressable iova address in the device */ | ||
71 | + uint64_t iova_first; | ||
72 | + | ||
73 | + /* Last addressable iova address in the device */ | ||
74 | + uint64_t iova_last; | ||
75 | + | ||
76 | + /* IOVA address to qemu memory maps. */ | ||
77 | + IOVATree *iova_taddr_map; | ||
78 | +}; | ||
79 | + | ||
80 | +/** | ||
81 | + * Create a new IOVA tree | ||
82 | + * | ||
83 | + * Returns the new IOVA tree | ||
84 | + */ | ||
85 | +VhostIOVATree *vhost_iova_tree_new(hwaddr iova_first, hwaddr iova_last) | ||
86 | +{ | ||
87 | + VhostIOVATree *tree = g_new(VhostIOVATree, 1); | ||
88 | + | ||
89 | + /* Some devices do not like 0 addresses */ | ||
90 | + tree->iova_first = MAX(iova_first, iova_min_addr); | ||
91 | + tree->iova_last = iova_last; | ||
92 | + | ||
93 | + tree->iova_taddr_map = iova_tree_new(); | ||
94 | + return tree; | ||
95 | +} | ||
96 | + | ||
97 | +/** | ||
98 | + * Delete an iova tree | ||
99 | + */ | ||
100 | +void vhost_iova_tree_delete(VhostIOVATree *iova_tree) | ||
101 | +{ | ||
102 | + iova_tree_destroy(iova_tree->iova_taddr_map); | ||
103 | + g_free(iova_tree); | ||
104 | +} | ||
105 | + | ||
106 | +/** | ||
107 | + * Find the IOVA address stored from a memory address | ||
108 | + * | ||
109 | + * @tree: The iova tree | ||
110 | + * @map: The map with the memory address | ||
111 | + * | ||
112 | + * Return the stored mapping, or NULL if not found. | ||
113 | + */ | ||
114 | +const DMAMap *vhost_iova_tree_find_iova(const VhostIOVATree *tree, | ||
115 | + const DMAMap *map) | ||
116 | +{ | ||
117 | + return iova_tree_find_iova(tree->iova_taddr_map, map); | ||
118 | +} | ||
119 | + | ||
120 | +/** | ||
121 | + * Allocate a new mapping | ||
122 | + * | ||
123 | + * @tree: The iova tree | ||
124 | + * @map: The iova map | ||
125 | + * | ||
126 | + * Returns: | ||
127 | + * - IOVA_OK if the map fits in the container | ||
128 | + * - IOVA_ERR_INVALID if the map does not make sense (like size overflow) | ||
129 | + * - IOVA_ERR_NOMEM if tree cannot allocate more space. | ||
130 | + * | ||
131 | + * It returns assignated iova in map->iova if return value is VHOST_DMA_MAP_OK. | ||
132 | + */ | ||
133 | +int vhost_iova_tree_map_alloc(VhostIOVATree *tree, DMAMap *map) | ||
134 | +{ | ||
135 | + /* Some vhost devices do not like addr 0. Skip first page */ | ||
136 | + hwaddr iova_first = tree->iova_first ?: qemu_real_host_page_size; | ||
137 | + | ||
138 | + if (map->translated_addr + map->size < map->translated_addr || | ||
139 | + map->perm == IOMMU_NONE) { | ||
140 | + return IOVA_ERR_INVALID; | ||
141 | + } | ||
142 | + | ||
143 | + /* Allocate a node in IOVA address */ | ||
144 | + return iova_tree_alloc_map(tree->iova_taddr_map, map, iova_first, | ||
145 | + tree->iova_last); | ||
146 | +} | ||
147 | + | ||
148 | +/** | ||
149 | + * Remove existing mappings from iova tree | ||
150 | + * | ||
151 | + * @iova_tree: The vhost iova tree | ||
152 | + * @map: The map to remove | ||
153 | + */ | ||
154 | +void vhost_iova_tree_remove(VhostIOVATree *iova_tree, const DMAMap *map) | ||
155 | +{ | ||
156 | + iova_tree_remove(iova_tree->iova_taddr_map, map); | ||
157 | +} | ||
158 | diff --git a/hw/virtio/vhost-iova-tree.h b/hw/virtio/vhost-iova-tree.h | ||
159 | new file mode 100644 | ||
160 | index XXXXXXX..XXXXXXX | ||
161 | --- /dev/null | ||
162 | +++ b/hw/virtio/vhost-iova-tree.h | ||
163 | @@ -XXX,XX +XXX,XX @@ | ||
164 | +/* | ||
165 | + * vhost software live migration iova tree | ||
166 | + * | ||
167 | + * SPDX-FileCopyrightText: Red Hat, Inc. 2021 | ||
168 | + * SPDX-FileContributor: Author: Eugenio Pérez <eperezma@redhat.com> | ||
169 | + * | ||
170 | + * SPDX-License-Identifier: GPL-2.0-or-later | ||
171 | + */ | ||
172 | + | ||
173 | +#ifndef HW_VIRTIO_VHOST_IOVA_TREE_H | ||
174 | +#define HW_VIRTIO_VHOST_IOVA_TREE_H | ||
175 | + | ||
176 | +#include "qemu/iova-tree.h" | ||
177 | +#include "exec/memory.h" | ||
178 | + | ||
179 | +typedef struct VhostIOVATree VhostIOVATree; | ||
180 | + | ||
181 | +VhostIOVATree *vhost_iova_tree_new(uint64_t iova_first, uint64_t iova_last); | ||
182 | +void vhost_iova_tree_delete(VhostIOVATree *iova_tree); | ||
183 | +G_DEFINE_AUTOPTR_CLEANUP_FUNC(VhostIOVATree, vhost_iova_tree_delete); | ||
184 | + | ||
185 | +const DMAMap *vhost_iova_tree_find_iova(const VhostIOVATree *iova_tree, | ||
186 | + const DMAMap *map); | ||
187 | +int vhost_iova_tree_map_alloc(VhostIOVATree *iova_tree, DMAMap *map); | ||
188 | +void vhost_iova_tree_remove(VhostIOVATree *iova_tree, const DMAMap *map); | ||
189 | + | ||
190 | +#endif | ||
44 | -- | 191 | -- |
45 | 2.7.4 | 192 | 2.7.4 |
193 | |||
194 | diff view generated by jsdifflib |
1 | From: Akihiko Odaki <akihiko.odaki@daynix.com> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | The datasheet does not say what happens when interrupt was asserted | 3 | Use translations added in VhostIOVATree in SVQ. |
4 | (ICR.INT_ASSERT=1) and auto mask is *not* active. | 4 | |
5 | However, section of 13.3.27 the PCIe* GbE Controllers Open Source | 5 | Only introduce usage here, not allocation and deallocation. As with |
6 | Software Developer’s Manual, which were written for older devices, | 6 | previous patches, we use the dead code paths of shadow_vqs_enabled to |
7 | namely 631xESB/632xESB, 82563EB/82564EB, 82571EB/82572EI & | 7 | avoid commiting too many changes at once. These are impossible to take |
8 | 82573E/82573V/82573L, does say: | 8 | at the moment. |
9 | > If IMS = 0b, then the ICR register is always clear-on-read. If IMS is | 9 | |
10 | > not 0b, but some ICR bit is set where the corresponding IMS bit is not | 10 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> |
11 | > set, then a read does not clear the ICR register. For example, if | 11 | Acked-by: Michael S. Tsirkin <mst@redhat.com> |
12 | > IMS = 10101010b and ICR = 01010101b, then a read to the ICR register | ||
13 | > does not clear it. If IMS = 10101010b and ICR = 0101011b, then a read | ||
14 | > to the ICR register clears it entirely (ICR.INT_ASSERTED = 1b). | ||
15 | |||
16 | Linux does no longer activate auto mask since commit | ||
17 | 0a8047ac68e50e4ccbadcfc6b6b070805b976885 and the real hardware clears | ||
18 | ICR even in such a case so we also should do so. | ||
19 | |||
20 | Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=1707441 | ||
21 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> | ||
22 | Signed-off-by: Akihiko Odaki <akihiko.odaki@daynix.com> | ||
23 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 12 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
24 | --- | 13 | --- |
25 | hw/net/e1000e_core.c | 38 ++++++++++++++++++++++++++++++++------ | 14 | hw/virtio/vhost-shadow-virtqueue.c | 86 +++++++++++++++++++++++--- |
26 | hw/net/trace-events | 1 + | 15 | hw/virtio/vhost-shadow-virtqueue.h | 6 +- |
27 | 2 files changed, 33 insertions(+), 6 deletions(-) | 16 | hw/virtio/vhost-vdpa.c | 122 +++++++++++++++++++++++++++++++------ |
28 | 17 | include/hw/virtio/vhost-vdpa.h | 3 + | |
29 | diff --git a/hw/net/e1000e_core.c b/hw/net/e1000e_core.c | 18 | 4 files changed, 187 insertions(+), 30 deletions(-) |
19 | |||
20 | diff --git a/hw/virtio/vhost-shadow-virtqueue.c b/hw/virtio/vhost-shadow-virtqueue.c | ||
30 | index XXXXXXX..XXXXXXX 100644 | 21 | index XXXXXXX..XXXXXXX 100644 |
31 | --- a/hw/net/e1000e_core.c | 22 | --- a/hw/virtio/vhost-shadow-virtqueue.c |
32 | +++ b/hw/net/e1000e_core.c | 23 | +++ b/hw/virtio/vhost-shadow-virtqueue.c |
33 | @@ -XXX,XX +XXX,XX @@ e1000e_mac_icr_read(E1000ECore *core, int index) | 24 | @@ -XXX,XX +XXX,XX @@ static uint16_t vhost_svq_available_slots(const VhostShadowVirtqueue *svq) |
34 | e1000e_lower_interrupts(core, ICR, 0xffffffff); | 25 | return svq->vring.num - (svq->shadow_avail_idx - svq->shadow_used_idx); |
26 | } | ||
27 | |||
28 | -static void vhost_vring_write_descs(VhostShadowVirtqueue *svq, | ||
29 | +/** | ||
30 | + * Translate addresses between the qemu's virtual address and the SVQ IOVA | ||
31 | + * | ||
32 | + * @svq: Shadow VirtQueue | ||
33 | + * @vaddr: Translated IOVA addresses | ||
34 | + * @iovec: Source qemu's VA addresses | ||
35 | + * @num: Length of iovec and minimum length of vaddr | ||
36 | + */ | ||
37 | +static bool vhost_svq_translate_addr(const VhostShadowVirtqueue *svq, | ||
38 | + hwaddr *addrs, const struct iovec *iovec, | ||
39 | + size_t num) | ||
40 | +{ | ||
41 | + if (num == 0) { | ||
42 | + return true; | ||
43 | + } | ||
44 | + | ||
45 | + for (size_t i = 0; i < num; ++i) { | ||
46 | + DMAMap needle = { | ||
47 | + .translated_addr = (hwaddr)(uintptr_t)iovec[i].iov_base, | ||
48 | + .size = iovec[i].iov_len, | ||
49 | + }; | ||
50 | + Int128 needle_last, map_last; | ||
51 | + size_t off; | ||
52 | + | ||
53 | + const DMAMap *map = vhost_iova_tree_find_iova(svq->iova_tree, &needle); | ||
54 | + /* | ||
55 | + * Map cannot be NULL since iova map contains all guest space and | ||
56 | + * qemu already has a physical address mapped | ||
57 | + */ | ||
58 | + if (unlikely(!map)) { | ||
59 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
60 | + "Invalid address 0x%"HWADDR_PRIx" given by guest", | ||
61 | + needle.translated_addr); | ||
62 | + return false; | ||
63 | + } | ||
64 | + | ||
65 | + off = needle.translated_addr - map->translated_addr; | ||
66 | + addrs[i] = map->iova + off; | ||
67 | + | ||
68 | + needle_last = int128_add(int128_make64(needle.translated_addr), | ||
69 | + int128_make64(iovec[i].iov_len)); | ||
70 | + map_last = int128_make64(map->translated_addr + map->size); | ||
71 | + if (unlikely(int128_gt(needle_last, map_last))) { | ||
72 | + qemu_log_mask(LOG_GUEST_ERROR, | ||
73 | + "Guest buffer expands over iova range"); | ||
74 | + return false; | ||
75 | + } | ||
76 | + } | ||
77 | + | ||
78 | + return true; | ||
79 | +} | ||
80 | + | ||
81 | +static void vhost_vring_write_descs(VhostShadowVirtqueue *svq, hwaddr *sg, | ||
82 | const struct iovec *iovec, size_t num, | ||
83 | bool more_descs, bool write) | ||
84 | { | ||
85 | @@ -XXX,XX +XXX,XX @@ static void vhost_vring_write_descs(VhostShadowVirtqueue *svq, | ||
86 | } else { | ||
87 | descs[i].flags = flags; | ||
88 | } | ||
89 | - descs[i].addr = cpu_to_le64((hwaddr)(intptr_t)iovec[n].iov_base); | ||
90 | + descs[i].addr = cpu_to_le64(sg[n]); | ||
91 | descs[i].len = cpu_to_le32(iovec[n].iov_len); | ||
92 | |||
93 | last = i; | ||
94 | @@ -XXX,XX +XXX,XX @@ static bool vhost_svq_add_split(VhostShadowVirtqueue *svq, | ||
95 | { | ||
96 | unsigned avail_idx; | ||
97 | vring_avail_t *avail = svq->vring.avail; | ||
98 | + bool ok; | ||
99 | + g_autofree hwaddr *sgs = g_new(hwaddr, MAX(elem->out_num, elem->in_num)); | ||
100 | |||
101 | *head = svq->free_head; | ||
102 | |||
103 | @@ -XXX,XX +XXX,XX @@ static bool vhost_svq_add_split(VhostShadowVirtqueue *svq, | ||
104 | return false; | ||
35 | } | 105 | } |
36 | 106 | ||
37 | - if ((core->mac[ICR] & E1000_ICR_ASSERTED) && | 107 | - vhost_vring_write_descs(svq, elem->out_sg, elem->out_num, elem->in_num > 0, |
38 | - (core->mac[CTRL_EXT] & E1000_CTRL_EXT_IAME)) { | 108 | - false); |
39 | - trace_e1000e_irq_icr_clear_iame(); | 109 | - vhost_vring_write_descs(svq, elem->in_sg, elem->in_num, false, true); |
40 | - e1000e_lower_interrupts(core, ICR, 0xffffffff); | 110 | + ok = vhost_svq_translate_addr(svq, sgs, elem->out_sg, elem->out_num); |
41 | - trace_e1000e_irq_icr_process_iame(); | 111 | + if (unlikely(!ok)) { |
42 | - e1000e_lower_interrupts(core, IMS, core->mac[IAM]); | 112 | + return false; |
43 | + if (core->mac[ICR] & E1000_ICR_ASSERTED) { | 113 | + } |
44 | + if (core->mac[CTRL_EXT] & E1000_CTRL_EXT_IAME) { | 114 | + vhost_vring_write_descs(svq, sgs, elem->out_sg, elem->out_num, |
45 | + trace_e1000e_irq_icr_clear_iame(); | 115 | + elem->in_num > 0, false); |
46 | + e1000e_lower_interrupts(core, ICR, 0xffffffff); | 116 | + |
47 | + trace_e1000e_irq_icr_process_iame(); | 117 | + |
48 | + e1000e_lower_interrupts(core, IMS, core->mac[IAM]); | 118 | + ok = vhost_svq_translate_addr(svq, sgs, elem->in_sg, elem->in_num); |
119 | + if (unlikely(!ok)) { | ||
120 | + return false; | ||
121 | + } | ||
122 | + | ||
123 | + vhost_vring_write_descs(svq, sgs, elem->in_sg, elem->in_num, false, true); | ||
124 | |||
125 | /* | ||
126 | * Put the entry in the available array (but don't update avail->idx until | ||
127 | @@ -XXX,XX +XXX,XX @@ void vhost_svq_set_svq_call_fd(VhostShadowVirtqueue *svq, int call_fd) | ||
128 | void vhost_svq_get_vring_addr(const VhostShadowVirtqueue *svq, | ||
129 | struct vhost_vring_addr *addr) | ||
130 | { | ||
131 | - addr->desc_user_addr = (uint64_t)(intptr_t)svq->vring.desc; | ||
132 | - addr->avail_user_addr = (uint64_t)(intptr_t)svq->vring.avail; | ||
133 | - addr->used_user_addr = (uint64_t)(intptr_t)svq->vring.used; | ||
134 | + addr->desc_user_addr = (uint64_t)(uintptr_t)svq->vring.desc; | ||
135 | + addr->avail_user_addr = (uint64_t)(uintptr_t)svq->vring.avail; | ||
136 | + addr->used_user_addr = (uint64_t)(uintptr_t)svq->vring.used; | ||
137 | } | ||
138 | |||
139 | size_t vhost_svq_driver_area_size(const VhostShadowVirtqueue *svq) | ||
140 | @@ -XXX,XX +XXX,XX @@ void vhost_svq_stop(VhostShadowVirtqueue *svq) | ||
141 | * Creates vhost shadow virtqueue, and instructs the vhost device to use the | ||
142 | * shadow methods and file descriptors. | ||
143 | * | ||
144 | + * @iova_tree: Tree to perform descriptors translations | ||
145 | + * | ||
146 | * Returns the new virtqueue or NULL. | ||
147 | * | ||
148 | * In case of error, reason is reported through error_report. | ||
149 | */ | ||
150 | -VhostShadowVirtqueue *vhost_svq_new(void) | ||
151 | +VhostShadowVirtqueue *vhost_svq_new(VhostIOVATree *iova_tree) | ||
152 | { | ||
153 | g_autofree VhostShadowVirtqueue *svq = g_new0(VhostShadowVirtqueue, 1); | ||
154 | int r; | ||
155 | @@ -XXX,XX +XXX,XX @@ VhostShadowVirtqueue *vhost_svq_new(void) | ||
156 | |||
157 | event_notifier_init_fd(&svq->svq_kick, VHOST_FILE_UNBIND); | ||
158 | event_notifier_set_handler(&svq->hdev_call, vhost_svq_handle_call); | ||
159 | + svq->iova_tree = iova_tree; | ||
160 | return g_steal_pointer(&svq); | ||
161 | |||
162 | err_init_hdev_call: | ||
163 | diff --git a/hw/virtio/vhost-shadow-virtqueue.h b/hw/virtio/vhost-shadow-virtqueue.h | ||
164 | index XXXXXXX..XXXXXXX 100644 | ||
165 | --- a/hw/virtio/vhost-shadow-virtqueue.h | ||
166 | +++ b/hw/virtio/vhost-shadow-virtqueue.h | ||
167 | @@ -XXX,XX +XXX,XX @@ | ||
168 | #include "qemu/event_notifier.h" | ||
169 | #include "hw/virtio/virtio.h" | ||
170 | #include "standard-headers/linux/vhost_types.h" | ||
171 | +#include "hw/virtio/vhost-iova-tree.h" | ||
172 | |||
173 | /* Shadow virtqueue to relay notifications */ | ||
174 | typedef struct VhostShadowVirtqueue { | ||
175 | @@ -XXX,XX +XXX,XX @@ typedef struct VhostShadowVirtqueue { | ||
176 | /* Virtio device */ | ||
177 | VirtIODevice *vdev; | ||
178 | |||
179 | + /* IOVA mapping */ | ||
180 | + VhostIOVATree *iova_tree; | ||
181 | + | ||
182 | /* Map for use the guest's descriptors */ | ||
183 | VirtQueueElement **ring_id_maps; | ||
184 | |||
185 | @@ -XXX,XX +XXX,XX @@ void vhost_svq_start(VhostShadowVirtqueue *svq, VirtIODevice *vdev, | ||
186 | VirtQueue *vq); | ||
187 | void vhost_svq_stop(VhostShadowVirtqueue *svq); | ||
188 | |||
189 | -VhostShadowVirtqueue *vhost_svq_new(void); | ||
190 | +VhostShadowVirtqueue *vhost_svq_new(VhostIOVATree *iova_tree); | ||
191 | |||
192 | void vhost_svq_free(gpointer vq); | ||
193 | G_DEFINE_AUTOPTR_CLEANUP_FUNC(VhostShadowVirtqueue, vhost_svq_free); | ||
194 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c | ||
195 | index XXXXXXX..XXXXXXX 100644 | ||
196 | --- a/hw/virtio/vhost-vdpa.c | ||
197 | +++ b/hw/virtio/vhost-vdpa.c | ||
198 | @@ -XXX,XX +XXX,XX @@ static void vhost_vdpa_listener_region_add(MemoryListener *listener, | ||
199 | vaddr, section->readonly); | ||
200 | |||
201 | llsize = int128_sub(llend, int128_make64(iova)); | ||
202 | + if (v->shadow_vqs_enabled) { | ||
203 | + DMAMap mem_region = { | ||
204 | + .translated_addr = (hwaddr)(uintptr_t)vaddr, | ||
205 | + .size = int128_get64(llsize) - 1, | ||
206 | + .perm = IOMMU_ACCESS_FLAG(true, section->readonly), | ||
207 | + }; | ||
208 | + | ||
209 | + int r = vhost_iova_tree_map_alloc(v->iova_tree, &mem_region); | ||
210 | + if (unlikely(r != IOVA_OK)) { | ||
211 | + error_report("Can't allocate a mapping (%d)", r); | ||
212 | + goto fail; | ||
49 | + } | 213 | + } |
50 | + | 214 | + |
51 | + /* | 215 | + iova = mem_region.iova; |
52 | + * The datasheet does not say what happens when interrupt was asserted | 216 | + } |
53 | + * (ICR.INT_ASSERT=1) and auto mask is *not* active. | 217 | |
54 | + * However, section of 13.3.27 the PCIe* GbE Controllers Open Source | 218 | vhost_vdpa_iotlb_batch_begin_once(v); |
55 | + * Software Developer’s Manual, which were written for older devices, | 219 | ret = vhost_vdpa_dma_map(v, iova, int128_get64(llsize), |
56 | + * namely 631xESB/632xESB, 82563EB/82564EB, 82571EB/82572EI & | 220 | @@ -XXX,XX +XXX,XX @@ static void vhost_vdpa_listener_region_del(MemoryListener *listener, |
57 | + * 82573E/82573V/82573L, does say: | 221 | |
58 | + * > If IMS = 0b, then the ICR register is always clear-on-read. If IMS | 222 | llsize = int128_sub(llend, int128_make64(iova)); |
59 | + * > is not 0b, but some ICR bit is set where the corresponding IMS bit | 223 | |
60 | + * > is not set, then a read does not clear the ICR register. For | 224 | + if (v->shadow_vqs_enabled) { |
61 | + * > example, if IMS = 10101010b and ICR = 01010101b, then a read to the | 225 | + const DMAMap *result; |
62 | + * > ICR register does not clear it. If IMS = 10101010b and | 226 | + const void *vaddr = memory_region_get_ram_ptr(section->mr) + |
63 | + * > ICR = 0101011b, then a read to the ICR register clears it entirely | 227 | + section->offset_within_region + |
64 | + * > (ICR.INT_ASSERTED = 1b). | 228 | + (iova - section->offset_within_address_space); |
65 | + * | 229 | + DMAMap mem_region = { |
66 | + * Linux does no longer activate auto mask since commit | 230 | + .translated_addr = (hwaddr)(uintptr_t)vaddr, |
67 | + * 0a8047ac68e50e4ccbadcfc6b6b070805b976885 and the real hardware | 231 | + .size = int128_get64(llsize) - 1, |
68 | + * clears ICR even in such a case so we also should do so. | 232 | + }; |
69 | + */ | 233 | + |
70 | + if (core->mac[ICR] & core->mac[IMS]) { | 234 | + result = vhost_iova_tree_find_iova(v->iova_tree, &mem_region); |
71 | + trace_e1000e_irq_icr_clear_icr_bit_ims(core->mac[ICR], | 235 | + iova = result->iova; |
72 | + core->mac[IMS]); | 236 | + vhost_iova_tree_remove(v->iova_tree, &mem_region); |
73 | + e1000e_lower_interrupts(core, ICR, 0xffffffff); | 237 | + } |
74 | + } | 238 | vhost_vdpa_iotlb_batch_begin_once(v); |
239 | ret = vhost_vdpa_dma_unmap(v, iova, int128_get64(llsize)); | ||
240 | if (ret) { | ||
241 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_init_svq(struct vhost_dev *hdev, struct vhost_vdpa *v, | ||
242 | |||
243 | shadow_vqs = g_ptr_array_new_full(hdev->nvqs, vhost_svq_free); | ||
244 | for (unsigned n = 0; n < hdev->nvqs; ++n) { | ||
245 | - g_autoptr(VhostShadowVirtqueue) svq = vhost_svq_new(); | ||
246 | + g_autoptr(VhostShadowVirtqueue) svq = vhost_svq_new(v->iova_tree); | ||
247 | |||
248 | if (unlikely(!svq)) { | ||
249 | error_setg(errp, "Cannot create svq %u", n); | ||
250 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_svq_set_fds(struct vhost_dev *dev, | ||
251 | /** | ||
252 | * Unmap a SVQ area in the device | ||
253 | */ | ||
254 | -static bool vhost_vdpa_svq_unmap_ring(struct vhost_vdpa *v, hwaddr iova, | ||
255 | - hwaddr size) | ||
256 | +static bool vhost_vdpa_svq_unmap_ring(struct vhost_vdpa *v, | ||
257 | + const DMAMap *needle) | ||
258 | { | ||
259 | + const DMAMap *result = vhost_iova_tree_find_iova(v->iova_tree, needle); | ||
260 | + hwaddr size; | ||
261 | int r; | ||
262 | |||
263 | - size = ROUND_UP(size, qemu_real_host_page_size); | ||
264 | - r = vhost_vdpa_dma_unmap(v, iova, size); | ||
265 | + if (unlikely(!result)) { | ||
266 | + error_report("Unable to find SVQ address to unmap"); | ||
267 | + return false; | ||
268 | + } | ||
269 | + | ||
270 | + size = ROUND_UP(result->size, qemu_real_host_page_size); | ||
271 | + r = vhost_vdpa_dma_unmap(v, result->iova, size); | ||
272 | return r == 0; | ||
273 | } | ||
274 | |||
275 | static bool vhost_vdpa_svq_unmap_rings(struct vhost_dev *dev, | ||
276 | const VhostShadowVirtqueue *svq) | ||
277 | { | ||
278 | + DMAMap needle = {}; | ||
279 | struct vhost_vdpa *v = dev->opaque; | ||
280 | struct vhost_vring_addr svq_addr; | ||
281 | - size_t device_size = vhost_svq_device_area_size(svq); | ||
282 | - size_t driver_size = vhost_svq_driver_area_size(svq); | ||
283 | bool ok; | ||
284 | |||
285 | vhost_svq_get_vring_addr(svq, &svq_addr); | ||
286 | |||
287 | - ok = vhost_vdpa_svq_unmap_ring(v, svq_addr.desc_user_addr, driver_size); | ||
288 | + needle.translated_addr = svq_addr.desc_user_addr; | ||
289 | + ok = vhost_vdpa_svq_unmap_ring(v, &needle); | ||
290 | if (unlikely(!ok)) { | ||
291 | return false; | ||
75 | } | 292 | } |
76 | 293 | ||
77 | return ret; | 294 | - return vhost_vdpa_svq_unmap_ring(v, svq_addr.used_user_addr, device_size); |
78 | diff --git a/hw/net/trace-events b/hw/net/trace-events | 295 | + needle.translated_addr = svq_addr.used_user_addr; |
296 | + return vhost_vdpa_svq_unmap_ring(v, &needle); | ||
297 | +} | ||
298 | + | ||
299 | +/** | ||
300 | + * Map the SVQ area in the device | ||
301 | + * | ||
302 | + * @v: Vhost-vdpa device | ||
303 | + * @needle: The area to search iova | ||
304 | + * @errorp: Error pointer | ||
305 | + */ | ||
306 | +static bool vhost_vdpa_svq_map_ring(struct vhost_vdpa *v, DMAMap *needle, | ||
307 | + Error **errp) | ||
308 | +{ | ||
309 | + int r; | ||
310 | + | ||
311 | + r = vhost_iova_tree_map_alloc(v->iova_tree, needle); | ||
312 | + if (unlikely(r != IOVA_OK)) { | ||
313 | + error_setg(errp, "Cannot allocate iova (%d)", r); | ||
314 | + return false; | ||
315 | + } | ||
316 | + | ||
317 | + r = vhost_vdpa_dma_map(v, needle->iova, needle->size + 1, | ||
318 | + (void *)(uintptr_t)needle->translated_addr, | ||
319 | + needle->perm == IOMMU_RO); | ||
320 | + if (unlikely(r != 0)) { | ||
321 | + error_setg_errno(errp, -r, "Cannot map region to device"); | ||
322 | + vhost_iova_tree_remove(v->iova_tree, needle); | ||
323 | + } | ||
324 | + | ||
325 | + return r == 0; | ||
326 | } | ||
327 | |||
328 | /** | ||
329 | @@ -XXX,XX +XXX,XX @@ static bool vhost_vdpa_svq_map_rings(struct vhost_dev *dev, | ||
330 | struct vhost_vring_addr *addr, | ||
331 | Error **errp) | ||
332 | { | ||
333 | + DMAMap device_region, driver_region; | ||
334 | + struct vhost_vring_addr svq_addr; | ||
335 | struct vhost_vdpa *v = dev->opaque; | ||
336 | size_t device_size = vhost_svq_device_area_size(svq); | ||
337 | size_t driver_size = vhost_svq_driver_area_size(svq); | ||
338 | - int r; | ||
339 | + size_t avail_offset; | ||
340 | + bool ok; | ||
341 | |||
342 | ERRP_GUARD(); | ||
343 | - vhost_svq_get_vring_addr(svq, addr); | ||
344 | + vhost_svq_get_vring_addr(svq, &svq_addr); | ||
345 | |||
346 | - r = vhost_vdpa_dma_map(v, addr->desc_user_addr, driver_size, | ||
347 | - (void *)(uintptr_t)addr->desc_user_addr, true); | ||
348 | - if (unlikely(r != 0)) { | ||
349 | - error_setg_errno(errp, -r, "Cannot create vq driver region: "); | ||
350 | + driver_region = (DMAMap) { | ||
351 | + .translated_addr = svq_addr.desc_user_addr, | ||
352 | + .size = driver_size - 1, | ||
353 | + .perm = IOMMU_RO, | ||
354 | + }; | ||
355 | + ok = vhost_vdpa_svq_map_ring(v, &driver_region, errp); | ||
356 | + if (unlikely(!ok)) { | ||
357 | + error_prepend(errp, "Cannot create vq driver region: "); | ||
358 | return false; | ||
359 | } | ||
360 | + addr->desc_user_addr = driver_region.iova; | ||
361 | + avail_offset = svq_addr.avail_user_addr - svq_addr.desc_user_addr; | ||
362 | + addr->avail_user_addr = driver_region.iova + avail_offset; | ||
363 | |||
364 | - r = vhost_vdpa_dma_map(v, addr->used_user_addr, device_size, | ||
365 | - (void *)(intptr_t)addr->used_user_addr, false); | ||
366 | - if (unlikely(r != 0)) { | ||
367 | - error_setg_errno(errp, -r, "Cannot create vq device region: "); | ||
368 | + device_region = (DMAMap) { | ||
369 | + .translated_addr = svq_addr.used_user_addr, | ||
370 | + .size = device_size - 1, | ||
371 | + .perm = IOMMU_RW, | ||
372 | + }; | ||
373 | + ok = vhost_vdpa_svq_map_ring(v, &device_region, errp); | ||
374 | + if (unlikely(!ok)) { | ||
375 | + error_prepend(errp, "Cannot create vq device region: "); | ||
376 | + vhost_vdpa_svq_unmap_ring(v, &driver_region); | ||
377 | } | ||
378 | + addr->used_user_addr = device_region.iova; | ||
379 | |||
380 | - return r == 0; | ||
381 | + return ok; | ||
382 | } | ||
383 | |||
384 | static bool vhost_vdpa_svq_setup(struct vhost_dev *dev, | ||
385 | diff --git a/include/hw/virtio/vhost-vdpa.h b/include/hw/virtio/vhost-vdpa.h | ||
79 | index XXXXXXX..XXXXXXX 100644 | 386 | index XXXXXXX..XXXXXXX 100644 |
80 | --- a/hw/net/trace-events | 387 | --- a/include/hw/virtio/vhost-vdpa.h |
81 | +++ b/hw/net/trace-events | 388 | +++ b/include/hw/virtio/vhost-vdpa.h |
82 | @@ -XXX,XX +XXX,XX @@ e1000e_irq_read_ims(uint32_t ims) "Current IMS: 0x%x" | 389 | @@ -XXX,XX +XXX,XX @@ |
83 | e1000e_irq_icr_clear_nonmsix_icr_read(void) "Clearing ICR on read due to non MSI-X int" | 390 | |
84 | e1000e_irq_icr_clear_zero_ims(void) "Clearing ICR on read due to zero IMS" | 391 | #include <gmodule.h> |
85 | e1000e_irq_icr_clear_iame(void) "Clearing ICR on read due to IAME" | 392 | |
86 | +e1000e_irq_icr_clear_icr_bit_ims(uint32_t icr, uint32_t ims) "Clearing ICR on read due corresponding IMS bit: 0x%x & 0x%x" | 393 | +#include "hw/virtio/vhost-iova-tree.h" |
87 | e1000e_irq_iam_clear_eiame(uint32_t iam, uint32_t cause) "Clearing IMS due to EIAME, IAM: 0x%X, cause: 0x%X" | 394 | #include "hw/virtio/virtio.h" |
88 | e1000e_irq_icr_clear_eiac(uint32_t icr, uint32_t eiac) "Clearing ICR bits due to EIAC, ICR: 0x%X, EIAC: 0x%X" | 395 | #include "standard-headers/linux/vhost_types.h" |
89 | e1000e_irq_ims_clear_set_imc(uint32_t val) "Clearing IMS bits due to IMC write 0x%x" | 396 | |
397 | @@ -XXX,XX +XXX,XX @@ typedef struct vhost_vdpa { | ||
398 | MemoryListener listener; | ||
399 | struct vhost_vdpa_iova_range iova_range; | ||
400 | bool shadow_vqs_enabled; | ||
401 | + /* IOVA mapping used by the Shadow Virtqueue */ | ||
402 | + VhostIOVATree *iova_tree; | ||
403 | GPtrArray *shadow_vqs; | ||
404 | struct vhost_dev *dev; | ||
405 | VhostVDPAHostNotifier notifier[VIRTIO_QUEUE_MAX]; | ||
90 | -- | 406 | -- |
91 | 2.7.4 | 407 | 2.7.4 |
92 | 408 | ||
93 | 409 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | This is needed to achieve migration, so the destination can restore its |
4 | QEMU networking codes, remove the same logic in the NIC codes. | 4 | index. |
5 | 5 | ||
6 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | 6 | Setting base as last used idx, so destination will see as available all |
7 | the entries that the device did not use, including the in-flight | ||
8 | processing ones. | ||
9 | |||
10 | This is ok for networking, but other kinds of devices might have | ||
11 | problems with these retransmissions. | ||
12 | |||
13 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
14 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 15 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
8 | --- | 16 | --- |
9 | hw/net/pcnet.c | 9 --------- | 17 | hw/virtio/vhost-vdpa.c | 17 +++++++++++++++++ |
10 | 1 file changed, 9 deletions(-) | 18 | 1 file changed, 17 insertions(+) |
11 | 19 | ||
12 | diff --git a/hw/net/pcnet.c b/hw/net/pcnet.c | 20 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c |
13 | index XXXXXXX..XXXXXXX 100644 | 21 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/hw/net/pcnet.c | 22 | --- a/hw/virtio/vhost-vdpa.c |
15 | +++ b/hw/net/pcnet.c | 23 | +++ b/hw/virtio/vhost-vdpa.c |
16 | @@ -XXX,XX +XXX,XX @@ ssize_t pcnet_receive(NetClientState *nc, const uint8_t *buf, size_t size_) | 24 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_vring_base(struct vhost_dev *dev, |
25 | static int vhost_vdpa_get_vring_base(struct vhost_dev *dev, | ||
26 | struct vhost_vring_state *ring) | ||
17 | { | 27 | { |
18 | PCNetState *s = qemu_get_nic_opaque(nc); | 28 | + struct vhost_vdpa *v = dev->opaque; |
19 | int is_padr = 0, is_bcast = 0, is_ladr = 0; | 29 | int ret; |
20 | - uint8_t buf1[60]; | 30 | |
21 | int remaining; | 31 | + if (v->shadow_vqs_enabled) { |
22 | int crc_err = 0; | 32 | + VhostShadowVirtqueue *svq = g_ptr_array_index(v->shadow_vqs, |
23 | size_t size = size_; | 33 | + ring->index); |
24 | @@ -XXX,XX +XXX,XX @@ ssize_t pcnet_receive(NetClientState *nc, const uint8_t *buf, size_t size_) | 34 | + |
25 | printf("pcnet_receive size=%zu\n", size); | 35 | + /* |
26 | #endif | 36 | + * Setting base as last used idx, so destination will see as available |
27 | 37 | + * all the entries that the device did not use, including the in-flight | |
28 | - /* if too small buffer, then expand it */ | 38 | + * processing ones. |
29 | - if (size < MIN_BUF_SIZE) { | 39 | + * |
30 | - memcpy(buf1, buf, size); | 40 | + * TODO: This is ok for networking, but other kinds of devices might |
31 | - memset(buf1 + size, 0, MIN_BUF_SIZE - size); | 41 | + * have problems with these retransmissions. |
32 | - buf = buf1; | 42 | + */ |
33 | - size = MIN_BUF_SIZE; | 43 | + ring->num = svq->last_used_idx; |
34 | - } | 44 | + return 0; |
35 | - | 45 | + } |
36 | if (CSR_PROM(s) | 46 | + |
37 | || (is_padr=padr_match(s, buf, size)) | 47 | ret = vhost_vdpa_call(dev, VHOST_GET_VRING_BASE, ring); |
38 | || (is_bcast=padr_bcast(s, buf, size)) | 48 | trace_vhost_vdpa_get_vring_base(dev, ring->index, ring->num); |
49 | return ret; | ||
39 | -- | 50 | -- |
40 | 2.7.4 | 51 | 2.7.4 |
52 | |||
53 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | Setting the log address would make the device start reporting invalid |
4 | QEMU networking codes, remove the same logic in the NIC codes. | 4 | dirty memory because the SVQ vrings are located in qemu's memory. |
5 | 5 | ||
6 | This actually reverts commit 78aeb23eded2d0b765bf9145c71f80025b568acd. | 6 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> |
7 | 7 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | |
8 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | ||
9 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 8 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
10 | --- | 9 | --- |
11 | hw/net/e1000.c | 11 +---------- | 10 | hw/virtio/vhost-vdpa.c | 3 ++- |
12 | 1 file changed, 1 insertion(+), 10 deletions(-) | 11 | 1 file changed, 2 insertions(+), 1 deletion(-) |
13 | 12 | ||
14 | diff --git a/hw/net/e1000.c b/hw/net/e1000.c | 13 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c |
15 | index XXXXXXX..XXXXXXX 100644 | 14 | index XXXXXXX..XXXXXXX 100644 |
16 | --- a/hw/net/e1000.c | 15 | --- a/hw/virtio/vhost-vdpa.c |
17 | +++ b/hw/net/e1000.c | 16 | +++ b/hw/virtio/vhost-vdpa.c |
18 | @@ -XXX,XX +XXX,XX @@ e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt) | 17 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_dev_start(struct vhost_dev *dev, bool started) |
19 | uint16_t vlan_special = 0; | 18 | static int vhost_vdpa_set_log_base(struct vhost_dev *dev, uint64_t base, |
20 | uint8_t vlan_status = 0; | 19 | struct vhost_log *log) |
21 | uint8_t min_buf[ETH_ZLEN]; | 20 | { |
22 | - struct iovec min_iov; | 21 | - if (vhost_vdpa_one_time_request(dev)) { |
23 | uint8_t *filter_buf = iov->iov_base; | 22 | + struct vhost_vdpa *v = dev->opaque; |
24 | size_t size = iov_size(iov, iovcnt); | 23 | + if (v->shadow_vqs_enabled || vhost_vdpa_one_time_request(dev)) { |
25 | size_t iov_ofs = 0; | ||
26 | @@ -XXX,XX +XXX,XX @@ e1000_receive_iov(NetClientState *nc, const struct iovec *iov, int iovcnt) | ||
27 | return 0; | 24 | return 0; |
28 | } | 25 | } |
29 | 26 | ||
30 | - /* Pad to minimum Ethernet frame length */ | ||
31 | - if (size < sizeof(min_buf)) { | ||
32 | - iov_to_buf(iov, iovcnt, 0, min_buf, size); | ||
33 | - memset(&min_buf[size], 0, sizeof(min_buf) - size); | ||
34 | - min_iov.iov_base = filter_buf = min_buf; | ||
35 | - min_iov.iov_len = size = sizeof(min_buf); | ||
36 | - iovcnt = 1; | ||
37 | - iov = &min_iov; | ||
38 | - } else if (iov->iov_len < MAXIMUM_ETHERNET_HDR_LEN) { | ||
39 | + if (iov->iov_len < MAXIMUM_ETHERNET_HDR_LEN) { | ||
40 | /* This is very unlikely, but may happen. */ | ||
41 | iov_to_buf(iov, iovcnt, 0, min_buf, MAXIMUM_ETHERNET_HDR_LEN); | ||
42 | filter_buf = min_buf; | ||
43 | -- | 27 | -- |
44 | 2.7.4 | 28 | 2.7.4 |
29 | |||
30 | diff view generated by jsdifflib |
1 | From: Bin Meng <bmeng@tinylab.org> | 1 | From: Eugenio Pérez <eperezma@redhat.com> |
---|---|---|---|
2 | 2 | ||
3 | Now that we have implemented unified short frames padding in the | 3 | SVQ is able to log the dirty bits by itself, so let's use it to not |
4 | QEMU networking codes, remove the same logic in the NIC codes. | 4 | block migration. |
5 | 5 | ||
6 | Signed-off-by: Bin Meng <bmeng@tinylab.org> | 6 | Also, ignore set and clear of VHOST_F_LOG_ALL on set_features if SVQ is |
7 | enabled. Even if the device supports it, the reports would be nonsense | ||
8 | because SVQ memory is in the qemu region. | ||
9 | |||
10 | The log region is still allocated. Future changes might skip that, but | ||
11 | this series is already long enough. | ||
12 | |||
13 | Signed-off-by: Eugenio Pérez <eperezma@redhat.com> | ||
14 | Acked-by: Michael S. Tsirkin <mst@redhat.com> | ||
7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 15 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
8 | --- | 16 | --- |
9 | hw/net/i82596.c | 18 ------------------ | 17 | hw/virtio/vhost-vdpa.c | 39 +++++++++++++++++++++++++++++++++++---- |
10 | 1 file changed, 18 deletions(-) | 18 | include/hw/virtio/vhost-vdpa.h | 1 + |
19 | 2 files changed, 36 insertions(+), 4 deletions(-) | ||
11 | 20 | ||
12 | diff --git a/hw/net/i82596.c b/hw/net/i82596.c | 21 | diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c |
13 | index XXXXXXX..XXXXXXX 100644 | 22 | index XXXXXXX..XXXXXXX 100644 |
14 | --- a/hw/net/i82596.c | 23 | --- a/hw/virtio/vhost-vdpa.c |
15 | +++ b/hw/net/i82596.c | 24 | +++ b/hw/virtio/vhost-vdpa.c |
16 | @@ -XXX,XX +XXX,XX @@ enum commands { | 25 | @@ -XXX,XX +XXX,XX @@ static bool vhost_vdpa_one_time_request(struct vhost_dev *dev) |
17 | #define I596_EOF 0x8000 | 26 | return v->index != 0; |
18 | #define SIZE_MASK 0x3fff | ||
19 | |||
20 | -#define ETHER_TYPE_LEN 2 | ||
21 | -#define VLAN_TCI_LEN 2 | ||
22 | -#define VLAN_HLEN (ETHER_TYPE_LEN + VLAN_TCI_LEN) | ||
23 | - | ||
24 | /* various flags in the chip config registers */ | ||
25 | #define I596_PREFETCH (s->config[0] & 0x80) | ||
26 | #define I596_PROMISC (s->config[8] & 0x01) | ||
27 | @@ -XXX,XX +XXX,XX @@ bool i82596_can_receive(NetClientState *nc) | ||
28 | return true; | ||
29 | } | 27 | } |
30 | 28 | ||
31 | -#define MIN_BUF_SIZE 60 | 29 | +static int vhost_vdpa_get_dev_features(struct vhost_dev *dev, |
32 | - | 30 | + uint64_t *features) |
33 | ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t sz) | 31 | +{ |
32 | + int ret; | ||
33 | + | ||
34 | + ret = vhost_vdpa_call(dev, VHOST_GET_FEATURES, features); | ||
35 | + trace_vhost_vdpa_get_features(dev, *features); | ||
36 | + return ret; | ||
37 | +} | ||
38 | + | ||
39 | static int vhost_vdpa_init_svq(struct vhost_dev *hdev, struct vhost_vdpa *v, | ||
40 | Error **errp) | ||
34 | { | 41 | { |
35 | I82596State *s = qemu_get_nic_opaque(nc); | 42 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_init_svq(struct vhost_dev *hdev, struct vhost_vdpa *v, |
36 | @@ -XXX,XX +XXX,XX @@ ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t sz) | 43 | return 0; |
37 | size_t bufsz = sz; /* length of data in buf */ | ||
38 | uint32_t crc; | ||
39 | uint8_t *crc_ptr; | ||
40 | - uint8_t buf1[MIN_BUF_SIZE + VLAN_HLEN]; | ||
41 | static const uint8_t broadcast_macaddr[6] = { | ||
42 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; | ||
43 | |||
44 | @@ -XXX,XX +XXX,XX @@ ssize_t i82596_receive(NetClientState *nc, const uint8_t *buf, size_t sz) | ||
45 | } | ||
46 | } | 44 | } |
47 | 45 | ||
48 | - /* if too small buffer, then expand it */ | 46 | - r = hdev->vhost_ops->vhost_get_features(hdev, &dev_features); |
49 | - if (len < MIN_BUF_SIZE + VLAN_HLEN) { | 47 | + r = vhost_vdpa_get_dev_features(hdev, &dev_features); |
50 | - memcpy(buf1, buf, len); | 48 | if (r != 0) { |
51 | - memset(buf1 + len, 0, MIN_BUF_SIZE + VLAN_HLEN - len); | 49 | error_setg_errno(errp, -r, "Can't get vdpa device features"); |
52 | - buf = buf1; | 50 | return r; |
53 | - if (len < MIN_BUF_SIZE) { | 51 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_mem_table(struct vhost_dev *dev, |
54 | - len = MIN_BUF_SIZE; | 52 | static int vhost_vdpa_set_features(struct vhost_dev *dev, |
55 | - } | 53 | uint64_t features) |
56 | - bufsz = len; | 54 | { |
57 | - } | 55 | + struct vhost_vdpa *v = dev->opaque; |
58 | - | 56 | int ret; |
59 | /* Calculate the ethernet checksum (4 bytes) */ | 57 | |
60 | len += 4; | 58 | if (vhost_vdpa_one_time_request(dev)) { |
61 | crc = cpu_to_be32(crc32(~0, buf, sz)); | 59 | return 0; |
60 | } | ||
61 | |||
62 | + if (v->shadow_vqs_enabled) { | ||
63 | + if ((v->acked_features ^ features) == BIT_ULL(VHOST_F_LOG_ALL)) { | ||
64 | + /* | ||
65 | + * QEMU is just trying to enable or disable logging. SVQ handles | ||
66 | + * this sepparately, so no need to forward this. | ||
67 | + */ | ||
68 | + v->acked_features = features; | ||
69 | + return 0; | ||
70 | + } | ||
71 | + | ||
72 | + v->acked_features = features; | ||
73 | + | ||
74 | + /* We must not ack _F_LOG if SVQ is enabled */ | ||
75 | + features &= ~BIT_ULL(VHOST_F_LOG_ALL); | ||
76 | + } | ||
77 | + | ||
78 | trace_vhost_vdpa_set_features(dev, features); | ||
79 | ret = vhost_vdpa_call(dev, VHOST_SET_FEATURES, &features); | ||
80 | if (ret) { | ||
81 | @@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_set_vring_call(struct vhost_dev *dev, | ||
82 | static int vhost_vdpa_get_features(struct vhost_dev *dev, | ||
83 | uint64_t *features) | ||
84 | { | ||
85 | - int ret; | ||
86 | + struct vhost_vdpa *v = dev->opaque; | ||
87 | + int ret = vhost_vdpa_get_dev_features(dev, features); | ||
88 | + | ||
89 | + if (ret == 0 && v->shadow_vqs_enabled) { | ||
90 | + /* Add SVQ logging capabilities */ | ||
91 | + *features |= BIT_ULL(VHOST_F_LOG_ALL); | ||
92 | + } | ||
93 | |||
94 | - ret = vhost_vdpa_call(dev, VHOST_GET_FEATURES, features); | ||
95 | - trace_vhost_vdpa_get_features(dev, *features); | ||
96 | return ret; | ||
97 | } | ||
98 | |||
99 | diff --git a/include/hw/virtio/vhost-vdpa.h b/include/hw/virtio/vhost-vdpa.h | ||
100 | index XXXXXXX..XXXXXXX 100644 | ||
101 | --- a/include/hw/virtio/vhost-vdpa.h | ||
102 | +++ b/include/hw/virtio/vhost-vdpa.h | ||
103 | @@ -XXX,XX +XXX,XX @@ typedef struct vhost_vdpa { | ||
104 | bool iotlb_batch_begin_sent; | ||
105 | MemoryListener listener; | ||
106 | struct vhost_vdpa_iova_range iova_range; | ||
107 | + uint64_t acked_features; | ||
108 | bool shadow_vqs_enabled; | ||
109 | /* IOVA mapping used by the Shadow Virtqueue */ | ||
110 | VhostIOVATree *iova_tree; | ||
62 | -- | 111 | -- |
63 | 2.7.4 | 112 | 2.7.4 |
113 | |||
114 | diff view generated by jsdifflib |