1 /*
2 * Vhost-user GPIO virtio device
3 *
4 * Copyright (c) 2022 Viresh Kumar <viresh.kumar@linaro.org>
5 *
6 * SPDX-License-Identifier: GPL-2.0-or-later
7 */
8
9 #include "qemu/osdep.h"
10 #include "qapi/error.h"
11 #include "hw/qdev-properties.h"
12 #include "hw/virtio/virtio-bus.h"
13 #include "hw/virtio/vhost-user-gpio.h"
14 #include "qemu/error-report.h"
15 #include "standard-headers/linux/virtio_ids.h"
16 #include "trace.h"
17
18 #define VHOST_NVQS 2
19
20 /* Features required from VirtIO */
21 static const int feature_bits[] = {
22 VIRTIO_F_VERSION_1,
23 VIRTIO_F_NOTIFY_ON_EMPTY,
24 VIRTIO_RING_F_INDIRECT_DESC,
25 VIRTIO_RING_F_EVENT_IDX,
26 VIRTIO_GPIO_F_IRQ,
27 VIRTIO_F_RING_RESET,
28 VHOST_INVALID_FEATURE_BIT
29 };
30
vu_gpio_get_config(VirtIODevice * vdev,uint8_t * config)31 static void vu_gpio_get_config(VirtIODevice *vdev, uint8_t *config)
32 {
33 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
34
35 memcpy(config, &gpio->config, sizeof(gpio->config));
36 }
37
vu_gpio_config_notifier(struct vhost_dev * dev)38 static int vu_gpio_config_notifier(struct vhost_dev *dev)
39 {
40 VHostUserGPIO *gpio = VHOST_USER_GPIO(dev->vdev);
41
42 memcpy(dev->vdev->config, &gpio->config, sizeof(gpio->config));
43 virtio_notify_config(dev->vdev);
44
45 return 0;
46 }
47
48 const VhostDevConfigOps gpio_ops = {
49 .vhost_dev_config_notifier = vu_gpio_config_notifier,
50 };
51
vu_gpio_start(VirtIODevice * vdev)52 static int vu_gpio_start(VirtIODevice *vdev)
53 {
54 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
55 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
56 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
57 struct vhost_dev *vhost_dev = &gpio->vhost_dev;
58 int ret, i;
59
60 if (!k->set_guest_notifiers) {
61 error_report("binding does not support guest notifiers");
62 return -ENOSYS;
63 }
64
65 ret = vhost_dev_enable_notifiers(vhost_dev, vdev);
66 if (ret < 0) {
67 error_report("Error enabling host notifiers: %d", ret);
68 return ret;
69 }
70
71 ret = k->set_guest_notifiers(qbus->parent, vhost_dev->nvqs, true);
72 if (ret < 0) {
73 error_report("Error binding guest notifier: %d", ret);
74 goto err_host_notifiers;
75 }
76
77 /*
78 * Before we start up we need to ensure we have the final feature
79 * set needed for the vhost configuration. The backend may also
80 * apply backend_features when the feature set is sent.
81 */
82 vhost_ack_features(&gpio->vhost_dev, feature_bits, vdev->guest_features);
83
84 ret = vhost_dev_start(&gpio->vhost_dev, vdev, false);
85 if (ret < 0) {
86 error_report("Error starting vhost-user-gpio: %d", ret);
87 goto err_guest_notifiers;
88 }
89 gpio->started_vu = true;
90
91 /*
92 * guest_notifier_mask/pending not used yet, so just unmask
93 * everything here. virtio-pci will do the right thing by
94 * enabling/disabling irqfd.
95 */
96 for (i = 0; i < gpio->vhost_dev.nvqs; i++) {
97 vhost_virtqueue_mask(&gpio->vhost_dev, vdev, i, false);
98 }
99
100 /*
101 * As we must have VHOST_USER_F_PROTOCOL_FEATURES (because
102 * VHOST_USER_GET_CONFIG requires it) we need to explicitly enable
103 * the vrings.
104 */
105 g_assert(vhost_dev->vhost_ops &&
106 vhost_dev->vhost_ops->vhost_set_vring_enable);
107 ret = vhost_dev->vhost_ops->vhost_set_vring_enable(vhost_dev, true);
108 if (ret == 0) {
109 return 0;
110 }
111
112 error_report("Failed to start vrings for vhost-user-gpio: %d", ret);
113
114 err_guest_notifiers:
115 k->set_guest_notifiers(qbus->parent, gpio->vhost_dev.nvqs, false);
116 err_host_notifiers:
117 vhost_dev_disable_notifiers(&gpio->vhost_dev, vdev);
118
119 return ret;
120 }
121
vu_gpio_stop(VirtIODevice * vdev)122 static void vu_gpio_stop(VirtIODevice *vdev)
123 {
124 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
125 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vdev)));
126 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
127 struct vhost_dev *vhost_dev = &gpio->vhost_dev;
128 int ret;
129
130 if (!gpio->started_vu) {
131 return;
132 }
133 gpio->started_vu = false;
134
135 if (!k->set_guest_notifiers) {
136 return;
137 }
138
139 vhost_dev_stop(vhost_dev, vdev, false);
140
141 ret = k->set_guest_notifiers(qbus->parent, vhost_dev->nvqs, false);
142 if (ret < 0) {
143 error_report("vhost guest notifier cleanup failed: %d", ret);
144 return;
145 }
146
147 vhost_dev_disable_notifiers(vhost_dev, vdev);
148 }
149
vu_gpio_set_status(VirtIODevice * vdev,uint8_t status)150 static void vu_gpio_set_status(VirtIODevice *vdev, uint8_t status)
151 {
152 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
153 bool should_start = virtio_device_should_start(vdev, status);
154
155 trace_virtio_gpio_set_status(status);
156
157 if (!gpio->connected) {
158 return;
159 }
160
161 if (vhost_dev_is_started(&gpio->vhost_dev) == should_start) {
162 return;
163 }
164
165 if (should_start) {
166 if (vu_gpio_start(vdev)) {
167 qemu_chr_fe_disconnect(&gpio->chardev);
168 }
169 } else {
170 vu_gpio_stop(vdev);
171 }
172 }
173
vu_gpio_get_features(VirtIODevice * vdev,uint64_t features,Error ** errp)174 static uint64_t vu_gpio_get_features(VirtIODevice *vdev, uint64_t features,
175 Error **errp)
176 {
177 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
178
179 return vhost_get_features(&gpio->vhost_dev, feature_bits, features);
180 }
181
vu_gpio_handle_output(VirtIODevice * vdev,VirtQueue * vq)182 static void vu_gpio_handle_output(VirtIODevice *vdev, VirtQueue *vq)
183 {
184 /*
185 * Not normally called; it's the daemon that handles the queue;
186 * however virtio's cleanup path can call this.
187 */
188 }
189
vu_gpio_guest_notifier_mask(VirtIODevice * vdev,int idx,bool mask)190 static void vu_gpio_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask)
191 {
192 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
193
194 /*
195 * Add the check for configure interrupt, Use VIRTIO_CONFIG_IRQ_IDX -1
196 * as the macro of configure interrupt's IDX, If this driver does not
197 * support, the function will return
198 */
199
200 if (idx == VIRTIO_CONFIG_IRQ_IDX) {
201 return;
202 }
203
204 vhost_virtqueue_mask(&gpio->vhost_dev, vdev, idx, mask);
205 }
206
vu_gpio_get_vhost(VirtIODevice * vdev)207 static struct vhost_dev *vu_gpio_get_vhost(VirtIODevice *vdev)
208 {
209 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
210 return &gpio->vhost_dev;
211 }
212
do_vhost_user_cleanup(VirtIODevice * vdev,VHostUserGPIO * gpio)213 static void do_vhost_user_cleanup(VirtIODevice *vdev, VHostUserGPIO *gpio)
214 {
215 virtio_delete_queue(gpio->command_vq);
216 virtio_delete_queue(gpio->interrupt_vq);
217 g_free(gpio->vhost_vqs);
218 virtio_cleanup(vdev);
219 vhost_user_cleanup(&gpio->vhost_user);
220 }
221
vu_gpio_connect(DeviceState * dev,Error ** errp)222 static int vu_gpio_connect(DeviceState *dev, Error **errp)
223 {
224 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
225 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
226 struct vhost_dev *vhost_dev = &gpio->vhost_dev;
227 int ret;
228
229 if (gpio->connected) {
230 return 0;
231 }
232
233 vhost_dev_set_config_notifier(vhost_dev, &gpio_ops);
234 gpio->vhost_user.supports_config = true;
235
236 gpio->vhost_dev.nvqs = VHOST_NVQS;
237 gpio->vhost_dev.vqs = gpio->vhost_vqs;
238
239 ret = vhost_dev_init(vhost_dev, &gpio->vhost_user,
240 VHOST_BACKEND_TYPE_USER, 0, errp);
241 if (ret < 0) {
242 return ret;
243 }
244
245 gpio->connected = true;
246
247 /* restore vhost state */
248 if (virtio_device_started(vdev, vdev->status)) {
249 vu_gpio_start(vdev);
250 }
251
252 return 0;
253 }
254
255 static void vu_gpio_event(void *opaque, QEMUChrEvent event);
256
vu_gpio_disconnect(DeviceState * dev)257 static void vu_gpio_disconnect(DeviceState *dev)
258 {
259 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
260 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
261
262 if (!gpio->connected) {
263 return;
264 }
265 gpio->connected = false;
266
267 vu_gpio_stop(vdev);
268 vhost_dev_cleanup(&gpio->vhost_dev);
269
270 /* Re-instate the event handler for new connections */
271 qemu_chr_fe_set_handlers(&gpio->chardev,
272 NULL, NULL, vu_gpio_event,
273 NULL, dev, NULL, true);
274 }
275
vu_gpio_event(void * opaque,QEMUChrEvent event)276 static void vu_gpio_event(void *opaque, QEMUChrEvent event)
277 {
278 DeviceState *dev = opaque;
279 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
280 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev);
281 Error *local_err = NULL;
282
283 switch (event) {
284 case CHR_EVENT_OPENED:
285 if (vu_gpio_connect(dev, &local_err) < 0) {
286 qemu_chr_fe_disconnect(&gpio->chardev);
287 return;
288 }
289 break;
290 case CHR_EVENT_CLOSED:
291 /* defer close until later to avoid circular close */
292 vhost_user_async_close(dev, &gpio->chardev, &gpio->vhost_dev,
293 vu_gpio_disconnect, vu_gpio_event);
294 break;
295 case CHR_EVENT_BREAK:
296 case CHR_EVENT_MUX_IN:
297 case CHR_EVENT_MUX_OUT:
298 /* Ignore */
299 break;
300 }
301 }
302
vu_gpio_realize_connect(VHostUserGPIO * gpio,Error ** errp)303 static int vu_gpio_realize_connect(VHostUserGPIO *gpio, Error **errp)
304 {
305 VirtIODevice *vdev = &gpio->parent_obj;
306 DeviceState *dev = &vdev->parent_obj;
307 struct vhost_dev *vhost_dev = &gpio->vhost_dev;
308 int ret;
309
310 ret = qemu_chr_fe_wait_connected(&gpio->chardev, errp);
311 if (ret < 0) {
312 return ret;
313 }
314
315 /*
316 * vu_gpio_connect() may have already connected (via the event
317 * callback) in which case it will just report success.
318 */
319 ret = vu_gpio_connect(dev, errp);
320 if (ret < 0) {
321 qemu_chr_fe_disconnect(&gpio->chardev);
322 return ret;
323 }
324 g_assert(gpio->connected);
325
326 ret = vhost_dev_get_config(vhost_dev, (uint8_t *)&gpio->config,
327 sizeof(gpio->config), errp);
328
329 if (ret < 0) {
330 error_report("vhost-user-gpio: get config failed");
331
332 qemu_chr_fe_disconnect(&gpio->chardev);
333 vhost_dev_cleanup(vhost_dev);
334 return ret;
335 }
336
337 return 0;
338 }
339
vu_gpio_device_realize(DeviceState * dev,Error ** errp)340 static void vu_gpio_device_realize(DeviceState *dev, Error **errp)
341 {
342 ERRP_GUARD();
343
344 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
345 VHostUserGPIO *gpio = VHOST_USER_GPIO(dev);
346 int retries, ret;
347
348 if (!gpio->chardev.chr) {
349 error_setg(errp, "vhost-user-gpio: chardev is mandatory");
350 return;
351 }
352
353 if (!vhost_user_init(&gpio->vhost_user, &gpio->chardev, errp)) {
354 return;
355 }
356
357 virtio_init(vdev, VIRTIO_ID_GPIO, sizeof(gpio->config));
358
359 gpio->command_vq = virtio_add_queue(vdev, 256, vu_gpio_handle_output);
360 gpio->interrupt_vq = virtio_add_queue(vdev, 256, vu_gpio_handle_output);
361 gpio->vhost_vqs = g_new0(struct vhost_virtqueue, VHOST_NVQS);
362
363 gpio->connected = false;
364
365 qemu_chr_fe_set_handlers(&gpio->chardev, NULL, NULL, vu_gpio_event, NULL,
366 dev, NULL, true);
367
368 retries = VU_REALIZE_CONN_RETRIES;
369 g_assert(!*errp);
370 do {
371 if (*errp) {
372 error_prepend(errp, "Reconnecting after error: ");
373 error_report_err(*errp);
374 *errp = NULL;
375 }
376 ret = vu_gpio_realize_connect(gpio, errp);
377 } while (ret < 0 && retries--);
378
379 if (ret < 0) {
380 do_vhost_user_cleanup(vdev, gpio);
381 }
382
383 return;
384 }
385
vu_gpio_device_unrealize(DeviceState * dev)386 static void vu_gpio_device_unrealize(DeviceState *dev)
387 {
388 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
389 VHostUserGPIO *gpio = VHOST_USER_GPIO(dev);
390
391 vu_gpio_set_status(vdev, 0);
392 qemu_chr_fe_set_handlers(&gpio->chardev, NULL, NULL, NULL, NULL, NULL, NULL,
393 false);
394 vhost_dev_cleanup(&gpio->vhost_dev);
395 do_vhost_user_cleanup(vdev, gpio);
396 }
397
398 static const VMStateDescription vu_gpio_vmstate = {
399 .name = "vhost-user-gpio",
400 .unmigratable = 1,
401 };
402
403 static Property vu_gpio_properties[] = {
404 DEFINE_PROP_CHR("chardev", VHostUserGPIO, chardev),
405 DEFINE_PROP_END_OF_LIST(),
406 };
407
vu_gpio_class_init(ObjectClass * klass,void * data)408 static void vu_gpio_class_init(ObjectClass *klass, void *data)
409 {
410 DeviceClass *dc = DEVICE_CLASS(klass);
411 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
412
413 device_class_set_props(dc, vu_gpio_properties);
414 dc->vmsd = &vu_gpio_vmstate;
415 set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
416 vdc->realize = vu_gpio_device_realize;
417 vdc->unrealize = vu_gpio_device_unrealize;
418 vdc->get_features = vu_gpio_get_features;
419 vdc->get_config = vu_gpio_get_config;
420 vdc->set_status = vu_gpio_set_status;
421 vdc->guest_notifier_mask = vu_gpio_guest_notifier_mask;
422 vdc->get_vhost = vu_gpio_get_vhost;
423 }
424
425 static const TypeInfo vu_gpio_info = {
426 .name = TYPE_VHOST_USER_GPIO,
427 .parent = TYPE_VIRTIO_DEVICE,
428 .instance_size = sizeof(VHostUserGPIO),
429 .class_init = vu_gpio_class_init,
430 };
431
vu_gpio_register_types(void)432 static void vu_gpio_register_types(void)
433 {
434 type_register_static(&vu_gpio_info);
435 }
436
437 type_init(vu_gpio_register_types)
438