1 /* 2 * Virtio PCI Bindings 3 * 4 * Copyright IBM, Corp. 2007 5 * Copyright (c) 2009 CodeSourcery 6 * 7 * Authors: 8 * Anthony Liguori <aliguori@us.ibm.com> 9 * Paul Brook <paul@codesourcery.com> 10 * 11 * This work is licensed under the terms of the GNU GPL, version 2. See 12 * the COPYING file in the top-level directory. 13 * 14 * Contributions after 2012-01-13 are licensed under the terms of the 15 * GNU GPL, version 2 or (at your option) any later version. 16 */ 17 18 #include <inttypes.h> 19 20 #include "standard-headers/linux/virtio_pci.h" 21 #include "hw/virtio/virtio.h" 22 #include "hw/virtio/virtio-blk.h" 23 #include "hw/virtio/virtio-net.h" 24 #include "hw/virtio/virtio-serial.h" 25 #include "hw/virtio/virtio-scsi.h" 26 #include "hw/virtio/virtio-balloon.h" 27 #include "hw/pci/pci.h" 28 #include "qemu/error-report.h" 29 #include "hw/pci/msi.h" 30 #include "hw/pci/msix.h" 31 #include "hw/loader.h" 32 #include "sysemu/kvm.h" 33 #include "sysemu/block-backend.h" 34 #include "virtio-pci.h" 35 #include "qemu/range.h" 36 #include "hw/virtio/virtio-bus.h" 37 #include "qapi/visitor.h" 38 39 #define VIRTIO_PCI_REGION_SIZE(dev) VIRTIO_PCI_CONFIG_OFF(msix_present(dev)) 40 41 /* The remaining space is defined by each driver as the per-driver 42 * configuration space */ 43 #define VIRTIO_PCI_CONFIG_SIZE(dev) VIRTIO_PCI_CONFIG_OFF(msix_enabled(dev)) 44 45 static void virtio_pci_bus_new(VirtioBusState *bus, size_t bus_size, 46 VirtIOPCIProxy *dev); 47 48 /* virtio device */ 49 /* DeviceState to VirtIOPCIProxy. For use off data-path. TODO: use QOM. */ 50 static inline VirtIOPCIProxy *to_virtio_pci_proxy(DeviceState *d) 51 { 52 return container_of(d, VirtIOPCIProxy, pci_dev.qdev); 53 } 54 55 /* DeviceState to VirtIOPCIProxy. Note: used on datapath, 56 * be careful and test performance if you change this. 57 */ 58 static inline VirtIOPCIProxy *to_virtio_pci_proxy_fast(DeviceState *d) 59 { 60 return container_of(d, VirtIOPCIProxy, pci_dev.qdev); 61 } 62 63 static void virtio_pci_notify(DeviceState *d, uint16_t vector) 64 { 65 VirtIOPCIProxy *proxy = to_virtio_pci_proxy_fast(d); 66 67 if (msix_enabled(&proxy->pci_dev)) 68 msix_notify(&proxy->pci_dev, vector); 69 else { 70 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 71 pci_set_irq(&proxy->pci_dev, vdev->isr & 1); 72 } 73 } 74 75 static void virtio_pci_save_config(DeviceState *d, QEMUFile *f) 76 { 77 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 78 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 79 80 pci_device_save(&proxy->pci_dev, f); 81 msix_save(&proxy->pci_dev, f); 82 if (msix_present(&proxy->pci_dev)) 83 qemu_put_be16(f, vdev->config_vector); 84 } 85 86 static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f) 87 { 88 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 89 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 90 91 if (msix_present(&proxy->pci_dev)) 92 qemu_put_be16(f, virtio_queue_vector(vdev, n)); 93 } 94 95 static int virtio_pci_load_config(DeviceState *d, QEMUFile *f) 96 { 97 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 98 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 99 100 int ret; 101 ret = pci_device_load(&proxy->pci_dev, f); 102 if (ret) { 103 return ret; 104 } 105 msix_unuse_all_vectors(&proxy->pci_dev); 106 msix_load(&proxy->pci_dev, f); 107 if (msix_present(&proxy->pci_dev)) { 108 qemu_get_be16s(f, &vdev->config_vector); 109 } else { 110 vdev->config_vector = VIRTIO_NO_VECTOR; 111 } 112 if (vdev->config_vector != VIRTIO_NO_VECTOR) { 113 return msix_vector_use(&proxy->pci_dev, vdev->config_vector); 114 } 115 return 0; 116 } 117 118 static int virtio_pci_load_queue(DeviceState *d, int n, QEMUFile *f) 119 { 120 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 121 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 122 123 uint16_t vector; 124 if (msix_present(&proxy->pci_dev)) { 125 qemu_get_be16s(f, &vector); 126 } else { 127 vector = VIRTIO_NO_VECTOR; 128 } 129 virtio_queue_set_vector(vdev, n, vector); 130 if (vector != VIRTIO_NO_VECTOR) { 131 return msix_vector_use(&proxy->pci_dev, vector); 132 } 133 return 0; 134 } 135 136 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy, 137 int n, bool assign, bool set_handler) 138 { 139 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 140 VirtQueue *vq = virtio_get_queue(vdev, n); 141 EventNotifier *notifier = virtio_queue_get_host_notifier(vq); 142 int r = 0; 143 144 if (assign) { 145 r = event_notifier_init(notifier, 1); 146 if (r < 0) { 147 error_report("%s: unable to init event notifier: %d", 148 __func__, r); 149 return r; 150 } 151 virtio_queue_set_host_notifier_fd_handler(vq, true, set_handler); 152 memory_region_add_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2, 153 true, n, notifier); 154 } else { 155 memory_region_del_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2, 156 true, n, notifier); 157 virtio_queue_set_host_notifier_fd_handler(vq, false, false); 158 event_notifier_cleanup(notifier); 159 } 160 return r; 161 } 162 163 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy) 164 { 165 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 166 int n, r; 167 168 if (!(proxy->flags & VIRTIO_PCI_FLAG_USE_IOEVENTFD) || 169 proxy->ioeventfd_disabled || 170 proxy->ioeventfd_started) { 171 return; 172 } 173 174 for (n = 0; n < VIRTIO_QUEUE_MAX; n++) { 175 if (!virtio_queue_get_num(vdev, n)) { 176 continue; 177 } 178 179 r = virtio_pci_set_host_notifier_internal(proxy, n, true, true); 180 if (r < 0) { 181 goto assign_error; 182 } 183 } 184 proxy->ioeventfd_started = true; 185 return; 186 187 assign_error: 188 while (--n >= 0) { 189 if (!virtio_queue_get_num(vdev, n)) { 190 continue; 191 } 192 193 r = virtio_pci_set_host_notifier_internal(proxy, n, false, false); 194 assert(r >= 0); 195 } 196 proxy->ioeventfd_started = false; 197 error_report("%s: failed. Fallback to a userspace (slower).", __func__); 198 } 199 200 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy) 201 { 202 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 203 int r; 204 int n; 205 206 if (!proxy->ioeventfd_started) { 207 return; 208 } 209 210 for (n = 0; n < VIRTIO_QUEUE_MAX; n++) { 211 if (!virtio_queue_get_num(vdev, n)) { 212 continue; 213 } 214 215 r = virtio_pci_set_host_notifier_internal(proxy, n, false, false); 216 assert(r >= 0); 217 } 218 proxy->ioeventfd_started = false; 219 } 220 221 static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val) 222 { 223 VirtIOPCIProxy *proxy = opaque; 224 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 225 hwaddr pa; 226 227 switch (addr) { 228 case VIRTIO_PCI_GUEST_FEATURES: 229 /* Guest does not negotiate properly? We have to assume nothing. */ 230 if (val & (1 << VIRTIO_F_BAD_FEATURE)) { 231 val = virtio_bus_get_vdev_bad_features(&proxy->bus); 232 } 233 virtio_set_features(vdev, val); 234 break; 235 case VIRTIO_PCI_QUEUE_PFN: 236 pa = (hwaddr)val << VIRTIO_PCI_QUEUE_ADDR_SHIFT; 237 if (pa == 0) { 238 virtio_pci_stop_ioeventfd(proxy); 239 virtio_reset(vdev); 240 msix_unuse_all_vectors(&proxy->pci_dev); 241 } 242 else 243 virtio_queue_set_addr(vdev, vdev->queue_sel, pa); 244 break; 245 case VIRTIO_PCI_QUEUE_SEL: 246 if (val < VIRTIO_QUEUE_MAX) 247 vdev->queue_sel = val; 248 break; 249 case VIRTIO_PCI_QUEUE_NOTIFY: 250 if (val < VIRTIO_QUEUE_MAX) { 251 virtio_queue_notify(vdev, val); 252 } 253 break; 254 case VIRTIO_PCI_STATUS: 255 if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) { 256 virtio_pci_stop_ioeventfd(proxy); 257 } 258 259 virtio_set_status(vdev, val & 0xFF); 260 261 if (val & VIRTIO_CONFIG_S_DRIVER_OK) { 262 virtio_pci_start_ioeventfd(proxy); 263 } 264 265 if (vdev->status == 0) { 266 virtio_reset(vdev); 267 msix_unuse_all_vectors(&proxy->pci_dev); 268 } 269 270 /* Linux before 2.6.34 drives the device without enabling 271 the PCI device bus master bit. Enable it automatically 272 for the guest. This is a PCI spec violation but so is 273 initiating DMA with bus master bit clear. */ 274 if (val == (VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER)) { 275 pci_default_write_config(&proxy->pci_dev, PCI_COMMAND, 276 proxy->pci_dev.config[PCI_COMMAND] | 277 PCI_COMMAND_MASTER, 1); 278 } 279 break; 280 case VIRTIO_MSI_CONFIG_VECTOR: 281 msix_vector_unuse(&proxy->pci_dev, vdev->config_vector); 282 /* Make it possible for guest to discover an error took place. */ 283 if (msix_vector_use(&proxy->pci_dev, val) < 0) 284 val = VIRTIO_NO_VECTOR; 285 vdev->config_vector = val; 286 break; 287 case VIRTIO_MSI_QUEUE_VECTOR: 288 msix_vector_unuse(&proxy->pci_dev, 289 virtio_queue_vector(vdev, vdev->queue_sel)); 290 /* Make it possible for guest to discover an error took place. */ 291 if (msix_vector_use(&proxy->pci_dev, val) < 0) 292 val = VIRTIO_NO_VECTOR; 293 virtio_queue_set_vector(vdev, vdev->queue_sel, val); 294 break; 295 default: 296 error_report("%s: unexpected address 0x%x value 0x%x", 297 __func__, addr, val); 298 break; 299 } 300 } 301 302 static uint32_t virtio_ioport_read(VirtIOPCIProxy *proxy, uint32_t addr) 303 { 304 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 305 uint32_t ret = 0xFFFFFFFF; 306 307 switch (addr) { 308 case VIRTIO_PCI_HOST_FEATURES: 309 ret = vdev->host_features; 310 break; 311 case VIRTIO_PCI_GUEST_FEATURES: 312 ret = vdev->guest_features; 313 break; 314 case VIRTIO_PCI_QUEUE_PFN: 315 ret = virtio_queue_get_addr(vdev, vdev->queue_sel) 316 >> VIRTIO_PCI_QUEUE_ADDR_SHIFT; 317 break; 318 case VIRTIO_PCI_QUEUE_NUM: 319 ret = virtio_queue_get_num(vdev, vdev->queue_sel); 320 break; 321 case VIRTIO_PCI_QUEUE_SEL: 322 ret = vdev->queue_sel; 323 break; 324 case VIRTIO_PCI_STATUS: 325 ret = vdev->status; 326 break; 327 case VIRTIO_PCI_ISR: 328 /* reading from the ISR also clears it. */ 329 ret = vdev->isr; 330 vdev->isr = 0; 331 pci_irq_deassert(&proxy->pci_dev); 332 break; 333 case VIRTIO_MSI_CONFIG_VECTOR: 334 ret = vdev->config_vector; 335 break; 336 case VIRTIO_MSI_QUEUE_VECTOR: 337 ret = virtio_queue_vector(vdev, vdev->queue_sel); 338 break; 339 default: 340 break; 341 } 342 343 return ret; 344 } 345 346 static uint64_t virtio_pci_config_read(void *opaque, hwaddr addr, 347 unsigned size) 348 { 349 VirtIOPCIProxy *proxy = opaque; 350 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 351 uint32_t config = VIRTIO_PCI_CONFIG_SIZE(&proxy->pci_dev); 352 uint64_t val = 0; 353 if (addr < config) { 354 return virtio_ioport_read(proxy, addr); 355 } 356 addr -= config; 357 358 switch (size) { 359 case 1: 360 val = virtio_config_readb(vdev, addr); 361 break; 362 case 2: 363 val = virtio_config_readw(vdev, addr); 364 if (virtio_is_big_endian(vdev)) { 365 val = bswap16(val); 366 } 367 break; 368 case 4: 369 val = virtio_config_readl(vdev, addr); 370 if (virtio_is_big_endian(vdev)) { 371 val = bswap32(val); 372 } 373 break; 374 } 375 return val; 376 } 377 378 static void virtio_pci_config_write(void *opaque, hwaddr addr, 379 uint64_t val, unsigned size) 380 { 381 VirtIOPCIProxy *proxy = opaque; 382 uint32_t config = VIRTIO_PCI_CONFIG_SIZE(&proxy->pci_dev); 383 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 384 if (addr < config) { 385 virtio_ioport_write(proxy, addr, val); 386 return; 387 } 388 addr -= config; 389 /* 390 * Virtio-PCI is odd. Ioports are LE but config space is target native 391 * endian. 392 */ 393 switch (size) { 394 case 1: 395 virtio_config_writeb(vdev, addr, val); 396 break; 397 case 2: 398 if (virtio_is_big_endian(vdev)) { 399 val = bswap16(val); 400 } 401 virtio_config_writew(vdev, addr, val); 402 break; 403 case 4: 404 if (virtio_is_big_endian(vdev)) { 405 val = bswap32(val); 406 } 407 virtio_config_writel(vdev, addr, val); 408 break; 409 } 410 } 411 412 static const MemoryRegionOps virtio_pci_config_ops = { 413 .read = virtio_pci_config_read, 414 .write = virtio_pci_config_write, 415 .impl = { 416 .min_access_size = 1, 417 .max_access_size = 4, 418 }, 419 .endianness = DEVICE_LITTLE_ENDIAN, 420 }; 421 422 static void virtio_write_config(PCIDevice *pci_dev, uint32_t address, 423 uint32_t val, int len) 424 { 425 VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev); 426 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 427 428 pci_default_write_config(pci_dev, address, val, len); 429 430 if (range_covers_byte(address, len, PCI_COMMAND) && 431 !(pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER)) { 432 virtio_pci_stop_ioeventfd(proxy); 433 virtio_set_status(vdev, vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK); 434 } 435 } 436 437 static int kvm_virtio_pci_vq_vector_use(VirtIOPCIProxy *proxy, 438 unsigned int queue_no, 439 unsigned int vector, 440 MSIMessage msg) 441 { 442 VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector]; 443 int ret; 444 445 if (irqfd->users == 0) { 446 ret = kvm_irqchip_add_msi_route(kvm_state, msg); 447 if (ret < 0) { 448 return ret; 449 } 450 irqfd->virq = ret; 451 } 452 irqfd->users++; 453 return 0; 454 } 455 456 static void kvm_virtio_pci_vq_vector_release(VirtIOPCIProxy *proxy, 457 unsigned int vector) 458 { 459 VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector]; 460 if (--irqfd->users == 0) { 461 kvm_irqchip_release_virq(kvm_state, irqfd->virq); 462 } 463 } 464 465 static int kvm_virtio_pci_irqfd_use(VirtIOPCIProxy *proxy, 466 unsigned int queue_no, 467 unsigned int vector) 468 { 469 VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector]; 470 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 471 VirtQueue *vq = virtio_get_queue(vdev, queue_no); 472 EventNotifier *n = virtio_queue_get_guest_notifier(vq); 473 int ret; 474 ret = kvm_irqchip_add_irqfd_notifier(kvm_state, n, NULL, irqfd->virq); 475 return ret; 476 } 477 478 static void kvm_virtio_pci_irqfd_release(VirtIOPCIProxy *proxy, 479 unsigned int queue_no, 480 unsigned int vector) 481 { 482 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 483 VirtQueue *vq = virtio_get_queue(vdev, queue_no); 484 EventNotifier *n = virtio_queue_get_guest_notifier(vq); 485 VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector]; 486 int ret; 487 488 ret = kvm_irqchip_remove_irqfd_notifier(kvm_state, n, irqfd->virq); 489 assert(ret == 0); 490 } 491 492 static int kvm_virtio_pci_vector_use(VirtIOPCIProxy *proxy, int nvqs) 493 { 494 PCIDevice *dev = &proxy->pci_dev; 495 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 496 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 497 unsigned int vector; 498 int ret, queue_no; 499 MSIMessage msg; 500 501 for (queue_no = 0; queue_no < nvqs; queue_no++) { 502 if (!virtio_queue_get_num(vdev, queue_no)) { 503 break; 504 } 505 vector = virtio_queue_vector(vdev, queue_no); 506 if (vector >= msix_nr_vectors_allocated(dev)) { 507 continue; 508 } 509 msg = msix_get_message(dev, vector); 510 ret = kvm_virtio_pci_vq_vector_use(proxy, queue_no, vector, msg); 511 if (ret < 0) { 512 goto undo; 513 } 514 /* If guest supports masking, set up irqfd now. 515 * Otherwise, delay until unmasked in the frontend. 516 */ 517 if (k->guest_notifier_mask) { 518 ret = kvm_virtio_pci_irqfd_use(proxy, queue_no, vector); 519 if (ret < 0) { 520 kvm_virtio_pci_vq_vector_release(proxy, vector); 521 goto undo; 522 } 523 } 524 } 525 return 0; 526 527 undo: 528 while (--queue_no >= 0) { 529 vector = virtio_queue_vector(vdev, queue_no); 530 if (vector >= msix_nr_vectors_allocated(dev)) { 531 continue; 532 } 533 if (k->guest_notifier_mask) { 534 kvm_virtio_pci_irqfd_release(proxy, queue_no, vector); 535 } 536 kvm_virtio_pci_vq_vector_release(proxy, vector); 537 } 538 return ret; 539 } 540 541 static void kvm_virtio_pci_vector_release(VirtIOPCIProxy *proxy, int nvqs) 542 { 543 PCIDevice *dev = &proxy->pci_dev; 544 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 545 unsigned int vector; 546 int queue_no; 547 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 548 549 for (queue_no = 0; queue_no < nvqs; queue_no++) { 550 if (!virtio_queue_get_num(vdev, queue_no)) { 551 break; 552 } 553 vector = virtio_queue_vector(vdev, queue_no); 554 if (vector >= msix_nr_vectors_allocated(dev)) { 555 continue; 556 } 557 /* If guest supports masking, clean up irqfd now. 558 * Otherwise, it was cleaned when masked in the frontend. 559 */ 560 if (k->guest_notifier_mask) { 561 kvm_virtio_pci_irqfd_release(proxy, queue_no, vector); 562 } 563 kvm_virtio_pci_vq_vector_release(proxy, vector); 564 } 565 } 566 567 static int virtio_pci_vq_vector_unmask(VirtIOPCIProxy *proxy, 568 unsigned int queue_no, 569 unsigned int vector, 570 MSIMessage msg) 571 { 572 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 573 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 574 VirtQueue *vq = virtio_get_queue(vdev, queue_no); 575 EventNotifier *n = virtio_queue_get_guest_notifier(vq); 576 VirtIOIRQFD *irqfd; 577 int ret = 0; 578 579 if (proxy->vector_irqfd) { 580 irqfd = &proxy->vector_irqfd[vector]; 581 if (irqfd->msg.data != msg.data || irqfd->msg.address != msg.address) { 582 ret = kvm_irqchip_update_msi_route(kvm_state, irqfd->virq, msg); 583 if (ret < 0) { 584 return ret; 585 } 586 } 587 } 588 589 /* If guest supports masking, irqfd is already setup, unmask it. 590 * Otherwise, set it up now. 591 */ 592 if (k->guest_notifier_mask) { 593 k->guest_notifier_mask(vdev, queue_no, false); 594 /* Test after unmasking to avoid losing events. */ 595 if (k->guest_notifier_pending && 596 k->guest_notifier_pending(vdev, queue_no)) { 597 event_notifier_set(n); 598 } 599 } else { 600 ret = kvm_virtio_pci_irqfd_use(proxy, queue_no, vector); 601 } 602 return ret; 603 } 604 605 static void virtio_pci_vq_vector_mask(VirtIOPCIProxy *proxy, 606 unsigned int queue_no, 607 unsigned int vector) 608 { 609 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 610 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 611 612 /* If guest supports masking, keep irqfd but mask it. 613 * Otherwise, clean it up now. 614 */ 615 if (k->guest_notifier_mask) { 616 k->guest_notifier_mask(vdev, queue_no, true); 617 } else { 618 kvm_virtio_pci_irqfd_release(proxy, queue_no, vector); 619 } 620 } 621 622 static int virtio_pci_vector_unmask(PCIDevice *dev, unsigned vector, 623 MSIMessage msg) 624 { 625 VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev); 626 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 627 VirtQueue *vq = virtio_vector_first_queue(vdev, vector); 628 int ret, index, unmasked = 0; 629 630 while (vq) { 631 index = virtio_get_queue_index(vq); 632 if (!virtio_queue_get_num(vdev, index)) { 633 break; 634 } 635 if (index < proxy->nvqs_with_notifiers) { 636 ret = virtio_pci_vq_vector_unmask(proxy, index, vector, msg); 637 if (ret < 0) { 638 goto undo; 639 } 640 ++unmasked; 641 } 642 vq = virtio_vector_next_queue(vq); 643 } 644 645 return 0; 646 647 undo: 648 vq = virtio_vector_first_queue(vdev, vector); 649 while (vq && unmasked >= 0) { 650 index = virtio_get_queue_index(vq); 651 if (index < proxy->nvqs_with_notifiers) { 652 virtio_pci_vq_vector_mask(proxy, index, vector); 653 --unmasked; 654 } 655 vq = virtio_vector_next_queue(vq); 656 } 657 return ret; 658 } 659 660 static void virtio_pci_vector_mask(PCIDevice *dev, unsigned vector) 661 { 662 VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev); 663 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 664 VirtQueue *vq = virtio_vector_first_queue(vdev, vector); 665 int index; 666 667 while (vq) { 668 index = virtio_get_queue_index(vq); 669 if (!virtio_queue_get_num(vdev, index)) { 670 break; 671 } 672 if (index < proxy->nvqs_with_notifiers) { 673 virtio_pci_vq_vector_mask(proxy, index, vector); 674 } 675 vq = virtio_vector_next_queue(vq); 676 } 677 } 678 679 static void virtio_pci_vector_poll(PCIDevice *dev, 680 unsigned int vector_start, 681 unsigned int vector_end) 682 { 683 VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev); 684 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 685 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 686 int queue_no; 687 unsigned int vector; 688 EventNotifier *notifier; 689 VirtQueue *vq; 690 691 for (queue_no = 0; queue_no < proxy->nvqs_with_notifiers; queue_no++) { 692 if (!virtio_queue_get_num(vdev, queue_no)) { 693 break; 694 } 695 vector = virtio_queue_vector(vdev, queue_no); 696 if (vector < vector_start || vector >= vector_end || 697 !msix_is_masked(dev, vector)) { 698 continue; 699 } 700 vq = virtio_get_queue(vdev, queue_no); 701 notifier = virtio_queue_get_guest_notifier(vq); 702 if (k->guest_notifier_pending) { 703 if (k->guest_notifier_pending(vdev, queue_no)) { 704 msix_set_pending(dev, vector); 705 } 706 } else if (event_notifier_test_and_clear(notifier)) { 707 msix_set_pending(dev, vector); 708 } 709 } 710 } 711 712 static int virtio_pci_set_guest_notifier(DeviceState *d, int n, bool assign, 713 bool with_irqfd) 714 { 715 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 716 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 717 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); 718 VirtQueue *vq = virtio_get_queue(vdev, n); 719 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 720 721 if (assign) { 722 int r = event_notifier_init(notifier, 0); 723 if (r < 0) { 724 return r; 725 } 726 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd); 727 } else { 728 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd); 729 event_notifier_cleanup(notifier); 730 } 731 732 if (!msix_enabled(&proxy->pci_dev) && vdc->guest_notifier_mask) { 733 vdc->guest_notifier_mask(vdev, n, !assign); 734 } 735 736 return 0; 737 } 738 739 static bool virtio_pci_query_guest_notifiers(DeviceState *d) 740 { 741 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 742 return msix_enabled(&proxy->pci_dev); 743 } 744 745 static int virtio_pci_set_guest_notifiers(DeviceState *d, int nvqs, bool assign) 746 { 747 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 748 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 749 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 750 int r, n; 751 bool with_irqfd = msix_enabled(&proxy->pci_dev) && 752 kvm_msi_via_irqfd_enabled(); 753 754 nvqs = MIN(nvqs, VIRTIO_QUEUE_MAX); 755 756 /* When deassigning, pass a consistent nvqs value 757 * to avoid leaking notifiers. 758 */ 759 assert(assign || nvqs == proxy->nvqs_with_notifiers); 760 761 proxy->nvqs_with_notifiers = nvqs; 762 763 /* Must unset vector notifier while guest notifier is still assigned */ 764 if ((proxy->vector_irqfd || k->guest_notifier_mask) && !assign) { 765 msix_unset_vector_notifiers(&proxy->pci_dev); 766 if (proxy->vector_irqfd) { 767 kvm_virtio_pci_vector_release(proxy, nvqs); 768 g_free(proxy->vector_irqfd); 769 proxy->vector_irqfd = NULL; 770 } 771 } 772 773 for (n = 0; n < nvqs; n++) { 774 if (!virtio_queue_get_num(vdev, n)) { 775 break; 776 } 777 778 r = virtio_pci_set_guest_notifier(d, n, assign, with_irqfd); 779 if (r < 0) { 780 goto assign_error; 781 } 782 } 783 784 /* Must set vector notifier after guest notifier has been assigned */ 785 if ((with_irqfd || k->guest_notifier_mask) && assign) { 786 if (with_irqfd) { 787 proxy->vector_irqfd = 788 g_malloc0(sizeof(*proxy->vector_irqfd) * 789 msix_nr_vectors_allocated(&proxy->pci_dev)); 790 r = kvm_virtio_pci_vector_use(proxy, nvqs); 791 if (r < 0) { 792 goto assign_error; 793 } 794 } 795 r = msix_set_vector_notifiers(&proxy->pci_dev, 796 virtio_pci_vector_unmask, 797 virtio_pci_vector_mask, 798 virtio_pci_vector_poll); 799 if (r < 0) { 800 goto notifiers_error; 801 } 802 } 803 804 return 0; 805 806 notifiers_error: 807 if (with_irqfd) { 808 assert(assign); 809 kvm_virtio_pci_vector_release(proxy, nvqs); 810 } 811 812 assign_error: 813 /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */ 814 assert(assign); 815 while (--n >= 0) { 816 virtio_pci_set_guest_notifier(d, n, !assign, with_irqfd); 817 } 818 return r; 819 } 820 821 static int virtio_pci_set_host_notifier(DeviceState *d, int n, bool assign) 822 { 823 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 824 825 /* Stop using ioeventfd for virtqueue kick if the device starts using host 826 * notifiers. This makes it easy to avoid stepping on each others' toes. 827 */ 828 proxy->ioeventfd_disabled = assign; 829 if (assign) { 830 virtio_pci_stop_ioeventfd(proxy); 831 } 832 /* We don't need to start here: it's not needed because backend 833 * currently only stops on status change away from ok, 834 * reset, vmstop and such. If we do add code to start here, 835 * need to check vmstate, device state etc. */ 836 return virtio_pci_set_host_notifier_internal(proxy, n, assign, false); 837 } 838 839 static void virtio_pci_vmstate_change(DeviceState *d, bool running) 840 { 841 VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d); 842 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 843 844 if (running) { 845 /* Old QEMU versions did not set bus master enable on status write. 846 * Detect DRIVER set and enable it. 847 */ 848 if ((proxy->flags & VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION) && 849 (vdev->status & VIRTIO_CONFIG_S_DRIVER) && 850 !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) { 851 pci_default_write_config(&proxy->pci_dev, PCI_COMMAND, 852 proxy->pci_dev.config[PCI_COMMAND] | 853 PCI_COMMAND_MASTER, 1); 854 } 855 virtio_pci_start_ioeventfd(proxy); 856 } else { 857 virtio_pci_stop_ioeventfd(proxy); 858 } 859 } 860 861 #ifdef CONFIG_VIRTFS 862 static void virtio_9p_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) 863 { 864 V9fsPCIState *dev = VIRTIO_9P_PCI(vpci_dev); 865 DeviceState *vdev = DEVICE(&dev->vdev); 866 867 qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus)); 868 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 869 } 870 871 static Property virtio_9p_pci_properties[] = { 872 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, 873 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true), 874 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2), 875 DEFINE_PROP_END_OF_LIST(), 876 }; 877 878 static void virtio_9p_pci_class_init(ObjectClass *klass, void *data) 879 { 880 DeviceClass *dc = DEVICE_CLASS(klass); 881 PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass); 882 VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass); 883 884 k->realize = virtio_9p_pci_realize; 885 pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 886 pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_9P; 887 pcidev_k->revision = VIRTIO_PCI_ABI_VERSION; 888 pcidev_k->class_id = 0x2; 889 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 890 dc->props = virtio_9p_pci_properties; 891 } 892 893 static void virtio_9p_pci_instance_init(Object *obj) 894 { 895 V9fsPCIState *dev = VIRTIO_9P_PCI(obj); 896 897 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 898 TYPE_VIRTIO_9P); 899 } 900 901 static const TypeInfo virtio_9p_pci_info = { 902 .name = TYPE_VIRTIO_9P_PCI, 903 .parent = TYPE_VIRTIO_PCI, 904 .instance_size = sizeof(V9fsPCIState), 905 .instance_init = virtio_9p_pci_instance_init, 906 .class_init = virtio_9p_pci_class_init, 907 }; 908 #endif /* CONFIG_VIRTFS */ 909 910 /* 911 * virtio-pci: This is the PCIDevice which has a virtio-pci-bus. 912 */ 913 914 static int virtio_pci_query_nvectors(DeviceState *d) 915 { 916 VirtIOPCIProxy *proxy = VIRTIO_PCI(d); 917 918 return proxy->nvectors; 919 } 920 921 /* This is called by virtio-bus just after the device is plugged. */ 922 static void virtio_pci_device_plugged(DeviceState *d, Error **errp) 923 { 924 VirtIOPCIProxy *proxy = VIRTIO_PCI(d); 925 VirtioBusState *bus = &proxy->bus; 926 uint8_t *config; 927 uint32_t size; 928 VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus); 929 930 config = proxy->pci_dev.config; 931 if (proxy->class_code) { 932 pci_config_set_class(config, proxy->class_code); 933 } 934 pci_set_word(config + PCI_SUBSYSTEM_VENDOR_ID, 935 pci_get_word(config + PCI_VENDOR_ID)); 936 pci_set_word(config + PCI_SUBSYSTEM_ID, virtio_bus_get_vdev_id(bus)); 937 config[PCI_INTERRUPT_PIN] = 1; 938 939 if (proxy->nvectors && 940 msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors, 1)) { 941 error_report("unable to init msix vectors to %" PRIu32, 942 proxy->nvectors); 943 proxy->nvectors = 0; 944 } 945 946 proxy->pci_dev.config_write = virtio_write_config; 947 948 size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev) 949 + virtio_bus_get_vdev_config_len(bus); 950 if (size & (size - 1)) { 951 size = 1 << qemu_fls(size); 952 } 953 954 memory_region_init_io(&proxy->bar, OBJECT(proxy), &virtio_pci_config_ops, 955 proxy, "virtio-pci", size); 956 pci_register_bar(&proxy->pci_dev, 0, PCI_BASE_ADDRESS_SPACE_IO, 957 &proxy->bar); 958 959 if (!kvm_has_many_ioeventfds()) { 960 proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD; 961 } 962 963 virtio_add_feature(&vdev->host_features, VIRTIO_F_BAD_FEATURE); 964 } 965 966 static void virtio_pci_device_unplugged(DeviceState *d) 967 { 968 VirtIOPCIProxy *proxy = VIRTIO_PCI(d); 969 970 virtio_pci_stop_ioeventfd(proxy); 971 } 972 973 static void virtio_pci_realize(PCIDevice *pci_dev, Error **errp) 974 { 975 VirtIOPCIProxy *dev = VIRTIO_PCI(pci_dev); 976 VirtioPCIClass *k = VIRTIO_PCI_GET_CLASS(pci_dev); 977 978 virtio_pci_bus_new(&dev->bus, sizeof(dev->bus), dev); 979 if (k->realize) { 980 k->realize(dev, errp); 981 } 982 } 983 984 static void virtio_pci_exit(PCIDevice *pci_dev) 985 { 986 msix_uninit_exclusive_bar(pci_dev); 987 } 988 989 static void virtio_pci_reset(DeviceState *qdev) 990 { 991 VirtIOPCIProxy *proxy = VIRTIO_PCI(qdev); 992 VirtioBusState *bus = VIRTIO_BUS(&proxy->bus); 993 virtio_pci_stop_ioeventfd(proxy); 994 virtio_bus_reset(bus); 995 msix_unuse_all_vectors(&proxy->pci_dev); 996 } 997 998 static Property virtio_pci_properties[] = { 999 DEFINE_PROP_BIT("virtio-pci-bus-master-bug-migration", VirtIOPCIProxy, flags, 1000 VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT, false), 1001 DEFINE_PROP_END_OF_LIST(), 1002 }; 1003 1004 static void virtio_pci_class_init(ObjectClass *klass, void *data) 1005 { 1006 DeviceClass *dc = DEVICE_CLASS(klass); 1007 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); 1008 1009 dc->props = virtio_pci_properties; 1010 k->realize = virtio_pci_realize; 1011 k->exit = virtio_pci_exit; 1012 k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 1013 k->revision = VIRTIO_PCI_ABI_VERSION; 1014 k->class_id = PCI_CLASS_OTHERS; 1015 dc->reset = virtio_pci_reset; 1016 } 1017 1018 static const TypeInfo virtio_pci_info = { 1019 .name = TYPE_VIRTIO_PCI, 1020 .parent = TYPE_PCI_DEVICE, 1021 .instance_size = sizeof(VirtIOPCIProxy), 1022 .class_init = virtio_pci_class_init, 1023 .class_size = sizeof(VirtioPCIClass), 1024 .abstract = true, 1025 }; 1026 1027 /* virtio-blk-pci */ 1028 1029 static Property virtio_blk_pci_properties[] = { 1030 DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0), 1031 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, 1032 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true), 1033 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2), 1034 DEFINE_PROP_END_OF_LIST(), 1035 }; 1036 1037 static void virtio_blk_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) 1038 { 1039 VirtIOBlkPCI *dev = VIRTIO_BLK_PCI(vpci_dev); 1040 DeviceState *vdev = DEVICE(&dev->vdev); 1041 1042 qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus)); 1043 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 1044 } 1045 1046 static void virtio_blk_pci_class_init(ObjectClass *klass, void *data) 1047 { 1048 DeviceClass *dc = DEVICE_CLASS(klass); 1049 VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass); 1050 PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass); 1051 1052 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1053 dc->props = virtio_blk_pci_properties; 1054 k->realize = virtio_blk_pci_realize; 1055 pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 1056 pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BLOCK; 1057 pcidev_k->revision = VIRTIO_PCI_ABI_VERSION; 1058 pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI; 1059 } 1060 1061 static void virtio_blk_pci_instance_init(Object *obj) 1062 { 1063 VirtIOBlkPCI *dev = VIRTIO_BLK_PCI(obj); 1064 1065 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1066 TYPE_VIRTIO_BLK); 1067 object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev),"iothread", 1068 &error_abort); 1069 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev), 1070 "bootindex", &error_abort); 1071 } 1072 1073 static const TypeInfo virtio_blk_pci_info = { 1074 .name = TYPE_VIRTIO_BLK_PCI, 1075 .parent = TYPE_VIRTIO_PCI, 1076 .instance_size = sizeof(VirtIOBlkPCI), 1077 .instance_init = virtio_blk_pci_instance_init, 1078 .class_init = virtio_blk_pci_class_init, 1079 }; 1080 1081 /* virtio-scsi-pci */ 1082 1083 static Property virtio_scsi_pci_properties[] = { 1084 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, 1085 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true), 1086 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 1087 DEV_NVECTORS_UNSPECIFIED), 1088 DEFINE_PROP_END_OF_LIST(), 1089 }; 1090 1091 static void virtio_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) 1092 { 1093 VirtIOSCSIPCI *dev = VIRTIO_SCSI_PCI(vpci_dev); 1094 DeviceState *vdev = DEVICE(&dev->vdev); 1095 VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev); 1096 DeviceState *proxy = DEVICE(vpci_dev); 1097 char *bus_name; 1098 1099 if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) { 1100 vpci_dev->nvectors = vs->conf.num_queues + 3; 1101 } 1102 1103 /* 1104 * For command line compatibility, this sets the virtio-scsi-device bus 1105 * name as before. 1106 */ 1107 if (proxy->id) { 1108 bus_name = g_strdup_printf("%s.0", proxy->id); 1109 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 1110 g_free(bus_name); 1111 } 1112 1113 qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus)); 1114 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 1115 } 1116 1117 static void virtio_scsi_pci_class_init(ObjectClass *klass, void *data) 1118 { 1119 DeviceClass *dc = DEVICE_CLASS(klass); 1120 VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass); 1121 PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass); 1122 1123 k->realize = virtio_scsi_pci_realize; 1124 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1125 dc->props = virtio_scsi_pci_properties; 1126 pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 1127 pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI; 1128 pcidev_k->revision = 0x00; 1129 pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI; 1130 } 1131 1132 static void virtio_scsi_pci_instance_init(Object *obj) 1133 { 1134 VirtIOSCSIPCI *dev = VIRTIO_SCSI_PCI(obj); 1135 1136 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1137 TYPE_VIRTIO_SCSI); 1138 object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev), "iothread", 1139 &error_abort); 1140 } 1141 1142 static const TypeInfo virtio_scsi_pci_info = { 1143 .name = TYPE_VIRTIO_SCSI_PCI, 1144 .parent = TYPE_VIRTIO_PCI, 1145 .instance_size = sizeof(VirtIOSCSIPCI), 1146 .instance_init = virtio_scsi_pci_instance_init, 1147 .class_init = virtio_scsi_pci_class_init, 1148 }; 1149 1150 /* vhost-scsi-pci */ 1151 1152 #ifdef CONFIG_VHOST_SCSI 1153 static Property vhost_scsi_pci_properties[] = { 1154 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 1155 DEV_NVECTORS_UNSPECIFIED), 1156 DEFINE_PROP_END_OF_LIST(), 1157 }; 1158 1159 static void vhost_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) 1160 { 1161 VHostSCSIPCI *dev = VHOST_SCSI_PCI(vpci_dev); 1162 DeviceState *vdev = DEVICE(&dev->vdev); 1163 VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev); 1164 1165 if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) { 1166 vpci_dev->nvectors = vs->conf.num_queues + 3; 1167 } 1168 1169 qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus)); 1170 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 1171 } 1172 1173 static void vhost_scsi_pci_class_init(ObjectClass *klass, void *data) 1174 { 1175 DeviceClass *dc = DEVICE_CLASS(klass); 1176 VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass); 1177 PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass); 1178 k->realize = vhost_scsi_pci_realize; 1179 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1180 dc->props = vhost_scsi_pci_properties; 1181 pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 1182 pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI; 1183 pcidev_k->revision = 0x00; 1184 pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI; 1185 } 1186 1187 static void vhost_scsi_pci_instance_init(Object *obj) 1188 { 1189 VHostSCSIPCI *dev = VHOST_SCSI_PCI(obj); 1190 1191 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1192 TYPE_VHOST_SCSI); 1193 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev), 1194 "bootindex", &error_abort); 1195 } 1196 1197 static const TypeInfo vhost_scsi_pci_info = { 1198 .name = TYPE_VHOST_SCSI_PCI, 1199 .parent = TYPE_VIRTIO_PCI, 1200 .instance_size = sizeof(VHostSCSIPCI), 1201 .instance_init = vhost_scsi_pci_instance_init, 1202 .class_init = vhost_scsi_pci_class_init, 1203 }; 1204 #endif 1205 1206 /* virtio-balloon-pci */ 1207 1208 static Property virtio_balloon_pci_properties[] = { 1209 DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0), 1210 DEFINE_PROP_END_OF_LIST(), 1211 }; 1212 1213 static void virtio_balloon_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) 1214 { 1215 VirtIOBalloonPCI *dev = VIRTIO_BALLOON_PCI(vpci_dev); 1216 DeviceState *vdev = DEVICE(&dev->vdev); 1217 1218 if (vpci_dev->class_code != PCI_CLASS_OTHERS && 1219 vpci_dev->class_code != PCI_CLASS_MEMORY_RAM) { /* qemu < 1.1 */ 1220 vpci_dev->class_code = PCI_CLASS_OTHERS; 1221 } 1222 1223 qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus)); 1224 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 1225 } 1226 1227 static void virtio_balloon_pci_class_init(ObjectClass *klass, void *data) 1228 { 1229 DeviceClass *dc = DEVICE_CLASS(klass); 1230 VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass); 1231 PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass); 1232 k->realize = virtio_balloon_pci_realize; 1233 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1234 dc->props = virtio_balloon_pci_properties; 1235 pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 1236 pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BALLOON; 1237 pcidev_k->revision = VIRTIO_PCI_ABI_VERSION; 1238 pcidev_k->class_id = PCI_CLASS_OTHERS; 1239 } 1240 1241 static void virtio_balloon_pci_instance_init(Object *obj) 1242 { 1243 VirtIOBalloonPCI *dev = VIRTIO_BALLOON_PCI(obj); 1244 1245 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1246 TYPE_VIRTIO_BALLOON); 1247 object_property_add_alias(obj, "guest-stats", OBJECT(&dev->vdev), 1248 "guest-stats", &error_abort); 1249 object_property_add_alias(obj, "guest-stats-polling-interval", 1250 OBJECT(&dev->vdev), 1251 "guest-stats-polling-interval", &error_abort); 1252 } 1253 1254 static const TypeInfo virtio_balloon_pci_info = { 1255 .name = TYPE_VIRTIO_BALLOON_PCI, 1256 .parent = TYPE_VIRTIO_PCI, 1257 .instance_size = sizeof(VirtIOBalloonPCI), 1258 .instance_init = virtio_balloon_pci_instance_init, 1259 .class_init = virtio_balloon_pci_class_init, 1260 }; 1261 1262 /* virtio-serial-pci */ 1263 1264 static void virtio_serial_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) 1265 { 1266 VirtIOSerialPCI *dev = VIRTIO_SERIAL_PCI(vpci_dev); 1267 DeviceState *vdev = DEVICE(&dev->vdev); 1268 DeviceState *proxy = DEVICE(vpci_dev); 1269 char *bus_name; 1270 1271 if (vpci_dev->class_code != PCI_CLASS_COMMUNICATION_OTHER && 1272 vpci_dev->class_code != PCI_CLASS_DISPLAY_OTHER && /* qemu 0.10 */ 1273 vpci_dev->class_code != PCI_CLASS_OTHERS) { /* qemu-kvm */ 1274 vpci_dev->class_code = PCI_CLASS_COMMUNICATION_OTHER; 1275 } 1276 1277 /* backwards-compatibility with machines that were created with 1278 DEV_NVECTORS_UNSPECIFIED */ 1279 if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) { 1280 vpci_dev->nvectors = dev->vdev.serial.max_virtserial_ports + 1; 1281 } 1282 1283 /* 1284 * For command line compatibility, this sets the virtio-serial-device bus 1285 * name as before. 1286 */ 1287 if (proxy->id) { 1288 bus_name = g_strdup_printf("%s.0", proxy->id); 1289 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 1290 g_free(bus_name); 1291 } 1292 1293 qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus)); 1294 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 1295 } 1296 1297 static Property virtio_serial_pci_properties[] = { 1298 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, 1299 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true), 1300 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2), 1301 DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0), 1302 DEFINE_PROP_END_OF_LIST(), 1303 }; 1304 1305 static void virtio_serial_pci_class_init(ObjectClass *klass, void *data) 1306 { 1307 DeviceClass *dc = DEVICE_CLASS(klass); 1308 VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass); 1309 PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass); 1310 k->realize = virtio_serial_pci_realize; 1311 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 1312 dc->props = virtio_serial_pci_properties; 1313 pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 1314 pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE; 1315 pcidev_k->revision = VIRTIO_PCI_ABI_VERSION; 1316 pcidev_k->class_id = PCI_CLASS_COMMUNICATION_OTHER; 1317 } 1318 1319 static void virtio_serial_pci_instance_init(Object *obj) 1320 { 1321 VirtIOSerialPCI *dev = VIRTIO_SERIAL_PCI(obj); 1322 1323 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1324 TYPE_VIRTIO_SERIAL); 1325 } 1326 1327 static const TypeInfo virtio_serial_pci_info = { 1328 .name = TYPE_VIRTIO_SERIAL_PCI, 1329 .parent = TYPE_VIRTIO_PCI, 1330 .instance_size = sizeof(VirtIOSerialPCI), 1331 .instance_init = virtio_serial_pci_instance_init, 1332 .class_init = virtio_serial_pci_class_init, 1333 }; 1334 1335 /* virtio-net-pci */ 1336 1337 static Property virtio_net_properties[] = { 1338 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags, 1339 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false), 1340 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3), 1341 DEFINE_PROP_END_OF_LIST(), 1342 }; 1343 1344 static void virtio_net_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) 1345 { 1346 DeviceState *qdev = DEVICE(vpci_dev); 1347 VirtIONetPCI *dev = VIRTIO_NET_PCI(vpci_dev); 1348 DeviceState *vdev = DEVICE(&dev->vdev); 1349 1350 virtio_net_set_netclient_name(&dev->vdev, qdev->id, 1351 object_get_typename(OBJECT(qdev))); 1352 qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus)); 1353 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 1354 } 1355 1356 static void virtio_net_pci_class_init(ObjectClass *klass, void *data) 1357 { 1358 DeviceClass *dc = DEVICE_CLASS(klass); 1359 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass); 1360 VirtioPCIClass *vpciklass = VIRTIO_PCI_CLASS(klass); 1361 1362 k->romfile = "efi-virtio.rom"; 1363 k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 1364 k->device_id = PCI_DEVICE_ID_VIRTIO_NET; 1365 k->revision = VIRTIO_PCI_ABI_VERSION; 1366 k->class_id = PCI_CLASS_NETWORK_ETHERNET; 1367 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); 1368 dc->props = virtio_net_properties; 1369 vpciklass->realize = virtio_net_pci_realize; 1370 } 1371 1372 static void virtio_net_pci_instance_init(Object *obj) 1373 { 1374 VirtIONetPCI *dev = VIRTIO_NET_PCI(obj); 1375 1376 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1377 TYPE_VIRTIO_NET); 1378 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev), 1379 "bootindex", &error_abort); 1380 } 1381 1382 static const TypeInfo virtio_net_pci_info = { 1383 .name = TYPE_VIRTIO_NET_PCI, 1384 .parent = TYPE_VIRTIO_PCI, 1385 .instance_size = sizeof(VirtIONetPCI), 1386 .instance_init = virtio_net_pci_instance_init, 1387 .class_init = virtio_net_pci_class_init, 1388 }; 1389 1390 /* virtio-rng-pci */ 1391 1392 static Property virtio_rng_pci_properties[] = { 1393 DEFINE_PROP_END_OF_LIST(), 1394 }; 1395 1396 static void virtio_rng_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) 1397 { 1398 VirtIORngPCI *vrng = VIRTIO_RNG_PCI(vpci_dev); 1399 DeviceState *vdev = DEVICE(&vrng->vdev); 1400 Error *err = NULL; 1401 1402 qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus)); 1403 object_property_set_bool(OBJECT(vdev), true, "realized", &err); 1404 if (err) { 1405 error_propagate(errp, err); 1406 return; 1407 } 1408 1409 object_property_set_link(OBJECT(vrng), 1410 OBJECT(vrng->vdev.conf.rng), "rng", 1411 NULL); 1412 } 1413 1414 static void virtio_rng_pci_class_init(ObjectClass *klass, void *data) 1415 { 1416 DeviceClass *dc = DEVICE_CLASS(klass); 1417 VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass); 1418 PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass); 1419 1420 k->realize = virtio_rng_pci_realize; 1421 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1422 dc->props = virtio_rng_pci_properties; 1423 1424 pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET; 1425 pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_RNG; 1426 pcidev_k->revision = VIRTIO_PCI_ABI_VERSION; 1427 pcidev_k->class_id = PCI_CLASS_OTHERS; 1428 } 1429 1430 static void virtio_rng_initfn(Object *obj) 1431 { 1432 VirtIORngPCI *dev = VIRTIO_RNG_PCI(obj); 1433 1434 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1435 TYPE_VIRTIO_RNG); 1436 object_property_add_alias(obj, "rng", OBJECT(&dev->vdev), "rng", 1437 &error_abort); 1438 } 1439 1440 static const TypeInfo virtio_rng_pci_info = { 1441 .name = TYPE_VIRTIO_RNG_PCI, 1442 .parent = TYPE_VIRTIO_PCI, 1443 .instance_size = sizeof(VirtIORngPCI), 1444 .instance_init = virtio_rng_initfn, 1445 .class_init = virtio_rng_pci_class_init, 1446 }; 1447 1448 /* virtio-pci-bus */ 1449 1450 static void virtio_pci_bus_new(VirtioBusState *bus, size_t bus_size, 1451 VirtIOPCIProxy *dev) 1452 { 1453 DeviceState *qdev = DEVICE(dev); 1454 char virtio_bus_name[] = "virtio-bus"; 1455 1456 qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_PCI_BUS, qdev, 1457 virtio_bus_name); 1458 } 1459 1460 static void virtio_pci_bus_class_init(ObjectClass *klass, void *data) 1461 { 1462 BusClass *bus_class = BUS_CLASS(klass); 1463 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass); 1464 bus_class->max_dev = 1; 1465 k->notify = virtio_pci_notify; 1466 k->save_config = virtio_pci_save_config; 1467 k->load_config = virtio_pci_load_config; 1468 k->save_queue = virtio_pci_save_queue; 1469 k->load_queue = virtio_pci_load_queue; 1470 k->query_guest_notifiers = virtio_pci_query_guest_notifiers; 1471 k->set_host_notifier = virtio_pci_set_host_notifier; 1472 k->set_guest_notifiers = virtio_pci_set_guest_notifiers; 1473 k->vmstate_change = virtio_pci_vmstate_change; 1474 k->device_plugged = virtio_pci_device_plugged; 1475 k->device_unplugged = virtio_pci_device_unplugged; 1476 k->query_nvectors = virtio_pci_query_nvectors; 1477 } 1478 1479 static const TypeInfo virtio_pci_bus_info = { 1480 .name = TYPE_VIRTIO_PCI_BUS, 1481 .parent = TYPE_VIRTIO_BUS, 1482 .instance_size = sizeof(VirtioPCIBusState), 1483 .class_init = virtio_pci_bus_class_init, 1484 }; 1485 1486 static void virtio_pci_register_types(void) 1487 { 1488 type_register_static(&virtio_rng_pci_info); 1489 type_register_static(&virtio_pci_bus_info); 1490 type_register_static(&virtio_pci_info); 1491 #ifdef CONFIG_VIRTFS 1492 type_register_static(&virtio_9p_pci_info); 1493 #endif 1494 type_register_static(&virtio_blk_pci_info); 1495 type_register_static(&virtio_scsi_pci_info); 1496 type_register_static(&virtio_balloon_pci_info); 1497 type_register_static(&virtio_serial_pci_info); 1498 type_register_static(&virtio_net_pci_info); 1499 #ifdef CONFIG_VHOST_SCSI 1500 type_register_static(&vhost_scsi_pci_info); 1501 #endif 1502 } 1503 1504 type_init(virtio_pci_register_types) 1505