vhost-user-gpio.c (11476B)
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 REALIZE_CONNECTION_RETRIES 3 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 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 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 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 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 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 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 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 190 static void vu_gpio_guest_notifier_mask(VirtIODevice *vdev, int idx, bool mask) 191 { 192 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev); 193 194 vhost_virtqueue_mask(&gpio->vhost_dev, vdev, idx, mask); 195 } 196 197 static void do_vhost_user_cleanup(VirtIODevice *vdev, VHostUserGPIO *gpio) 198 { 199 virtio_delete_queue(gpio->command_vq); 200 virtio_delete_queue(gpio->interrupt_vq); 201 g_free(gpio->vhost_dev.vqs); 202 gpio->vhost_dev.vqs = NULL; 203 virtio_cleanup(vdev); 204 vhost_user_cleanup(&gpio->vhost_user); 205 } 206 207 static int vu_gpio_connect(DeviceState *dev, Error **errp) 208 { 209 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 210 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev); 211 struct vhost_dev *vhost_dev = &gpio->vhost_dev; 212 int ret; 213 214 if (gpio->connected) { 215 return 0; 216 } 217 gpio->connected = true; 218 219 vhost_dev_set_config_notifier(vhost_dev, &gpio_ops); 220 gpio->vhost_user.supports_config = true; 221 222 ret = vhost_dev_init(vhost_dev, &gpio->vhost_user, 223 VHOST_BACKEND_TYPE_USER, 0, errp); 224 if (ret < 0) { 225 return ret; 226 } 227 228 /* restore vhost state */ 229 if (virtio_device_started(vdev, vdev->status)) { 230 vu_gpio_start(vdev); 231 } 232 233 return 0; 234 } 235 236 static void vu_gpio_event(void *opaque, QEMUChrEvent event); 237 238 static void vu_gpio_disconnect(DeviceState *dev) 239 { 240 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 241 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev); 242 243 if (!gpio->connected) { 244 return; 245 } 246 gpio->connected = false; 247 248 vu_gpio_stop(vdev); 249 vhost_dev_cleanup(&gpio->vhost_dev); 250 251 /* Re-instate the event handler for new connections */ 252 qemu_chr_fe_set_handlers(&gpio->chardev, 253 NULL, NULL, vu_gpio_event, 254 NULL, dev, NULL, true); 255 } 256 257 static void vu_gpio_event(void *opaque, QEMUChrEvent event) 258 { 259 DeviceState *dev = opaque; 260 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 261 VHostUserGPIO *gpio = VHOST_USER_GPIO(vdev); 262 Error *local_err = NULL; 263 264 switch (event) { 265 case CHR_EVENT_OPENED: 266 if (vu_gpio_connect(dev, &local_err) < 0) { 267 qemu_chr_fe_disconnect(&gpio->chardev); 268 return; 269 } 270 break; 271 case CHR_EVENT_CLOSED: 272 /* defer close until later to avoid circular close */ 273 vhost_user_async_close(dev, &gpio->chardev, &gpio->vhost_dev, 274 vu_gpio_disconnect); 275 break; 276 case CHR_EVENT_BREAK: 277 case CHR_EVENT_MUX_IN: 278 case CHR_EVENT_MUX_OUT: 279 /* Ignore */ 280 break; 281 } 282 } 283 284 static int vu_gpio_realize_connect(VHostUserGPIO *gpio, Error **errp) 285 { 286 VirtIODevice *vdev = &gpio->parent_obj; 287 DeviceState *dev = &vdev->parent_obj; 288 struct vhost_dev *vhost_dev = &gpio->vhost_dev; 289 int ret; 290 291 ret = qemu_chr_fe_wait_connected(&gpio->chardev, errp); 292 if (ret < 0) { 293 return ret; 294 } 295 296 /* 297 * vu_gpio_connect() may have already connected (via the event 298 * callback) in which case it will just report success. 299 */ 300 ret = vu_gpio_connect(dev, errp); 301 if (ret < 0) { 302 qemu_chr_fe_disconnect(&gpio->chardev); 303 return ret; 304 } 305 g_assert(gpio->connected); 306 307 ret = vhost_dev_get_config(vhost_dev, (uint8_t *)&gpio->config, 308 sizeof(gpio->config), errp); 309 310 if (ret < 0) { 311 error_report("vhost-user-gpio: get config failed"); 312 313 qemu_chr_fe_disconnect(&gpio->chardev); 314 vhost_dev_cleanup(vhost_dev); 315 return ret; 316 } 317 318 return 0; 319 } 320 321 static void vu_gpio_device_realize(DeviceState *dev, Error **errp) 322 { 323 ERRP_GUARD(); 324 325 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 326 VHostUserGPIO *gpio = VHOST_USER_GPIO(dev); 327 int retries, ret; 328 329 if (!gpio->chardev.chr) { 330 error_setg(errp, "vhost-user-gpio: chardev is mandatory"); 331 return; 332 } 333 334 if (!vhost_user_init(&gpio->vhost_user, &gpio->chardev, errp)) { 335 return; 336 } 337 338 virtio_init(vdev, VIRTIO_ID_GPIO, sizeof(gpio->config)); 339 340 gpio->vhost_dev.nvqs = 2; 341 gpio->command_vq = virtio_add_queue(vdev, 256, vu_gpio_handle_output); 342 gpio->interrupt_vq = virtio_add_queue(vdev, 256, vu_gpio_handle_output); 343 gpio->vhost_dev.vqs = g_new0(struct vhost_virtqueue, gpio->vhost_dev.nvqs); 344 345 gpio->connected = false; 346 347 qemu_chr_fe_set_handlers(&gpio->chardev, NULL, NULL, vu_gpio_event, NULL, 348 dev, NULL, true); 349 350 retries = REALIZE_CONNECTION_RETRIES; 351 g_assert(!*errp); 352 do { 353 if (*errp) { 354 error_prepend(errp, "Reconnecting after error: "); 355 error_report_err(*errp); 356 *errp = NULL; 357 } 358 ret = vu_gpio_realize_connect(gpio, errp); 359 } while (ret < 0 && retries--); 360 361 if (ret < 0) { 362 do_vhost_user_cleanup(vdev, gpio); 363 } 364 365 return; 366 } 367 368 static void vu_gpio_device_unrealize(DeviceState *dev) 369 { 370 VirtIODevice *vdev = VIRTIO_DEVICE(dev); 371 VHostUserGPIO *gpio = VHOST_USER_GPIO(dev); 372 373 vu_gpio_set_status(vdev, 0); 374 qemu_chr_fe_set_handlers(&gpio->chardev, NULL, NULL, NULL, NULL, NULL, NULL, 375 false); 376 vhost_dev_cleanup(&gpio->vhost_dev); 377 do_vhost_user_cleanup(vdev, gpio); 378 } 379 380 static const VMStateDescription vu_gpio_vmstate = { 381 .name = "vhost-user-gpio", 382 .unmigratable = 1, 383 }; 384 385 static Property vu_gpio_properties[] = { 386 DEFINE_PROP_CHR("chardev", VHostUserGPIO, chardev), 387 DEFINE_PROP_END_OF_LIST(), 388 }; 389 390 static void vu_gpio_class_init(ObjectClass *klass, void *data) 391 { 392 DeviceClass *dc = DEVICE_CLASS(klass); 393 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass); 394 395 device_class_set_props(dc, vu_gpio_properties); 396 dc->vmsd = &vu_gpio_vmstate; 397 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 398 vdc->realize = vu_gpio_device_realize; 399 vdc->unrealize = vu_gpio_device_unrealize; 400 vdc->get_features = vu_gpio_get_features; 401 vdc->get_config = vu_gpio_get_config; 402 vdc->set_status = vu_gpio_set_status; 403 vdc->guest_notifier_mask = vu_gpio_guest_notifier_mask; 404 } 405 406 static const TypeInfo vu_gpio_info = { 407 .name = TYPE_VHOST_USER_GPIO, 408 .parent = TYPE_VIRTIO_DEVICE, 409 .instance_size = sizeof(VHostUserGPIO), 410 .class_init = vu_gpio_class_init, 411 }; 412 413 static void vu_gpio_register_types(void) 414 { 415 type_register_static(&vu_gpio_info); 416 } 417 418 type_init(vu_gpio_register_types)