hw/arm/raspi: fix CPRMAN base address
[qemu.git] / hw / virtio / vhost-vsock-common.c
1 /*
2 * Parent class for vhost-vsock devices
3 *
4 * Copyright 2015-2020 Red Hat, Inc.
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or
7 * (at your option) any later version. See the COPYING file in the
8 * top-level directory.
9 */
10
11 #include "qemu/osdep.h"
12 #include "standard-headers/linux/virtio_vsock.h"
13 #include "qapi/error.h"
14 #include "hw/virtio/virtio-access.h"
15 #include "qemu/error-report.h"
16 #include "hw/qdev-properties.h"
17 #include "hw/virtio/vhost-vsock.h"
18 #include "qemu/iov.h"
19 #include "monitor/monitor.h"
20
21 int vhost_vsock_common_start(VirtIODevice *vdev)
22 {
23 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
24 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
25 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
26 int ret;
27 int i;
28
29 if (!k->set_guest_notifiers) {
30 error_report("binding does not support guest notifiers");
31 return -ENOSYS;
32 }
33
34 ret = vhost_dev_enable_notifiers(&vvc->vhost_dev, vdev);
35 if (ret < 0) {
36 error_report("Error enabling host notifiers: %d", -ret);
37 return ret;
38 }
39
40 ret = k->set_guest_notifiers(qbus->parent, vvc->vhost_dev.nvqs, true);
41 if (ret < 0) {
42 error_report("Error binding guest notifier: %d", -ret);
43 goto err_host_notifiers;
44 }
45
46 vvc->vhost_dev.acked_features = vdev->guest_features;
47 ret = vhost_dev_start(&vvc->vhost_dev, vdev);
48 if (ret < 0) {
49 error_report("Error starting vhost: %d", -ret);
50 goto err_guest_notifiers;
51 }
52
53 /*
54 * guest_notifier_mask/pending not used yet, so just unmask
55 * everything here. virtio-pci will do the right thing by
56 * enabling/disabling irqfd.
57 */
58 for (i = 0; i < vvc->vhost_dev.nvqs; i++) {
59 vhost_virtqueue_mask(&vvc->vhost_dev, vdev, i, false);
60 }
61
62 return 0;
63
64 err_guest_notifiers:
65 k->set_guest_notifiers(qbus->parent, vvc->vhost_dev.nvqs, false);
66 err_host_notifiers:
67 vhost_dev_disable_notifiers(&vvc->vhost_dev, vdev);
68 return ret;
69 }
70
71 void vhost_vsock_common_stop(VirtIODevice *vdev)
72 {
73 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
74 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
75 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
76 int ret;
77
78 if (!k->set_guest_notifiers) {
79 return;
80 }
81
82 vhost_dev_stop(&vvc->vhost_dev, vdev);
83
84 ret = k->set_guest_notifiers(qbus->parent, vvc->vhost_dev.nvqs, false);
85 if (ret < 0) {
86 error_report("vhost guest notifier cleanup failed: %d", ret);
87 return;
88 }
89
90 vhost_dev_disable_notifiers(&vvc->vhost_dev, vdev);
91 }
92
93
94 static void vhost_vsock_common_handle_output(VirtIODevice *vdev, VirtQueue *vq)
95 {
96 /* Do nothing */
97 }
98
99 static void vhost_vsock_common_guest_notifier_mask(VirtIODevice *vdev, int idx,
100 bool mask)
101 {
102 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
103
104 vhost_virtqueue_mask(&vvc->vhost_dev, vdev, idx, mask);
105 }
106
107 static bool vhost_vsock_common_guest_notifier_pending(VirtIODevice *vdev,
108 int idx)
109 {
110 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
111
112 return vhost_virtqueue_pending(&vvc->vhost_dev, idx);
113 }
114
115 static void vhost_vsock_common_send_transport_reset(VHostVSockCommon *vvc)
116 {
117 VirtQueueElement *elem;
118 VirtQueue *vq = vvc->event_vq;
119 struct virtio_vsock_event event = {
120 .id = cpu_to_le32(VIRTIO_VSOCK_EVENT_TRANSPORT_RESET),
121 };
122
123 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
124 if (!elem) {
125 error_report("vhost-vsock missed transport reset event");
126 return;
127 }
128
129 if (elem->out_num) {
130 error_report("invalid vhost-vsock event virtqueue element with "
131 "out buffers");
132 goto out;
133 }
134
135 if (iov_from_buf(elem->in_sg, elem->in_num, 0,
136 &event, sizeof(event)) != sizeof(event)) {
137 error_report("vhost-vsock event virtqueue element is too short");
138 goto out;
139 }
140
141 virtqueue_push(vq, elem, sizeof(event));
142 virtio_notify(VIRTIO_DEVICE(vvc), vq);
143
144 out:
145 g_free(elem);
146 }
147
148 static void vhost_vsock_common_post_load_timer_cleanup(VHostVSockCommon *vvc)
149 {
150 if (!vvc->post_load_timer) {
151 return;
152 }
153
154 timer_del(vvc->post_load_timer);
155 timer_free(vvc->post_load_timer);
156 vvc->post_load_timer = NULL;
157 }
158
159 static void vhost_vsock_common_post_load_timer_cb(void *opaque)
160 {
161 VHostVSockCommon *vvc = opaque;
162
163 vhost_vsock_common_post_load_timer_cleanup(vvc);
164 vhost_vsock_common_send_transport_reset(vvc);
165 }
166
167 int vhost_vsock_common_pre_save(void *opaque)
168 {
169 VHostVSockCommon *vvc = opaque;
170
171 /*
172 * At this point, backend must be stopped, otherwise
173 * it might keep writing to memory.
174 */
175 assert(!vvc->vhost_dev.started);
176
177 return 0;
178 }
179
180 int vhost_vsock_common_post_load(void *opaque, int version_id)
181 {
182 VHostVSockCommon *vvc = opaque;
183 VirtIODevice *vdev = VIRTIO_DEVICE(vvc);
184
185 if (virtio_queue_get_addr(vdev, 2)) {
186 /*
187 * Defer transport reset event to a vm clock timer so that virtqueue
188 * changes happen after migration has completed.
189 */
190 assert(!vvc->post_load_timer);
191 vvc->post_load_timer =
192 timer_new_ns(QEMU_CLOCK_VIRTUAL,
193 vhost_vsock_common_post_load_timer_cb,
194 vvc);
195 timer_mod(vvc->post_load_timer, 1);
196 }
197 return 0;
198 }
199
200 void vhost_vsock_common_realize(VirtIODevice *vdev, const char *name)
201 {
202 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
203
204 virtio_init(vdev, name, VIRTIO_ID_VSOCK,
205 sizeof(struct virtio_vsock_config));
206
207 /* Receive and transmit queues belong to vhost */
208 vvc->recv_vq = virtio_add_queue(vdev, VHOST_VSOCK_QUEUE_SIZE,
209 vhost_vsock_common_handle_output);
210 vvc->trans_vq = virtio_add_queue(vdev, VHOST_VSOCK_QUEUE_SIZE,
211 vhost_vsock_common_handle_output);
212
213 /* The event queue belongs to QEMU */
214 vvc->event_vq = virtio_add_queue(vdev, VHOST_VSOCK_QUEUE_SIZE,
215 vhost_vsock_common_handle_output);
216
217 vvc->vhost_dev.nvqs = ARRAY_SIZE(vvc->vhost_vqs);
218 vvc->vhost_dev.vqs = vvc->vhost_vqs;
219
220 vvc->post_load_timer = NULL;
221 }
222
223 void vhost_vsock_common_unrealize(VirtIODevice *vdev)
224 {
225 VHostVSockCommon *vvc = VHOST_VSOCK_COMMON(vdev);
226
227 vhost_vsock_common_post_load_timer_cleanup(vvc);
228
229 virtio_delete_queue(vvc->recv_vq);
230 virtio_delete_queue(vvc->trans_vq);
231 virtio_delete_queue(vvc->event_vq);
232 virtio_cleanup(vdev);
233 }
234
235 static void vhost_vsock_common_class_init(ObjectClass *klass, void *data)
236 {
237 DeviceClass *dc = DEVICE_CLASS(klass);
238 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
239
240 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
241 vdc->guest_notifier_mask = vhost_vsock_common_guest_notifier_mask;
242 vdc->guest_notifier_pending = vhost_vsock_common_guest_notifier_pending;
243 }
244
245 static const TypeInfo vhost_vsock_common_info = {
246 .name = TYPE_VHOST_VSOCK_COMMON,
247 .parent = TYPE_VIRTIO_DEVICE,
248 .instance_size = sizeof(VHostVSockCommon),
249 .class_init = vhost_vsock_common_class_init,
250 .abstract = true,
251 };
252
253 static void vhost_vsock_common_register_types(void)
254 {
255 type_register_static(&vhost_vsock_common_info);
256 }
257
258 type_init(vhost_vsock_common_register_types)