hw/virtio/virtio-pci.c

   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 "qemu/osdep.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/virtio/virtio-input.h"
  28 #include "hw/pci/pci.h"
  29 #include "qapi/error.h"
  30 #include "qemu/error-report.h"
  31 #include "hw/pci/msi.h"
  32 #include "hw/pci/msix.h"
  33 #include "hw/loader.h"
  34 #include "sysemu/kvm.h"
  35 #include "virtio-pci.h"
  36 #include "qemu/range.h"
  37 #include "hw/virtio/virtio-bus.h"
  38 #include "qapi/visitor.h"
  39
  40 #define VIRTIO_PCI_REGION_SIZE(dev)     VIRTIO_PCI_CONFIG_OFF(msix_present(dev))
  41
  42 #undef VIRTIO_PCI_CONFIG
  43
  44 /* The remaining space is defined by each driver as the per-driver
  45  * configuration space */
  46 #define VIRTIO_PCI_CONFIG_SIZE(dev)     VIRTIO_PCI_CONFIG_OFF(msix_enabled(dev))
  47
  48 static void virtio_pci_bus_new(VirtioBusState *bus, size_t bus_size,
  49                                VirtIOPCIProxy *dev);
  50 static void virtio_pci_reset(DeviceState *qdev);
  51
  52 /* virtio device */
  53 /* DeviceState to VirtIOPCIProxy. For use off data-path. TODO: use QOM. */
  54 static inline VirtIOPCIProxy *to_virtio_pci_proxy(DeviceState *d)
  55 {
  56     return container_of(d, VirtIOPCIProxy, pci_dev.qdev);
  57 }
  58
  59 /* DeviceState to VirtIOPCIProxy. Note: used on datapath,
  60  * be careful and test performance if you change this.
  61  */
  62 static inline VirtIOPCIProxy *to_virtio_pci_proxy_fast(DeviceState *d)
  63 {
  64     return container_of(d, VirtIOPCIProxy, pci_dev.qdev);
  65 }
  66
  67 static void virtio_pci_notify(DeviceState *d, uint16_t vector)
  68 {
  69     VirtIOPCIProxy *proxy = to_virtio_pci_proxy_fast(d);
  70
  71     if (msix_enabled(&proxy->pci_dev))
  72         msix_notify(&proxy->pci_dev, vector);
  73     else {
  74         VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  75         pci_set_irq(&proxy->pci_dev, atomic_read(&vdev->isr) & 1);
  76     }
  77 }
  78
  79 static void virtio_pci_save_config(DeviceState *d, QEMUFile *f)
  80 {
  81     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
  82     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  83
  84     pci_device_save(&proxy->pci_dev, f);
  85     msix_save(&proxy->pci_dev, f);
  86     if (msix_present(&proxy->pci_dev))
  87         qemu_put_be16(f, vdev->config_vector);
  88 }
  89
  90 static const VMStateDescription vmstate_virtio_pci_modern_queue_state = {
  91     .name = "virtio_pci/modern_queue_state",
  92     .version_id = 1,
  93     .minimum_version_id = 1,
  94     .fields = (VMStateField[]) {
  95         VMSTATE_UINT16(num, VirtIOPCIQueue),
  96         VMSTATE_UNUSED(1), /* enabled was stored as be16 */
  97         VMSTATE_BOOL(enabled, VirtIOPCIQueue),
  98         VMSTATE_UINT32_ARRAY(desc, VirtIOPCIQueue, 2),
  99         VMSTATE_UINT32_ARRAY(avail, VirtIOPCIQueue, 2),
 100         VMSTATE_UINT32_ARRAY(used, VirtIOPCIQueue, 2),
 101         VMSTATE_END_OF_LIST()
 102     }
 103 };
 104
 105 static bool virtio_pci_modern_state_needed(void *opaque)
 106 {
 107     VirtIOPCIProxy *proxy = opaque;
 108
 109     return virtio_pci_modern(proxy);
 110 }
 111
 112 static const VMStateDescription vmstate_virtio_pci_modern_state_sub = {
 113     .name = "virtio_pci/modern_state",
 114     .version_id = 1,
 115     .minimum_version_id = 1,
 116     .needed = &virtio_pci_modern_state_needed,
 117     .fields = (VMStateField[]) {
 118         VMSTATE_UINT32(dfselect, VirtIOPCIProxy),
 119         VMSTATE_UINT32(gfselect, VirtIOPCIProxy),
 120         VMSTATE_UINT32_ARRAY(guest_features, VirtIOPCIProxy, 2),
 121         VMSTATE_STRUCT_ARRAY(vqs, VirtIOPCIProxy, VIRTIO_QUEUE_MAX, 0,
 122                              vmstate_virtio_pci_modern_queue_state,
 123                              VirtIOPCIQueue),
 124         VMSTATE_END_OF_LIST()
 125     }
 126 };
 127
 128 static const VMStateDescription vmstate_virtio_pci = {
 129     .name = "virtio_pci",
 130     .version_id = 1,
 131     .minimum_version_id = 1,
 132     .minimum_version_id_old = 1,
 133     .fields = (VMStateField[]) {
 134         VMSTATE_END_OF_LIST()
 135     },
 136     .subsections = (const VMStateDescription*[]) {
 137         &vmstate_virtio_pci_modern_state_sub,
 138         NULL
 139     }
 140 };
 141
 142 static bool virtio_pci_has_extra_state(DeviceState *d)
 143 {
 144     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 145
 146     return proxy->flags & VIRTIO_PCI_FLAG_MIGRATE_EXTRA;
 147 }
 148
 149 static void virtio_pci_save_extra_state(DeviceState *d, QEMUFile *f)
 150 {
 151     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 152
 153     vmstate_save_state(f, &vmstate_virtio_pci, proxy, NULL);
 154 }
 155
 156 static int virtio_pci_load_extra_state(DeviceState *d, QEMUFile *f)
 157 {
 158     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 159
 160     return vmstate_load_state(f, &vmstate_virtio_pci, proxy, 1);
 161 }
 162
 163 static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f)
 164 {
 165     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 166     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 167
 168     if (msix_present(&proxy->pci_dev))
 169         qemu_put_be16(f, virtio_queue_vector(vdev, n));
 170 }
 171
 172 static int virtio_pci_load_config(DeviceState *d, QEMUFile *f)
 173 {
 174     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 175     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 176
 177     int ret;
 178     ret = pci_device_load(&proxy->pci_dev, f);
 179     if (ret) {
 180         return ret;
 181     }
 182     msix_unuse_all_vectors(&proxy->pci_dev);
 183     msix_load(&proxy->pci_dev, f);
 184     if (msix_present(&proxy->pci_dev)) {
 185         qemu_get_be16s(f, &vdev->config_vector);
 186     } else {
 187         vdev->config_vector = VIRTIO_NO_VECTOR;
 188     }
 189     if (vdev->config_vector != VIRTIO_NO_VECTOR) {
 190         return msix_vector_use(&proxy->pci_dev, vdev->config_vector);
 191     }
 192     return 0;
 193 }
 194
 195 static int virtio_pci_load_queue(DeviceState *d, int n, QEMUFile *f)
 196 {
 197     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 198     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 199
 200     uint16_t vector;
 201     if (msix_present(&proxy->pci_dev)) {
 202         qemu_get_be16s(f, &vector);
 203     } else {
 204         vector = VIRTIO_NO_VECTOR;
 205     }
 206     virtio_queue_set_vector(vdev, n, vector);
 207     if (vector != VIRTIO_NO_VECTOR) {
 208         return msix_vector_use(&proxy->pci_dev, vector);
 209     }
 210
 211     return 0;
 212 }
 213
 214 static bool virtio_pci_ioeventfd_enabled(DeviceState *d)
 215 {
 216     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 217
 218     return (proxy->flags & VIRTIO_PCI_FLAG_USE_IOEVENTFD) != 0;
 219 }
 220
 221 #define QEMU_VIRTIO_PCI_QUEUE_MEM_MULT 0x1000
 222
 223 static inline int virtio_pci_queue_mem_mult(struct VirtIOPCIProxy *proxy)
 224 {
 225     return (proxy->flags & VIRTIO_PCI_FLAG_PAGE_PER_VQ) ?
 226         QEMU_VIRTIO_PCI_QUEUE_MEM_MULT : 4;
 227 }
 228
 229 static int virtio_pci_ioeventfd_assign(DeviceState *d, EventNotifier *notifier,
 230                                        int n, bool assign)
 231 {
 232     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 233     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 234     VirtQueue *vq = virtio_get_queue(vdev, n);
 235     bool legacy = virtio_pci_legacy(proxy);
 236     bool modern = virtio_pci_modern(proxy);
 237     bool fast_mmio = kvm_ioeventfd_any_length_enabled();
 238     bool modern_pio = proxy->flags & VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY;
 239     MemoryRegion *modern_mr = &proxy->notify.mr;
 240     MemoryRegion *modern_notify_mr = &proxy->notify_pio.mr;
 241     MemoryRegion *legacy_mr = &proxy->bar;
 242     hwaddr modern_addr = virtio_pci_queue_mem_mult(proxy) *
 243                          virtio_get_queue_index(vq);
 244     hwaddr legacy_addr = VIRTIO_PCI_QUEUE_NOTIFY;
 245
 246     if (assign) {
 247         if (modern) {
 248             if (fast_mmio) {
 249                 memory_region_add_eventfd(modern_mr, modern_addr, 0,
 250                                           false, n, notifier);
 251             } else {
 252                 memory_region_add_eventfd(modern_mr, modern_addr, 2,
 253                                           false, n, notifier);
 254             }
 255             if (modern_pio) {
 256                 memory_region_add_eventfd(modern_notify_mr, 0, 2,
 257                                               true, n, notifier);
 258             }
 259         }
 260         if (legacy) {
 261             memory_region_add_eventfd(legacy_mr, legacy_addr, 2,
 262                                       true, n, notifier);
 263         }
 264     } else {
 265         if (modern) {
 266             if (fast_mmio) {
 267                 memory_region_del_eventfd(modern_mr, modern_addr, 0,
 268                                           false, n, notifier);
 269             } else {
 270                 memory_region_del_eventfd(modern_mr, modern_addr, 2,
 271                                           false, n, notifier);
 272             }
 273             if (modern_pio) {
 274                 memory_region_del_eventfd(modern_notify_mr, 0, 2,
 275                                           true, n, notifier);
 276             }
 277         }
 278         if (legacy) {
 279             memory_region_del_eventfd(legacy_mr, legacy_addr, 2,
 280                                       true, n, notifier);
 281         }
 282     }
 283     return 0;
 284 }
 285
 286 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy)
 287 {
 288     virtio_bus_start_ioeventfd(&proxy->bus);
 289 }
 290
 291 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy)
 292 {
 293     virtio_bus_stop_ioeventfd(&proxy->bus);
 294 }
 295
 296 static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 297 {
 298     VirtIOPCIProxy *proxy = opaque;
 299     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 300     hwaddr pa;
 301
 302     switch (addr) {
 303     case VIRTIO_PCI_GUEST_FEATURES:
 304         /* Guest does not negotiate properly?  We have to assume nothing. */
 305         if (val & (1 << VIRTIO_F_BAD_FEATURE)) {
 306             val = virtio_bus_get_vdev_bad_features(&proxy->bus);
 307         }
 308         virtio_set_features(vdev, val);
 309         break;
 310     case VIRTIO_PCI_QUEUE_PFN:
 311         pa = (hwaddr)val << VIRTIO_PCI_QUEUE_ADDR_SHIFT;
 312         if (pa == 0) {
 313             virtio_pci_reset(DEVICE(proxy));
 314         }
 315         else
 316             virtio_queue_set_addr(vdev, vdev->queue_sel, pa);
 317         break;
 318     case VIRTIO_PCI_QUEUE_SEL:
 319         if (val < VIRTIO_QUEUE_MAX)
 320             vdev->queue_sel = val;
 321         break;
 322     case VIRTIO_PCI_QUEUE_NOTIFY:
 323         if (val < VIRTIO_QUEUE_MAX) {
 324             virtio_queue_notify(vdev, val);
 325         }
 326         break;
 327     case VIRTIO_PCI_STATUS:
 328         if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) {
 329             virtio_pci_stop_ioeventfd(proxy);
 330         }
 331
 332         virtio_set_status(vdev, val & 0xFF);
 333
 334         if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
 335             virtio_pci_start_ioeventfd(proxy);
 336         }
 337
 338         if (vdev->status == 0) {
 339             virtio_pci_reset(DEVICE(proxy));
 340         }
 341
 342         /* Linux before 2.6.34 drives the device without enabling
 343            the PCI device bus master bit. Enable it automatically
 344            for the guest. This is a PCI spec violation but so is
 345            initiating DMA with bus master bit clear. */
 346         if (val == (VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER)) {
 347             pci_default_write_config(&proxy->pci_dev, PCI_COMMAND,
 348                                      proxy->pci_dev.config[PCI_COMMAND] |
 349                                      PCI_COMMAND_MASTER, 1);
 350         }
 351         break;
 352     case VIRTIO_MSI_CONFIG_VECTOR:
 353         msix_vector_unuse(&proxy->pci_dev, vdev->config_vector);
 354         /* Make it possible for guest to discover an error took place. */
 355         if (msix_vector_use(&proxy->pci_dev, val) < 0)
 356             val = VIRTIO_NO_VECTOR;
 357         vdev->config_vector = val;
 358         break;
 359     case VIRTIO_MSI_QUEUE_VECTOR:
 360         msix_vector_unuse(&proxy->pci_dev,
 361                           virtio_queue_vector(vdev, vdev->queue_sel));
 362         /* Make it possible for guest to discover an error took place. */
 363         if (msix_vector_use(&proxy->pci_dev, val) < 0)
 364             val = VIRTIO_NO_VECTOR;
 365         virtio_queue_set_vector(vdev, vdev->queue_sel, val);
 366         break;
 367     default:
 368         error_report("%s: unexpected address 0x%x value 0x%x",
 369                      __func__, addr, val);
 370         break;
 371     }
 372 }
 373
 374 static uint32_t virtio_ioport_read(VirtIOPCIProxy *proxy, uint32_t addr)
 375 {
 376     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 377     uint32_t ret = 0xFFFFFFFF;
 378
 379     switch (addr) {
 380     case VIRTIO_PCI_HOST_FEATURES:
 381         ret = vdev->host_features;
 382         break;
 383     case VIRTIO_PCI_GUEST_FEATURES:
 384         ret = vdev->guest_features;
 385         break;
 386     case VIRTIO_PCI_QUEUE_PFN:
 387         ret = virtio_queue_get_addr(vdev, vdev->queue_sel)
 388               >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
 389         break;
 390     case VIRTIO_PCI_QUEUE_NUM:
 391         ret = virtio_queue_get_num(vdev, vdev->queue_sel);
 392         break;
 393     case VIRTIO_PCI_QUEUE_SEL:
 394         ret = vdev->queue_sel;
 395         break;
 396     case VIRTIO_PCI_STATUS:
 397         ret = vdev->status;
 398         break;
 399     case VIRTIO_PCI_ISR:
 400         /* reading from the ISR also clears it. */
 401         ret = atomic_xchg(&vdev->isr, 0);
 402         pci_irq_deassert(&proxy->pci_dev);
 403         break;
 404     case VIRTIO_MSI_CONFIG_VECTOR:
 405         ret = vdev->config_vector;
 406         break;
 407     case VIRTIO_MSI_QUEUE_VECTOR:
 408         ret = virtio_queue_vector(vdev, vdev->queue_sel);
 409         break;
 410     default:
 411         break;
 412     }
 413
 414     return ret;
 415 }
 416
 417 static uint64_t virtio_pci_config_read(void *opaque, hwaddr addr,
 418                                        unsigned size)
 419 {
 420     VirtIOPCIProxy *proxy = opaque;
 421     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 422     uint32_t config = VIRTIO_PCI_CONFIG_SIZE(&proxy->pci_dev);
 423     uint64_t val = 0;
 424     if (addr < config) {
 425         return virtio_ioport_read(proxy, addr);
 426     }
 427     addr -= config;
 428
 429     switch (size) {
 430     case 1:
 431         val = virtio_config_readb(vdev, addr);
 432         break;
 433     case 2:
 434         val = virtio_config_readw(vdev, addr);
 435         if (virtio_is_big_endian(vdev)) {
 436             val = bswap16(val);
 437         }
 438         break;
 439     case 4:
 440         val = virtio_config_readl(vdev, addr);
 441         if (virtio_is_big_endian(vdev)) {
 442             val = bswap32(val);
 443         }
 444         break;
 445     }
 446     return val;
 447 }
 448
 449 static void virtio_pci_config_write(void *opaque, hwaddr addr,
 450                                     uint64_t val, unsigned size)
 451 {
 452     VirtIOPCIProxy *proxy = opaque;
 453     uint32_t config = VIRTIO_PCI_CONFIG_SIZE(&proxy->pci_dev);
 454     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 455     if (addr < config) {
 456         virtio_ioport_write(proxy, addr, val);
 457         return;
 458     }
 459     addr -= config;
 460     /*
 461      * Virtio-PCI is odd. Ioports are LE but config space is target native
 462      * endian.
 463      */
 464     switch (size) {
 465     case 1:
 466         virtio_config_writeb(vdev, addr, val);
 467         break;
 468     case 2:
 469         if (virtio_is_big_endian(vdev)) {
 470             val = bswap16(val);
 471         }
 472         virtio_config_writew(vdev, addr, val);
 473         break;
 474     case 4:
 475         if (virtio_is_big_endian(vdev)) {
 476             val = bswap32(val);
 477         }
 478         virtio_config_writel(vdev, addr, val);
 479         break;
 480     }
 481 }
 482
 483 static const MemoryRegionOps virtio_pci_config_ops = {
 484     .read = virtio_pci_config_read,
 485     .write = virtio_pci_config_write,
 486     .impl = {
 487         .min_access_size = 1,
 488         .max_access_size = 4,
 489     },
 490     .endianness = DEVICE_LITTLE_ENDIAN,
 491 };
 492
 493 static MemoryRegion *virtio_address_space_lookup(VirtIOPCIProxy *proxy,
 494                                                  hwaddr *off, int len)
 495 {
 496     int i;
 497     VirtIOPCIRegion *reg;
 498
 499     for (i = 0; i < ARRAY_SIZE(proxy->regs); ++i) {
 500         reg = &proxy->regs[i];
 501         if (*off >= reg->offset &&
 502             *off + len <= reg->offset + reg->size) {
 503             *off -= reg->offset;
 504             return &reg->mr;
 505         }
 506     }
 507
 508     return NULL;
 509 }
 510
 511 /* Below are generic functions to do memcpy from/to an address space,
 512  * without byteswaps, with input validation.
 513  *
 514  * As regular address_space_* APIs all do some kind of byteswap at least for
 515  * some host/target combinations, we are forced to explicitly convert to a
 516  * known-endianness integer value.
 517  * It doesn't really matter which endian format to go through, so the code
 518  * below selects the endian that causes the least amount of work on the given
 519  * host.
 520  *
 521  * Note: host pointer must be aligned.
 522  */
 523 static
 524 void virtio_address_space_write(VirtIOPCIProxy *proxy, hwaddr addr,
 525                                 const uint8_t *buf, int len)
 526 {
 527     uint64_t val;
 528     MemoryRegion *mr;
 529
 530     /* address_space_* APIs assume an aligned address.
 531      * As address is under guest control, handle illegal values.
 532      */
 533     addr &= ~(len - 1);
 534
 535     mr = virtio_address_space_lookup(proxy, &addr, len);
 536     if (!mr) {
 537         return;
 538     }
 539
 540     /* Make sure caller aligned buf properly */
 541     assert(!(((uintptr_t)buf) & (len - 1)));
 542
 543     switch (len) {
 544     case 1:
 545         val = pci_get_byte(buf);
 546         break;
 547     case 2:
 548         val = cpu_to_le16(pci_get_word(buf));
 549         break;
 550     case 4:
 551         val = cpu_to_le32(pci_get_long(buf));
 552         break;
 553     default:
 554         /* As length is under guest control, handle illegal values. */
 555         return;
 556     }
 557     memory_region_dispatch_write(mr, addr, val, len, MEMTXATTRS_UNSPECIFIED);
 558 }
 559
 560 static void
 561 virtio_address_space_read(VirtIOPCIProxy *proxy, hwaddr addr,
 562                           uint8_t *buf, int len)
 563 {
 564     uint64_t val;
 565     MemoryRegion *mr;
 566
 567     /* address_space_* APIs assume an aligned address.
 568      * As address is under guest control, handle illegal values.
 569      */
 570     addr &= ~(len - 1);
 571
 572     mr = virtio_address_space_lookup(proxy, &addr, len);
 573     if (!mr) {
 574         return;
 575     }
 576
 577     /* Make sure caller aligned buf properly */
 578     assert(!(((uintptr_t)buf) & (len - 1)));
 579
 580     memory_region_dispatch_read(mr, addr, &val, len, MEMTXATTRS_UNSPECIFIED);
 581     switch (len) {
 582     case 1:
 583         pci_set_byte(buf, val);
 584         break;
 585     case 2:
 586         pci_set_word(buf, le16_to_cpu(val));
 587         break;
 588     case 4:
 589         pci_set_long(buf, le32_to_cpu(val));
 590         break;
 591     default:
 592         /* As length is under guest control, handle illegal values. */
 593         break;
 594     }
 595 }
 596
 597 static void virtio_write_config(PCIDevice *pci_dev, uint32_t address,
 598                                 uint32_t val, int len)
 599 {
 600     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 601     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 602     struct virtio_pci_cfg_cap *cfg;
 603
 604     pci_default_write_config(pci_dev, address, val, len);
 605
 606     if (range_covers_byte(address, len, PCI_COMMAND) &&
 607         !(pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
 608         virtio_pci_stop_ioeventfd(proxy);
 609         virtio_set_status(vdev, vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK);
 610     }
 611
 612     if (proxy->config_cap &&
 613         ranges_overlap(address, len, proxy->config_cap + offsetof(struct virtio_pci_cfg_cap,
 614                                                                   pci_cfg_data),
 615                        sizeof cfg->pci_cfg_data)) {
 616         uint32_t off;
 617         uint32_t len;
 618
 619         cfg = (void *)(proxy->pci_dev.config + proxy->config_cap);
 620         off = le32_to_cpu(cfg->cap.offset);
 621         len = le32_to_cpu(cfg->cap.length);
 622
 623         if (len == 1 || len == 2 || len == 4) {
 624             assert(len <= sizeof cfg->pci_cfg_data);
 625             virtio_address_space_write(proxy, off, cfg->pci_cfg_data, len);
 626         }
 627     }
 628 }
 629
 630 static uint32_t virtio_read_config(PCIDevice *pci_dev,
 631                                    uint32_t address, int len)
 632 {
 633     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 634     struct virtio_pci_cfg_cap *cfg;
 635
 636     if (proxy->config_cap &&
 637         ranges_overlap(address, len, proxy->config_cap + offsetof(struct virtio_pci_cfg_cap,
 638                                                                   pci_cfg_data),
 639                        sizeof cfg->pci_cfg_data)) {
 640         uint32_t off;
 641         uint32_t len;
 642
 643         cfg = (void *)(proxy->pci_dev.config + proxy->config_cap);
 644         off = le32_to_cpu(cfg->cap.offset);
 645         len = le32_to_cpu(cfg->cap.length);
 646
 647         if (len == 1 || len == 2 || len == 4) {
 648             assert(len <= sizeof cfg->pci_cfg_data);
 649             virtio_address_space_read(proxy, off, cfg->pci_cfg_data, len);
 650         }
 651     }
 652
 653     return pci_default_read_config(pci_dev, address, len);
 654 }
 655
 656 static int kvm_virtio_pci_vq_vector_use(VirtIOPCIProxy *proxy,
 657                                         unsigned int queue_no,
 658                                         unsigned int vector)
 659 {
 660     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 661     int ret;
 662
 663     if (irqfd->users == 0) {
 664         ret = kvm_irqchip_add_msi_route(kvm_state, vector, &proxy->pci_dev);
 665         if (ret < 0) {
 666             return ret;
 667         }
 668         irqfd->virq = ret;
 669     }
 670     irqfd->users++;
 671     return 0;
 672 }
 673
 674 static void kvm_virtio_pci_vq_vector_release(VirtIOPCIProxy *proxy,
 675                                              unsigned int vector)
 676 {
 677     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 678     if (--irqfd->users == 0) {
 679         kvm_irqchip_release_virq(kvm_state, irqfd->virq);
 680     }
 681 }
 682
 683 static int kvm_virtio_pci_irqfd_use(VirtIOPCIProxy *proxy,
 684                                  unsigned int queue_no,
 685                                  unsigned int vector)
 686 {
 687     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 688     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 689     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 690     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 691     return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state, n, NULL, irqfd->virq);
 692 }
 693
 694 static void kvm_virtio_pci_irqfd_release(VirtIOPCIProxy *proxy,
 695                                       unsigned int queue_no,
 696                                       unsigned int vector)
 697 {
 698     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 699     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 700     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 701     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 702     int ret;
 703
 704     ret = kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state, n, irqfd->virq);
 705     assert(ret == 0);
 706 }
 707
 708 static int kvm_virtio_pci_vector_use(VirtIOPCIProxy *proxy, int nvqs)
 709 {
 710     PCIDevice *dev = &proxy->pci_dev;
 711     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 712     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 713     unsigned int vector;
 714     int ret, queue_no;
 715
 716     for (queue_no = 0; queue_no < nvqs; queue_no++) {
 717         if (!virtio_queue_get_num(vdev, queue_no)) {
 718             break;
 719         }
 720         vector = virtio_queue_vector(vdev, queue_no);
 721         if (vector >= msix_nr_vectors_allocated(dev)) {
 722             continue;
 723         }
 724         ret = kvm_virtio_pci_vq_vector_use(proxy, queue_no, vector);
 725         if (ret < 0) {
 726             goto undo;
 727         }
 728         /* If guest supports masking, set up irqfd now.
 729          * Otherwise, delay until unmasked in the frontend.
 730          */
 731         if (vdev->use_guest_notifier_mask && k->guest_notifier_mask) {
 732             ret = kvm_virtio_pci_irqfd_use(proxy, queue_no, vector);
 733             if (ret < 0) {
 734                 kvm_virtio_pci_vq_vector_release(proxy, vector);
 735                 goto undo;
 736             }
 737         }
 738     }
 739     return 0;
 740
 741 undo:
 742     while (--queue_no >= 0) {
 743         vector = virtio_queue_vector(vdev, queue_no);
 744         if (vector >= msix_nr_vectors_allocated(dev)) {
 745             continue;
 746         }
 747         if (vdev->use_guest_notifier_mask && k->guest_notifier_mask) {
 748             kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 749         }
 750         kvm_virtio_pci_vq_vector_release(proxy, vector);
 751     }
 752     return ret;
 753 }
 754
 755 static void kvm_virtio_pci_vector_release(VirtIOPCIProxy *proxy, int nvqs)
 756 {
 757     PCIDevice *dev = &proxy->pci_dev;
 758     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 759     unsigned int vector;
 760     int queue_no;
 761     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 762
 763     for (queue_no = 0; queue_no < nvqs; queue_no++) {
 764         if (!virtio_queue_get_num(vdev, queue_no)) {
 765             break;
 766         }
 767         vector = virtio_queue_vector(vdev, queue_no);
 768         if (vector >= msix_nr_vectors_allocated(dev)) {
 769             continue;
 770         }
 771         /* If guest supports masking, clean up irqfd now.
 772          * Otherwise, it was cleaned when masked in the frontend.
 773          */
 774         if (vdev->use_guest_notifier_mask && k->guest_notifier_mask) {
 775             kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 776         }
 777         kvm_virtio_pci_vq_vector_release(proxy, vector);
 778     }
 779 }
 780
 781 static int virtio_pci_vq_vector_unmask(VirtIOPCIProxy *proxy,
 782                                        unsigned int queue_no,
 783                                        unsigned int vector,
 784                                        MSIMessage msg)
 785 {
 786     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 787     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 788     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 789     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 790     VirtIOIRQFD *irqfd;
 791     int ret = 0;
 792
 793     if (proxy->vector_irqfd) {
 794         irqfd = &proxy->vector_irqfd[vector];
 795         if (irqfd->msg.data != msg.data || irqfd->msg.address != msg.address) {
 796             ret = kvm_irqchip_update_msi_route(kvm_state, irqfd->virq, msg,
 797                                                &proxy->pci_dev);
 798             if (ret < 0) {
 799                 return ret;
 800             }
 801             kvm_irqchip_commit_routes(kvm_state);
 802         }
 803     }
 804
 805     /* If guest supports masking, irqfd is already setup, unmask it.
 806      * Otherwise, set it up now.
 807      */
 808     if (vdev->use_guest_notifier_mask && k->guest_notifier_mask) {
 809         k->guest_notifier_mask(vdev, queue_no, false);
 810         /* Test after unmasking to avoid losing events. */
 811         if (k->guest_notifier_pending &&
 812             k->guest_notifier_pending(vdev, queue_no)) {
 813             event_notifier_set(n);
 814         }
 815     } else {
 816         ret = kvm_virtio_pci_irqfd_use(proxy, queue_no, vector);
 817     }
 818     return ret;
 819 }
 820
 821 static void virtio_pci_vq_vector_mask(VirtIOPCIProxy *proxy,
 822                                              unsigned int queue_no,
 823                                              unsigned int vector)
 824 {
 825     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 826     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 827
 828     /* If guest supports masking, keep irqfd but mask it.
 829      * Otherwise, clean it up now.
 830      */
 831     if (vdev->use_guest_notifier_mask && k->guest_notifier_mask) {
 832         k->guest_notifier_mask(vdev, queue_no, true);
 833     } else {
 834         kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 835     }
 836 }
 837
 838 static int virtio_pci_vector_unmask(PCIDevice *dev, unsigned vector,
 839                                     MSIMessage msg)
 840 {
 841     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 842     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 843     VirtQueue *vq = virtio_vector_first_queue(vdev, vector);
 844     int ret, index, unmasked = 0;
 845
 846     while (vq) {
 847         index = virtio_get_queue_index(vq);
 848         if (!virtio_queue_get_num(vdev, index)) {
 849             break;
 850         }
 851         if (index < proxy->nvqs_with_notifiers) {
 852             ret = virtio_pci_vq_vector_unmask(proxy, index, vector, msg);
 853             if (ret < 0) {
 854                 goto undo;
 855             }
 856             ++unmasked;
 857         }
 858         vq = virtio_vector_next_queue(vq);
 859     }
 860
 861     return 0;
 862
 863 undo:
 864     vq = virtio_vector_first_queue(vdev, vector);
 865     while (vq && unmasked >= 0) {
 866         index = virtio_get_queue_index(vq);
 867         if (index < proxy->nvqs_with_notifiers) {
 868             virtio_pci_vq_vector_mask(proxy, index, vector);
 869             --unmasked;
 870         }
 871         vq = virtio_vector_next_queue(vq);
 872     }
 873     return ret;
 874 }
 875
 876 static void virtio_pci_vector_mask(PCIDevice *dev, unsigned vector)
 877 {
 878     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 879     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 880     VirtQueue *vq = virtio_vector_first_queue(vdev, vector);
 881     int index;
 882
 883     while (vq) {
 884         index = virtio_get_queue_index(vq);
 885         if (!virtio_queue_get_num(vdev, index)) {
 886             break;
 887         }
 888         if (index < proxy->nvqs_with_notifiers) {
 889             virtio_pci_vq_vector_mask(proxy, index, vector);
 890         }
 891         vq = virtio_vector_next_queue(vq);
 892     }
 893 }
 894
 895 static void virtio_pci_vector_poll(PCIDevice *dev,
 896                                    unsigned int vector_start,
 897                                    unsigned int vector_end)
 898 {
 899     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 900     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 901     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 902     int queue_no;
 903     unsigned int vector;
 904     EventNotifier *notifier;
 905     VirtQueue *vq;
 906
 907     for (queue_no = 0; queue_no < proxy->nvqs_with_notifiers; queue_no++) {
 908         if (!virtio_queue_get_num(vdev, queue_no)) {
 909             break;
 910         }
 911         vector = virtio_queue_vector(vdev, queue_no);
 912         if (vector < vector_start || vector >= vector_end ||
 913             !msix_is_masked(dev, vector)) {
 914             continue;
 915         }
 916         vq = virtio_get_queue(vdev, queue_no);
 917         notifier = virtio_queue_get_guest_notifier(vq);
 918         if (k->guest_notifier_pending) {
 919             if (k->guest_notifier_pending(vdev, queue_no)) {
 920                 msix_set_pending(dev, vector);
 921             }
 922         } else if (event_notifier_test_and_clear(notifier)) {
 923             msix_set_pending(dev, vector);
 924         }
 925     }
 926 }
 927
 928 static int virtio_pci_set_guest_notifier(DeviceState *d, int n, bool assign,
 929                                          bool with_irqfd)
 930 {
 931     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 932     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 933     VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
 934     VirtQueue *vq = virtio_get_queue(vdev, n);
 935     EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
 936
 937     if (assign) {
 938         int r = event_notifier_init(notifier, 0);
 939         if (r < 0) {
 940             return r;
 941         }
 942         virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd);
 943     } else {
 944         virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd);
 945         event_notifier_cleanup(notifier);
 946     }
 947
 948     if (!msix_enabled(&proxy->pci_dev) &&
 949         vdev->use_guest_notifier_mask &&
 950         vdc->guest_notifier_mask) {
 951         vdc->guest_notifier_mask(vdev, n, !assign);
 952     }
 953
 954     return 0;
 955 }
 956
 957 static bool virtio_pci_query_guest_notifiers(DeviceState *d)
 958 {
 959     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 960     return msix_enabled(&proxy->pci_dev);
 961 }
 962
 963 static int virtio_pci_set_guest_notifiers(DeviceState *d, int nvqs, bool assign)
 964 {
 965     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 966     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 967     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 968     int r, n;
 969     bool with_irqfd = msix_enabled(&proxy->pci_dev) &&
 970         kvm_msi_via_irqfd_enabled();
 971
 972     nvqs = MIN(nvqs, VIRTIO_QUEUE_MAX);
 973
 974     /* When deassigning, pass a consistent nvqs value
 975      * to avoid leaking notifiers.
 976      */
 977     assert(assign || nvqs == proxy->nvqs_with_notifiers);
 978
 979     proxy->nvqs_with_notifiers = nvqs;
 980
 981     /* Must unset vector notifier while guest notifier is still assigned */
 982     if ((proxy->vector_irqfd || k->guest_notifier_mask) && !assign) {
 983         msix_unset_vector_notifiers(&proxy->pci_dev);
 984         if (proxy->vector_irqfd) {
 985             kvm_virtio_pci_vector_release(proxy, nvqs);
 986             g_free(proxy->vector_irqfd);
 987             proxy->vector_irqfd = NULL;
 988         }
 989     }
 990
 991     for (n = 0; n < nvqs; n++) {
 992         if (!virtio_queue_get_num(vdev, n)) {
 993             break;
 994         }
 995
 996         r = virtio_pci_set_guest_notifier(d, n, assign, with_irqfd);
 997         if (r < 0) {
 998             goto assign_error;
 999         }
1000     }
1001
1002     /* Must set vector notifier after guest notifier has been assigned */
1003     if ((with_irqfd || k->guest_notifier_mask) && assign) {
1004         if (with_irqfd) {
1005             proxy->vector_irqfd =
1006                 g_malloc0(sizeof(*proxy->vector_irqfd) *
1007                           msix_nr_vectors_allocated(&proxy->pci_dev));
1008             r = kvm_virtio_pci_vector_use(proxy, nvqs);
1009             if (r < 0) {
1010                 goto assign_error;
1011             }
1012         }
1013         r = msix_set_vector_notifiers(&proxy->pci_dev,
1014                                       virtio_pci_vector_unmask,
1015                                       virtio_pci_vector_mask,
1016                                       virtio_pci_vector_poll);
1017         if (r < 0) {
1018             goto notifiers_error;
1019         }
1020     }
1021
1022     return 0;
1023
1024 notifiers_error:
1025     if (with_irqfd) {
1026         assert(assign);
1027         kvm_virtio_pci_vector_release(proxy, nvqs);
1028     }
1029
1030 assign_error:
1031     /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
1032     assert(assign);
1033     while (--n >= 0) {
1034         virtio_pci_set_guest_notifier(d, n, !assign, with_irqfd);
1035     }
1036     return r;
1037 }
1038
1039 static int virtio_pci_set_host_notifier_mr(DeviceState *d, int n,
1040                                            MemoryRegion *mr, bool assign)
1041 {
1042     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
1043     int offset;
1044
1045     if (n >= VIRTIO_QUEUE_MAX || !virtio_pci_modern(proxy) ||
1046         virtio_pci_queue_mem_mult(proxy) != memory_region_size(mr)) {
1047         return -1;
1048     }
1049
1050     if (assign) {
1051         offset = virtio_pci_queue_mem_mult(proxy) * n;
1052         memory_region_add_subregion_overlap(&proxy->notify.mr, offset, mr, 1);
1053     } else {
1054         memory_region_del_subregion(&proxy->notify.mr, mr);
1055     }
1056
1057     return 0;
1058 }
1059
1060 static void virtio_pci_vmstate_change(DeviceState *d, bool running)
1061 {
1062     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
1063     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1064
1065     if (running) {
1066         /* Old QEMU versions did not set bus master enable on status write.
1067          * Detect DRIVER set and enable it.
1068          */
1069         if ((proxy->flags & VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION) &&
1070             (vdev->status & VIRTIO_CONFIG_S_DRIVER) &&
1071             !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
1072             pci_default_write_config(&proxy->pci_dev, PCI_COMMAND,
1073                                      proxy->pci_dev.config[PCI_COMMAND] |
1074                                      PCI_COMMAND_MASTER, 1);
1075         }
1076         virtio_pci_start_ioeventfd(proxy);
1077     } else {
1078         virtio_pci_stop_ioeventfd(proxy);
1079     }
1080 }
1081
1082 #ifdef CONFIG_VIRTFS
1083 static void virtio_9p_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1084 {
1085     V9fsPCIState *dev = VIRTIO_9P_PCI(vpci_dev);
1086     DeviceState *vdev = DEVICE(&dev->vdev);
1087
1088     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1089     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1090 }
1091
1092 static Property virtio_9p_pci_properties[] = {
1093     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1094                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1095     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
1096     DEFINE_PROP_END_OF_LIST(),
1097 };
1098
1099 static void virtio_9p_pci_class_init(ObjectClass *klass, void *data)
1100 {
1101     DeviceClass *dc = DEVICE_CLASS(klass);
1102     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1103     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1104
1105     k->realize = virtio_9p_pci_realize;
1106     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1107     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_9P;
1108     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1109     pcidev_k->class_id = 0x2;
1110     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1111     dc->props = virtio_9p_pci_properties;
1112 }
1113
1114 static void virtio_9p_pci_instance_init(Object *obj)
1115 {
1116     V9fsPCIState *dev = VIRTIO_9P_PCI(obj);
1117
1118     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1119                                 TYPE_VIRTIO_9P);
1120 }
1121
1122 static const TypeInfo virtio_9p_pci_info = {
1123     .name          = TYPE_VIRTIO_9P_PCI,
1124     .parent        = TYPE_VIRTIO_PCI,
1125     .instance_size = sizeof(V9fsPCIState),
1126     .instance_init = virtio_9p_pci_instance_init,
1127     .class_init    = virtio_9p_pci_class_init,
1128 };
1129 #endif /* CONFIG_VIRTFS */
1130
1131 /*
1132  * virtio-pci: This is the PCIDevice which has a virtio-pci-bus.
1133  */
1134
1135 static int virtio_pci_query_nvectors(DeviceState *d)
1136 {
1137     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1138
1139     return proxy->nvectors;
1140 }
1141
1142 static AddressSpace *virtio_pci_get_dma_as(DeviceState *d)
1143 {
1144     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1145     PCIDevice *dev = &proxy->pci_dev;
1146
1147     return pci_get_address_space(dev);
1148 }
1149
1150 static int virtio_pci_add_mem_cap(VirtIOPCIProxy *proxy,
1151                                    struct virtio_pci_cap *cap)
1152 {
1153     PCIDevice *dev = &proxy->pci_dev;
1154     int offset;
1155
1156     offset = pci_add_capability(dev, PCI_CAP_ID_VNDR, 0,
1157                                 cap->cap_len, &error_abort);
1158
1159     assert(cap->cap_len >= sizeof *cap);
1160     memcpy(dev->config + offset + PCI_CAP_FLAGS, &cap->cap_len,
1161            cap->cap_len - PCI_CAP_FLAGS);
1162
1163     return offset;
1164 }
1165
1166 static uint64_t virtio_pci_common_read(void *opaque, hwaddr addr,
1167                                        unsigned size)
1168 {
1169     VirtIOPCIProxy *proxy = opaque;
1170     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1171     uint32_t val = 0;
1172     int i;
1173
1174     switch (addr) {
1175     case VIRTIO_PCI_COMMON_DFSELECT:
1176         val = proxy->dfselect;
1177         break;
1178     case VIRTIO_PCI_COMMON_DF:
1179         if (proxy->dfselect <= 1) {
1180             VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
1181
1182             val = (vdev->host_features & ~vdc->legacy_features) >>
1183                 (32 * proxy->dfselect);
1184         }
1185         break;
1186     case VIRTIO_PCI_COMMON_GFSELECT:
1187         val = proxy->gfselect;
1188         break;
1189     case VIRTIO_PCI_COMMON_GF:
1190         if (proxy->gfselect < ARRAY_SIZE(proxy->guest_features)) {
1191             val = proxy->guest_features[proxy->gfselect];
1192         }
1193         break;
1194     case VIRTIO_PCI_COMMON_MSIX:
1195         val = vdev->config_vector;
1196         break;
1197     case VIRTIO_PCI_COMMON_NUMQ:
1198         for (i = 0; i < VIRTIO_QUEUE_MAX; ++i) {
1199             if (virtio_queue_get_num(vdev, i)) {
1200                 val = i + 1;
1201             }
1202         }
1203         break;
1204     case VIRTIO_PCI_COMMON_STATUS:
1205         val = vdev->status;
1206         break;
1207     case VIRTIO_PCI_COMMON_CFGGENERATION:
1208         val = vdev->generation;
1209         break;
1210     case VIRTIO_PCI_COMMON_Q_SELECT:
1211         val = vdev->queue_sel;
1212         break;
1213     case VIRTIO_PCI_COMMON_Q_SIZE:
1214         val = virtio_queue_get_num(vdev, vdev->queue_sel);
1215         break;
1216     case VIRTIO_PCI_COMMON_Q_MSIX:
1217         val = virtio_queue_vector(vdev, vdev->queue_sel);
1218         break;
1219     case VIRTIO_PCI_COMMON_Q_ENABLE:
1220         val = proxy->vqs[vdev->queue_sel].enabled;
1221         break;
1222     case VIRTIO_PCI_COMMON_Q_NOFF:
1223         /* Simply map queues in order */
1224         val = vdev->queue_sel;
1225         break;
1226     case VIRTIO_PCI_COMMON_Q_DESCLO:
1227         val = proxy->vqs[vdev->queue_sel].desc[0];
1228         break;
1229     case VIRTIO_PCI_COMMON_Q_DESCHI:
1230         val = proxy->vqs[vdev->queue_sel].desc[1];
1231         break;
1232     case VIRTIO_PCI_COMMON_Q_AVAILLO:
1233         val = proxy->vqs[vdev->queue_sel].avail[0];
1234         break;
1235     case VIRTIO_PCI_COMMON_Q_AVAILHI:
1236         val = proxy->vqs[vdev->queue_sel].avail[1];
1237         break;
1238     case VIRTIO_PCI_COMMON_Q_USEDLO:
1239         val = proxy->vqs[vdev->queue_sel].used[0];
1240         break;
1241     case VIRTIO_PCI_COMMON_Q_USEDHI:
1242         val = proxy->vqs[vdev->queue_sel].used[1];
1243         break;
1244     default:
1245         val = 0;
1246     }
1247
1248     return val;
1249 }
1250
1251 static void virtio_pci_common_write(void *opaque, hwaddr addr,
1252                                     uint64_t val, unsigned size)
1253 {
1254     VirtIOPCIProxy *proxy = opaque;
1255     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1256
1257     switch (addr) {
1258     case VIRTIO_PCI_COMMON_DFSELECT:
1259         proxy->dfselect = val;
1260         break;
1261     case VIRTIO_PCI_COMMON_GFSELECT:
1262         proxy->gfselect = val;
1263         break;
1264     case VIRTIO_PCI_COMMON_GF:
1265         if (proxy->gfselect < ARRAY_SIZE(proxy->guest_features)) {
1266             proxy->guest_features[proxy->gfselect] = val;
1267             virtio_set_features(vdev,
1268                                 (((uint64_t)proxy->guest_features[1]) << 32) |
1269                                 proxy->guest_features[0]);
1270         }
1271         break;
1272     case VIRTIO_PCI_COMMON_MSIX:
1273         msix_vector_unuse(&proxy->pci_dev, vdev->config_vector);
1274         /* Make it possible for guest to discover an error took place. */
1275         if (msix_vector_use(&proxy->pci_dev, val) < 0) {
1276             val = VIRTIO_NO_VECTOR;
1277         }
1278         vdev->config_vector = val;
1279         break;
1280     case VIRTIO_PCI_COMMON_STATUS:
1281         if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) {
1282             virtio_pci_stop_ioeventfd(proxy);
1283         }
1284
1285         virtio_set_status(vdev, val & 0xFF);
1286
1287         if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
1288             virtio_pci_start_ioeventfd(proxy);
1289         }
1290
1291         if (vdev->status == 0) {
1292             virtio_pci_reset(DEVICE(proxy));
1293         }
1294
1295         break;
1296     case VIRTIO_PCI_COMMON_Q_SELECT:
1297         if (val < VIRTIO_QUEUE_MAX) {
1298             vdev->queue_sel = val;
1299         }
1300         break;
1301     case VIRTIO_PCI_COMMON_Q_SIZE:
1302         proxy->vqs[vdev->queue_sel].num = val;
1303         break;
1304     case VIRTIO_PCI_COMMON_Q_MSIX:
1305         msix_vector_unuse(&proxy->pci_dev,
1306                           virtio_queue_vector(vdev, vdev->queue_sel));
1307         /* Make it possible for guest to discover an error took place. */
1308         if (msix_vector_use(&proxy->pci_dev, val) < 0) {
1309             val = VIRTIO_NO_VECTOR;
1310         }
1311         virtio_queue_set_vector(vdev, vdev->queue_sel, val);
1312         break;
1313     case VIRTIO_PCI_COMMON_Q_ENABLE:
1314         virtio_queue_set_num(vdev, vdev->queue_sel,
1315                              proxy->vqs[vdev->queue_sel].num);
1316         virtio_queue_set_rings(vdev, vdev->queue_sel,
1317                        ((uint64_t)proxy->vqs[vdev->queue_sel].desc[1]) << 32 |
1318                        proxy->vqs[vdev->queue_sel].desc[0],
1319                        ((uint64_t)proxy->vqs[vdev->queue_sel].avail[1]) << 32 |
1320                        proxy->vqs[vdev->queue_sel].avail[0],
1321                        ((uint64_t)proxy->vqs[vdev->queue_sel].used[1]) << 32 |
1322                        proxy->vqs[vdev->queue_sel].used[0]);
1323         proxy->vqs[vdev->queue_sel].enabled = 1;
1324         break;
1325     case VIRTIO_PCI_COMMON_Q_DESCLO:
1326         proxy->vqs[vdev->queue_sel].desc[0] = val;
1327         break;
1328     case VIRTIO_PCI_COMMON_Q_DESCHI:
1329         proxy->vqs[vdev->queue_sel].desc[1] = val;
1330         break;
1331     case VIRTIO_PCI_COMMON_Q_AVAILLO:
1332         proxy->vqs[vdev->queue_sel].avail[0] = val;
1333         break;
1334     case VIRTIO_PCI_COMMON_Q_AVAILHI:
1335         proxy->vqs[vdev->queue_sel].avail[1] = val;
1336         break;
1337     case VIRTIO_PCI_COMMON_Q_USEDLO:
1338         proxy->vqs[vdev->queue_sel].used[0] = val;
1339         break;
1340     case VIRTIO_PCI_COMMON_Q_USEDHI:
1341         proxy->vqs[vdev->queue_sel].used[1] = val;
1342         break;
1343     default:
1344         break;
1345     }
1346 }
1347
1348
1349 static uint64_t virtio_pci_notify_read(void *opaque, hwaddr addr,
1350                                        unsigned size)
1351 {
1352     return 0;
1353 }
1354
1355 static void virtio_pci_notify_write(void *opaque, hwaddr addr,
1356                                     uint64_t val, unsigned size)
1357 {
1358     VirtIODevice *vdev = opaque;
1359     VirtIOPCIProxy *proxy = VIRTIO_PCI(DEVICE(vdev)->parent_bus->parent);
1360     unsigned queue = addr / virtio_pci_queue_mem_mult(proxy);
1361
1362     if (queue < VIRTIO_QUEUE_MAX) {
1363         virtio_queue_notify(vdev, queue);
1364     }
1365 }
1366
1367 static void virtio_pci_notify_write_pio(void *opaque, hwaddr addr,
1368                                         uint64_t val, unsigned size)
1369 {
1370     VirtIODevice *vdev = opaque;
1371     unsigned queue = val;
1372
1373     if (queue < VIRTIO_QUEUE_MAX) {
1374         virtio_queue_notify(vdev, queue);
1375     }
1376 }
1377
1378 static uint64_t virtio_pci_isr_read(void *opaque, hwaddr addr,
1379                                     unsigned size)
1380 {
1381     VirtIOPCIProxy *proxy = opaque;
1382     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1383     uint64_t val = atomic_xchg(&vdev->isr, 0);
1384     pci_irq_deassert(&proxy->pci_dev);
1385
1386     return val;
1387 }
1388
1389 static void virtio_pci_isr_write(void *opaque, hwaddr addr,
1390                                  uint64_t val, unsigned size)
1391 {
1392 }
1393
1394 static uint64_t virtio_pci_device_read(void *opaque, hwaddr addr,
1395                                        unsigned size)
1396 {
1397     VirtIODevice *vdev = opaque;
1398     uint64_t val = 0;
1399
1400     switch (size) {
1401     case 1:
1402         val = virtio_config_modern_readb(vdev, addr);
1403         break;
1404     case 2:
1405         val = virtio_config_modern_readw(vdev, addr);
1406         break;
1407     case 4:
1408         val = virtio_config_modern_readl(vdev, addr);
1409         break;
1410     }
1411     return val;
1412 }
1413
1414 static void virtio_pci_device_write(void *opaque, hwaddr addr,
1415                                     uint64_t val, unsigned size)
1416 {
1417     VirtIODevice *vdev = opaque;
1418     switch (size) {
1419     case 1:
1420         virtio_config_modern_writeb(vdev, addr, val);
1421         break;
1422     case 2:
1423         virtio_config_modern_writew(vdev, addr, val);
1424         break;
1425     case 4:
1426         virtio_config_modern_writel(vdev, addr, val);
1427         break;
1428     }
1429 }
1430
1431 static void virtio_pci_modern_regions_init(VirtIOPCIProxy *proxy)
1432 {
1433     static const MemoryRegionOps common_ops = {
1434         .read = virtio_pci_common_read,
1435         .write = virtio_pci_common_write,
1436         .impl = {
1437             .min_access_size = 1,
1438             .max_access_size = 4,
1439         },
1440         .endianness = DEVICE_LITTLE_ENDIAN,
1441     };
1442     static const MemoryRegionOps isr_ops = {
1443         .read = virtio_pci_isr_read,
1444         .write = virtio_pci_isr_write,
1445         .impl = {
1446             .min_access_size = 1,
1447             .max_access_size = 4,
1448         },
1449         .endianness = DEVICE_LITTLE_ENDIAN,
1450     };
1451     static const MemoryRegionOps device_ops = {
1452         .read = virtio_pci_device_read,
1453         .write = virtio_pci_device_write,
1454         .impl = {
1455             .min_access_size = 1,
1456             .max_access_size = 4,
1457         },
1458         .endianness = DEVICE_LITTLE_ENDIAN,
1459     };
1460     static const MemoryRegionOps notify_ops = {
1461         .read = virtio_pci_notify_read,
1462         .write = virtio_pci_notify_write,
1463         .impl = {
1464             .min_access_size = 1,
1465             .max_access_size = 4,
1466         },
1467         .endianness = DEVICE_LITTLE_ENDIAN,
1468     };
1469     static const MemoryRegionOps notify_pio_ops = {
1470         .read = virtio_pci_notify_read,
1471         .write = virtio_pci_notify_write_pio,
1472         .impl = {
1473             .min_access_size = 1,
1474             .max_access_size = 4,
1475         },
1476         .endianness = DEVICE_LITTLE_ENDIAN,
1477     };
1478
1479
1480     memory_region_init_io(&proxy->common.mr, OBJECT(proxy),
1481                           &common_ops,
1482                           proxy,
1483                           "virtio-pci-common",
1484                           proxy->common.size);
1485
1486     memory_region_init_io(&proxy->isr.mr, OBJECT(proxy),
1487                           &isr_ops,
1488                           proxy,
1489                           "virtio-pci-isr",
1490                           proxy->isr.size);
1491
1492     memory_region_init_io(&proxy->device.mr, OBJECT(proxy),
1493                           &device_ops,
1494                           virtio_bus_get_device(&proxy->bus),
1495                           "virtio-pci-device",
1496                           proxy->device.size);
1497
1498     memory_region_init_io(&proxy->notify.mr, OBJECT(proxy),
1499                           &notify_ops,
1500                           virtio_bus_get_device(&proxy->bus),
1501                           "virtio-pci-notify",
1502                           proxy->notify.size);
1503
1504     memory_region_init_io(&proxy->notify_pio.mr, OBJECT(proxy),
1505                           &notify_pio_ops,
1506                           virtio_bus_get_device(&proxy->bus),
1507                           "virtio-pci-notify-pio",
1508                           proxy->notify_pio.size);
1509 }
1510
1511 static void virtio_pci_modern_region_map(VirtIOPCIProxy *proxy,
1512                                          VirtIOPCIRegion *region,
1513                                          struct virtio_pci_cap *cap,
1514                                          MemoryRegion *mr,
1515                                          uint8_t bar)
1516 {
1517     memory_region_add_subregion(mr, region->offset, &region->mr);
1518
1519     cap->cfg_type = region->type;
1520     cap->bar = bar;
1521     cap->offset = cpu_to_le32(region->offset);
1522     cap->length = cpu_to_le32(region->size);
1523     virtio_pci_add_mem_cap(proxy, cap);
1524
1525 }
1526
1527 static void virtio_pci_modern_mem_region_map(VirtIOPCIProxy *proxy,
1528                                              VirtIOPCIRegion *region,
1529                                              struct virtio_pci_cap *cap)
1530 {
1531     virtio_pci_modern_region_map(proxy, region, cap,
1532                                  &proxy->modern_bar, proxy->modern_mem_bar_idx);
1533 }
1534
1535 static void virtio_pci_modern_io_region_map(VirtIOPCIProxy *proxy,
1536                                             VirtIOPCIRegion *region,
1537                                             struct virtio_pci_cap *cap)
1538 {
1539     virtio_pci_modern_region_map(proxy, region, cap,
1540                                  &proxy->io_bar, proxy->modern_io_bar_idx);
1541 }
1542
1543 static void virtio_pci_modern_mem_region_unmap(VirtIOPCIProxy *proxy,
1544                                                VirtIOPCIRegion *region)
1545 {
1546     memory_region_del_subregion(&proxy->modern_bar,
1547                                 &region->mr);
1548 }
1549
1550 static void virtio_pci_modern_io_region_unmap(VirtIOPCIProxy *proxy,
1551                                               VirtIOPCIRegion *region)
1552 {
1553     memory_region_del_subregion(&proxy->io_bar,
1554                                 &region->mr);
1555 }
1556
1557 static void virtio_pci_pre_plugged(DeviceState *d, Error **errp)
1558 {
1559     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1560     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1561
1562     if (virtio_pci_modern(proxy)) {
1563         virtio_add_feature(&vdev->host_features, VIRTIO_F_VERSION_1);
1564     }
1565
1566     virtio_add_feature(&vdev->host_features, VIRTIO_F_BAD_FEATURE);
1567 }
1568
1569 /* This is called by virtio-bus just after the device is plugged. */
1570 static void virtio_pci_device_plugged(DeviceState *d, Error **errp)
1571 {
1572     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1573     VirtioBusState *bus = &proxy->bus;
1574     bool legacy = virtio_pci_legacy(proxy);
1575     bool modern;
1576     bool modern_pio = proxy->flags & VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY;
1577     uint8_t *config;
1578     uint32_t size;
1579     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1580
1581     /*
1582      * Virtio capabilities present without
1583      * VIRTIO_F_VERSION_1 confuses guests
1584      */
1585     if (!proxy->ignore_backend_features &&
1586             !virtio_has_feature(vdev->host_features, VIRTIO_F_VERSION_1)) {
1587         virtio_pci_disable_modern(proxy);
1588
1589         if (!legacy) {
1590             error_setg(errp, "Device doesn't support modern mode, and legacy"
1591                              " mode is disabled");
1592             error_append_hint(errp, "Set disable-legacy to off\n");
1593
1594             return;
1595         }
1596     }
1597
1598     modern = virtio_pci_modern(proxy);
1599
1600     config = proxy->pci_dev.config;
1601     if (proxy->class_code) {
1602         pci_config_set_class(config, proxy->class_code);
1603     }
1604
1605     if (legacy) {
1606         if (virtio_host_has_feature(vdev, VIRTIO_F_IOMMU_PLATFORM)) {
1607             error_setg(errp, "VIRTIO_F_IOMMU_PLATFORM was supported by"
1608                        " neither legacy nor transitional device");
1609             return ;
1610         }
1611         /*
1612          * Legacy and transitional devices use specific subsystem IDs.
1613          * Note that the subsystem vendor ID (config + PCI_SUBSYSTEM_VENDOR_ID)
1614          * is set to PCI_SUBVENDOR_ID_REDHAT_QUMRANET by default.
1615          */
1616         pci_set_word(config + PCI_SUBSYSTEM_ID, virtio_bus_get_vdev_id(bus));
1617     } else {
1618         /* pure virtio-1.0 */
1619         pci_set_word(config + PCI_VENDOR_ID,
1620                      PCI_VENDOR_ID_REDHAT_QUMRANET);
1621         pci_set_word(config + PCI_DEVICE_ID,
1622                      0x1040 + virtio_bus_get_vdev_id(bus));
1623         pci_config_set_revision(config, 1);
1624     }
1625     config[PCI_INTERRUPT_PIN] = 1;
1626
1627
1628     if (modern) {
1629         struct virtio_pci_cap cap = {
1630             .cap_len = sizeof cap,
1631         };
1632         struct virtio_pci_notify_cap notify = {
1633             .cap.cap_len = sizeof notify,
1634             .notify_off_multiplier =
1635                 cpu_to_le32(virtio_pci_queue_mem_mult(proxy)),
1636         };
1637         struct virtio_pci_cfg_cap cfg = {
1638             .cap.cap_len = sizeof cfg,
1639             .cap.cfg_type = VIRTIO_PCI_CAP_PCI_CFG,
1640         };
1641         struct virtio_pci_notify_cap notify_pio = {
1642             .cap.cap_len = sizeof notify,
1643             .notify_off_multiplier = cpu_to_le32(0x0),
1644         };
1645
1646         struct virtio_pci_cfg_cap *cfg_mask;
1647
1648         virtio_pci_modern_regions_init(proxy);
1649
1650         virtio_pci_modern_mem_region_map(proxy, &proxy->common, &cap);
1651         virtio_pci_modern_mem_region_map(proxy, &proxy->isr, &cap);
1652         virtio_pci_modern_mem_region_map(proxy, &proxy->device, &cap);
1653         virtio_pci_modern_mem_region_map(proxy, &proxy->notify, &notify.cap);
1654
1655         if (modern_pio) {
1656             memory_region_init(&proxy->io_bar, OBJECT(proxy),
1657                                "virtio-pci-io", 0x4);
1658
1659             pci_register_bar(&proxy->pci_dev, proxy->modern_io_bar_idx,
1660                              PCI_BASE_ADDRESS_SPACE_IO, &proxy->io_bar);
1661
1662             virtio_pci_modern_io_region_map(proxy, &proxy->notify_pio,
1663                                             &notify_pio.cap);
1664         }
1665
1666         pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar_idx,
1667                          PCI_BASE_ADDRESS_SPACE_MEMORY |
1668                          PCI_BASE_ADDRESS_MEM_PREFETCH |
1669                          PCI_BASE_ADDRESS_MEM_TYPE_64,
1670                          &proxy->modern_bar);
1671
1672         proxy->config_cap = virtio_pci_add_mem_cap(proxy, &cfg.cap);
1673         cfg_mask = (void *)(proxy->pci_dev.wmask + proxy->config_cap);
1674         pci_set_byte(&cfg_mask->cap.bar, ~0x0);
1675         pci_set_long((uint8_t *)&cfg_mask->cap.offset, ~0x0);
1676         pci_set_long((uint8_t *)&cfg_mask->cap.length, ~0x0);
1677         pci_set_long(cfg_mask->pci_cfg_data, ~0x0);
1678     }
1679
1680     if (proxy->nvectors) {
1681         int err = msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors,
1682                                           proxy->msix_bar_idx, NULL);
1683         if (err) {
1684             /* Notice when a system that supports MSIx can't initialize it */
1685             if (err != -ENOTSUP) {
1686                 warn_report("unable to init msix vectors to %" PRIu32,
1687                             proxy->nvectors);
1688             }
1689             proxy->nvectors = 0;
1690         }
1691     }
1692
1693     proxy->pci_dev.config_write = virtio_write_config;
1694     proxy->pci_dev.config_read = virtio_read_config;
1695
1696     if (legacy) {
1697         size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev)
1698             + virtio_bus_get_vdev_config_len(bus);
1699         size = pow2ceil(size);
1700
1701         memory_region_init_io(&proxy->bar, OBJECT(proxy),
1702                               &virtio_pci_config_ops,
1703                               proxy, "virtio-pci", size);
1704
1705         pci_register_bar(&proxy->pci_dev, proxy->legacy_io_bar_idx,
1706                          PCI_BASE_ADDRESS_SPACE_IO, &proxy->bar);
1707     }
1708 }
1709
1710 static void virtio_pci_device_unplugged(DeviceState *d)
1711 {
1712     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1713     bool modern = virtio_pci_modern(proxy);
1714     bool modern_pio = proxy->flags & VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY;
1715
1716     virtio_pci_stop_ioeventfd(proxy);
1717
1718     if (modern) {
1719         virtio_pci_modern_mem_region_unmap(proxy, &proxy->common);
1720         virtio_pci_modern_mem_region_unmap(proxy, &proxy->isr);
1721         virtio_pci_modern_mem_region_unmap(proxy, &proxy->device);
1722         virtio_pci_modern_mem_region_unmap(proxy, &proxy->notify);
1723         if (modern_pio) {
1724             virtio_pci_modern_io_region_unmap(proxy, &proxy->notify_pio);
1725         }
1726     }
1727 }
1728
1729 static void virtio_pci_realize(PCIDevice *pci_dev, Error **errp)
1730 {
1731     VirtIOPCIProxy *proxy = VIRTIO_PCI(pci_dev);
1732     VirtioPCIClass *k = VIRTIO_PCI_GET_CLASS(pci_dev);
1733     bool pcie_port = pci_bus_is_express(pci_get_bus(pci_dev)) &&
1734                      !pci_bus_is_root(pci_get_bus(pci_dev));
1735
1736     if (kvm_enabled() && !kvm_has_many_ioeventfds()) {
1737         proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
1738     }
1739
1740     /*
1741      * virtio pci bar layout used by default.
1742      * subclasses can re-arrange things if needed.
1743      *
1744      *   region 0   --  virtio legacy io bar
1745      *   region 1   --  msi-x bar
1746      *   region 4+5 --  virtio modern memory (64bit) bar
1747      *
1748      */
1749     proxy->legacy_io_bar_idx  = 0;
1750     proxy->msix_bar_idx       = 1;
1751     proxy->modern_io_bar_idx  = 2;
1752     proxy->modern_mem_bar_idx = 4;
1753
1754     proxy->common.offset = 0x0;
1755     proxy->common.size = 0x1000;
1756     proxy->common.type = VIRTIO_PCI_CAP_COMMON_CFG;
1757
1758     proxy->isr.offset = 0x1000;
1759     proxy->isr.size = 0x1000;
1760     proxy->isr.type = VIRTIO_PCI_CAP_ISR_CFG;
1761
1762     proxy->device.offset = 0x2000;
1763     proxy->device.size = 0x1000;
1764     proxy->device.type = VIRTIO_PCI_CAP_DEVICE_CFG;
1765
1766     proxy->notify.offset = 0x3000;
1767     proxy->notify.size = virtio_pci_queue_mem_mult(proxy) * VIRTIO_QUEUE_MAX;
1768     proxy->notify.type = VIRTIO_PCI_CAP_NOTIFY_CFG;
1769
1770     proxy->notify_pio.offset = 0x0;
1771     proxy->notify_pio.size = 0x4;
1772     proxy->notify_pio.type = VIRTIO_PCI_CAP_NOTIFY_CFG;
1773
1774     /* subclasses can enforce modern, so do this unconditionally */
1775     memory_region_init(&proxy->modern_bar, OBJECT(proxy), "virtio-pci",
1776                        /* PCI BAR regions must be powers of 2 */
1777                        pow2ceil(proxy->notify.offset + proxy->notify.size));
1778
1779     if (proxy->disable_legacy == ON_OFF_AUTO_AUTO) {
1780         proxy->disable_legacy = pcie_port ? ON_OFF_AUTO_ON : ON_OFF_AUTO_OFF;
1781     }
1782
1783     if (!virtio_pci_modern(proxy) && !virtio_pci_legacy(proxy)) {
1784         error_setg(errp, "device cannot work as neither modern nor legacy mode"
1785                    " is enabled");
1786         error_append_hint(errp, "Set either disable-modern or disable-legacy"
1787                           " to off\n");
1788         return;
1789     }
1790
1791     if (pcie_port && pci_is_express(pci_dev)) {
1792         int pos;
1793
1794         pos = pcie_endpoint_cap_init(pci_dev, 0);
1795         assert(pos > 0);
1796
1797         pos = pci_add_capability(pci_dev, PCI_CAP_ID_PM, 0,
1798                                  PCI_PM_SIZEOF, errp);
1799         if (pos < 0) {
1800             return;
1801         }
1802
1803         pci_dev->exp.pm_cap = pos;
1804
1805         /*
1806          * Indicates that this function complies with revision 1.2 of the
1807          * PCI Power Management Interface Specification.
1808          */
1809         pci_set_word(pci_dev->config + pos + PCI_PM_PMC, 0x3);
1810
1811         if (proxy->flags & VIRTIO_PCI_FLAG_INIT_DEVERR) {
1812             /* Init error enabling flags */
1813             pcie_cap_deverr_init(pci_dev);
1814         }
1815
1816         if (proxy->flags & VIRTIO_PCI_FLAG_INIT_LNKCTL) {
1817             /* Init Link Control Register */
1818             pcie_cap_lnkctl_init(pci_dev);
1819         }
1820
1821         if (proxy->flags & VIRTIO_PCI_FLAG_INIT_PM) {
1822             /* Init Power Management Control Register */
1823             pci_set_word(pci_dev->wmask + pos + PCI_PM_CTRL,
1824                          PCI_PM_CTRL_STATE_MASK);
1825         }
1826
1827         if (proxy->flags & VIRTIO_PCI_FLAG_ATS) {
1828             pcie_ats_init(pci_dev, 256);
1829         }
1830
1831     } else {
1832         /*
1833          * make future invocations of pci_is_express() return false
1834          * and pci_config_size() return PCI_CONFIG_SPACE_SIZE.
1835          */
1836         pci_dev->cap_present &= ~QEMU_PCI_CAP_EXPRESS;
1837     }
1838
1839     virtio_pci_bus_new(&proxy->bus, sizeof(proxy->bus), proxy);
1840     if (k->realize) {
1841         k->realize(proxy, errp);
1842     }
1843 }
1844
1845 static void virtio_pci_exit(PCIDevice *pci_dev)
1846 {
1847     msix_uninit_exclusive_bar(pci_dev);
1848 }
1849
1850 static void virtio_pci_reset(DeviceState *qdev)
1851 {
1852     VirtIOPCIProxy *proxy = VIRTIO_PCI(qdev);
1853     VirtioBusState *bus = VIRTIO_BUS(&proxy->bus);
1854     PCIDevice *dev = PCI_DEVICE(qdev);
1855     int i;
1856
1857     virtio_pci_stop_ioeventfd(proxy);
1858     virtio_bus_reset(bus);
1859     msix_unuse_all_vectors(&proxy->pci_dev);
1860
1861     for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1862         proxy->vqs[i].enabled = 0;
1863         proxy->vqs[i].num = 0;
1864         proxy->vqs[i].desc[0] = proxy->vqs[i].desc[1] = 0;
1865         proxy->vqs[i].avail[0] = proxy->vqs[i].avail[1] = 0;
1866         proxy->vqs[i].used[0] = proxy->vqs[i].used[1] = 0;
1867     }
1868
1869     if (pci_is_express(dev)) {
1870         pcie_cap_deverr_reset(dev);
1871         pcie_cap_lnkctl_reset(dev);
1872
1873         pci_set_word(dev->config + dev->exp.pm_cap + PCI_PM_CTRL, 0);
1874     }
1875 }
1876
1877 static Property virtio_pci_properties[] = {
1878     DEFINE_PROP_BIT("virtio-pci-bus-master-bug-migration", VirtIOPCIProxy, flags,
1879                     VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT, false),
1880     DEFINE_PROP_ON_OFF_AUTO("disable-legacy", VirtIOPCIProxy, disable_legacy,
1881                             ON_OFF_AUTO_AUTO),
1882     DEFINE_PROP_BOOL("disable-modern", VirtIOPCIProxy, disable_modern, false),
1883     DEFINE_PROP_BIT("migrate-extra", VirtIOPCIProxy, flags,
1884                     VIRTIO_PCI_FLAG_MIGRATE_EXTRA_BIT, true),
1885     DEFINE_PROP_BIT("modern-pio-notify", VirtIOPCIProxy, flags,
1886                     VIRTIO_PCI_FLAG_MODERN_PIO_NOTIFY_BIT, false),
1887     DEFINE_PROP_BIT("x-disable-pcie", VirtIOPCIProxy, flags,
1888                     VIRTIO_PCI_FLAG_DISABLE_PCIE_BIT, false),
1889     DEFINE_PROP_BIT("page-per-vq", VirtIOPCIProxy, flags,
1890                     VIRTIO_PCI_FLAG_PAGE_PER_VQ_BIT, false),
1891     DEFINE_PROP_BOOL("x-ignore-backend-features", VirtIOPCIProxy,
1892                      ignore_backend_features, false),
1893     DEFINE_PROP_BIT("ats", VirtIOPCIProxy, flags,
1894                     VIRTIO_PCI_FLAG_ATS_BIT, false),
1895     DEFINE_PROP_BIT("x-pcie-deverr-init", VirtIOPCIProxy, flags,
1896                     VIRTIO_PCI_FLAG_INIT_DEVERR_BIT, true),
1897     DEFINE_PROP_BIT("x-pcie-lnkctl-init", VirtIOPCIProxy, flags,
1898                     VIRTIO_PCI_FLAG_INIT_LNKCTL_BIT, true),
1899     DEFINE_PROP_BIT("x-pcie-pm-init", VirtIOPCIProxy, flags,
1900                     VIRTIO_PCI_FLAG_INIT_PM_BIT, true),
1901     DEFINE_PROP_END_OF_LIST(),
1902 };
1903
1904 static void virtio_pci_dc_realize(DeviceState *qdev, Error **errp)
1905 {
1906     VirtioPCIClass *vpciklass = VIRTIO_PCI_GET_CLASS(qdev);
1907     VirtIOPCIProxy *proxy = VIRTIO_PCI(qdev);
1908     PCIDevice *pci_dev = &proxy->pci_dev;
1909
1910     if (!(proxy->flags & VIRTIO_PCI_FLAG_DISABLE_PCIE) &&
1911         virtio_pci_modern(proxy)) {
1912         pci_dev->cap_present |= QEMU_PCI_CAP_EXPRESS;
1913     }
1914
1915     vpciklass->parent_dc_realize(qdev, errp);
1916 }
1917
1918 static void virtio_pci_class_init(ObjectClass *klass, void *data)
1919 {
1920     DeviceClass *dc = DEVICE_CLASS(klass);
1921     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1922     VirtioPCIClass *vpciklass = VIRTIO_PCI_CLASS(klass);
1923
1924     dc->props = virtio_pci_properties;
1925     k->realize = virtio_pci_realize;
1926     k->exit = virtio_pci_exit;
1927     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1928     k->revision = VIRTIO_PCI_ABI_VERSION;
1929     k->class_id = PCI_CLASS_OTHERS;
1930     device_class_set_parent_realize(dc, virtio_pci_dc_realize,
1931                                     &vpciklass->parent_dc_realize);
1932     dc->reset = virtio_pci_reset;
1933 }
1934
1935 static const TypeInfo virtio_pci_info = {
1936     .name          = TYPE_VIRTIO_PCI,
1937     .parent        = TYPE_PCI_DEVICE,
1938     .instance_size = sizeof(VirtIOPCIProxy),
1939     .class_init    = virtio_pci_class_init,
1940     .class_size    = sizeof(VirtioPCIClass),
1941     .abstract      = true,
1942     .interfaces = (InterfaceInfo[]) {
1943         { INTERFACE_PCIE_DEVICE },
1944         { INTERFACE_CONVENTIONAL_PCI_DEVICE },
1945         { }
1946     },
1947 };
1948
1949 /* virtio-blk-pci */
1950
1951 static Property virtio_blk_pci_properties[] = {
1952     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
1953     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1954                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1955     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
1956                        DEV_NVECTORS_UNSPECIFIED),
1957     DEFINE_PROP_END_OF_LIST(),
1958 };
1959
1960 static void virtio_blk_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1961 {
1962     VirtIOBlkPCI *dev = VIRTIO_BLK_PCI(vpci_dev);
1963     DeviceState *vdev = DEVICE(&dev->vdev);
1964
1965     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
1966         vpci_dev->nvectors = dev->vdev.conf.num_queues + 1;
1967     }
1968
1969     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1970     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1971 }
1972
1973 static void virtio_blk_pci_class_init(ObjectClass *klass, void *data)
1974 {
1975     DeviceClass *dc = DEVICE_CLASS(klass);
1976     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1977     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1978
1979     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1980     dc->props = virtio_blk_pci_properties;
1981     k->realize = virtio_blk_pci_realize;
1982     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1983     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BLOCK;
1984     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1985     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
1986 }
1987
1988 static void virtio_blk_pci_instance_init(Object *obj)
1989 {
1990     VirtIOBlkPCI *dev = VIRTIO_BLK_PCI(obj);
1991
1992     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1993                                 TYPE_VIRTIO_BLK);
1994     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
1995                               "bootindex", &error_abort);
1996 }
1997
1998 static const TypeInfo virtio_blk_pci_info = {
1999     .name          = TYPE_VIRTIO_BLK_PCI,
2000     .parent        = TYPE_VIRTIO_PCI,
2001     .instance_size = sizeof(VirtIOBlkPCI),
2002     .instance_init = virtio_blk_pci_instance_init,
2003     .class_init    = virtio_blk_pci_class_init,
2004 };
2005
2006 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
2007 /* vhost-user-blk */
2008
2009 static Property vhost_user_blk_pci_properties[] = {
2010     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
2011     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
2012                        DEV_NVECTORS_UNSPECIFIED),
2013     DEFINE_PROP_END_OF_LIST(),
2014 };
2015
2016 static void vhost_user_blk_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2017 {
2018     VHostUserBlkPCI *dev = VHOST_USER_BLK_PCI(vpci_dev);
2019     DeviceState *vdev = DEVICE(&dev->vdev);
2020
2021     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
2022         vpci_dev->nvectors = dev->vdev.num_queues + 1;
2023     }
2024
2025     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2026     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2027 }
2028
2029 static void vhost_user_blk_pci_class_init(ObjectClass *klass, void *data)
2030 {
2031     DeviceClass *dc = DEVICE_CLASS(klass);
2032     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2033     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2034
2035     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
2036     dc->props = vhost_user_blk_pci_properties;
2037     k->realize = vhost_user_blk_pci_realize;
2038     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2039     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BLOCK;
2040     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
2041     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
2042 }
2043
2044 static void vhost_user_blk_pci_instance_init(Object *obj)
2045 {
2046     VHostUserBlkPCI *dev = VHOST_USER_BLK_PCI(obj);
2047
2048     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2049                                 TYPE_VHOST_USER_BLK);
2050     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
2051                               "bootindex", &error_abort);
2052 }
2053
2054 static const TypeInfo vhost_user_blk_pci_info = {
2055     .name           = TYPE_VHOST_USER_BLK_PCI,
2056     .parent         = TYPE_VIRTIO_PCI,
2057     .instance_size  = sizeof(VHostUserBlkPCI),
2058     .instance_init  = vhost_user_blk_pci_instance_init,
2059     .class_init     = vhost_user_blk_pci_class_init,
2060 };
2061 #endif
2062
2063 /* virtio-scsi-pci */
2064
2065 static Property virtio_scsi_pci_properties[] = {
2066     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
2067                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
2068     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
2069                        DEV_NVECTORS_UNSPECIFIED),
2070     DEFINE_PROP_END_OF_LIST(),
2071 };
2072
2073 static void virtio_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2074 {
2075     VirtIOSCSIPCI *dev = VIRTIO_SCSI_PCI(vpci_dev);
2076     DeviceState *vdev = DEVICE(&dev->vdev);
2077     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
2078     DeviceState *proxy = DEVICE(vpci_dev);
2079     char *bus_name;
2080
2081     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
2082         vpci_dev->nvectors = vs->conf.num_queues + 3;
2083     }
2084
2085     /*
2086      * For command line compatibility, this sets the virtio-scsi-device bus
2087      * name as before.
2088      */
2089     if (proxy->id) {
2090         bus_name = g_strdup_printf("%s.0", proxy->id);
2091         virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);
2092         g_free(bus_name);
2093     }
2094
2095     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2096     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2097 }
2098
2099 static void virtio_scsi_pci_class_init(ObjectClass *klass, void *data)
2100 {
2101     DeviceClass *dc = DEVICE_CLASS(klass);
2102     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2103     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2104
2105     k->realize = virtio_scsi_pci_realize;
2106     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
2107     dc->props = virtio_scsi_pci_properties;
2108     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2109     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
2110     pcidev_k->revision = 0x00;
2111     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
2112 }
2113
2114 static void virtio_scsi_pci_instance_init(Object *obj)
2115 {
2116     VirtIOSCSIPCI *dev = VIRTIO_SCSI_PCI(obj);
2117
2118     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2119                                 TYPE_VIRTIO_SCSI);
2120 }
2121
2122 static const TypeInfo virtio_scsi_pci_info = {
2123     .name          = TYPE_VIRTIO_SCSI_PCI,
2124     .parent        = TYPE_VIRTIO_PCI,
2125     .instance_size = sizeof(VirtIOSCSIPCI),
2126     .instance_init = virtio_scsi_pci_instance_init,
2127     .class_init    = virtio_scsi_pci_class_init,
2128 };
2129
2130 /* vhost-scsi-pci */
2131
2132 #ifdef CONFIG_VHOST_SCSI
2133 static Property vhost_scsi_pci_properties[] = {
2134     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
2135                        DEV_NVECTORS_UNSPECIFIED),
2136     DEFINE_PROP_END_OF_LIST(),
2137 };
2138
2139 static void vhost_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2140 {
2141     VHostSCSIPCI *dev = VHOST_SCSI_PCI(vpci_dev);
2142     DeviceState *vdev = DEVICE(&dev->vdev);
2143     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
2144
2145     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
2146         vpci_dev->nvectors = vs->conf.num_queues + 3;
2147     }
2148
2149     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2150     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2151 }
2152
2153 static void vhost_scsi_pci_class_init(ObjectClass *klass, void *data)
2154 {
2155     DeviceClass *dc = DEVICE_CLASS(klass);
2156     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2157     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2158     k->realize = vhost_scsi_pci_realize;
2159     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
2160     dc->props = vhost_scsi_pci_properties;
2161     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2162     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
2163     pcidev_k->revision = 0x00;
2164     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
2165 }
2166
2167 static void vhost_scsi_pci_instance_init(Object *obj)
2168 {
2169     VHostSCSIPCI *dev = VHOST_SCSI_PCI(obj);
2170
2171     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2172                                 TYPE_VHOST_SCSI);
2173     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
2174                               "bootindex", &error_abort);
2175 }
2176
2177 static const TypeInfo vhost_scsi_pci_info = {
2178     .name          = TYPE_VHOST_SCSI_PCI,
2179     .parent        = TYPE_VIRTIO_PCI,
2180     .instance_size = sizeof(VHostSCSIPCI),
2181     .instance_init = vhost_scsi_pci_instance_init,
2182     .class_init    = vhost_scsi_pci_class_init,
2183 };
2184 #endif
2185
2186 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
2187 /* vhost-user-scsi-pci */
2188 static Property vhost_user_scsi_pci_properties[] = {
2189     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
2190                        DEV_NVECTORS_UNSPECIFIED),
2191     DEFINE_PROP_END_OF_LIST(),
2192 };
2193
2194 static void vhost_user_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2195 {
2196     VHostUserSCSIPCI *dev = VHOST_USER_SCSI_PCI(vpci_dev);
2197     DeviceState *vdev = DEVICE(&dev->vdev);
2198     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
2199
2200     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
2201         vpci_dev->nvectors = vs->conf.num_queues + 3;
2202     }
2203
2204     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2205     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2206 }
2207
2208 static void vhost_user_scsi_pci_class_init(ObjectClass *klass, void *data)
2209 {
2210     DeviceClass *dc = DEVICE_CLASS(klass);
2211     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2212     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2213     k->realize = vhost_user_scsi_pci_realize;
2214     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
2215     dc->props = vhost_user_scsi_pci_properties;
2216     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2217     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
2218     pcidev_k->revision = 0x00;
2219     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
2220 }
2221
2222 static void vhost_user_scsi_pci_instance_init(Object *obj)
2223 {
2224     VHostUserSCSIPCI *dev = VHOST_USER_SCSI_PCI(obj);
2225
2226     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2227                                 TYPE_VHOST_USER_SCSI);
2228     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
2229                               "bootindex", &error_abort);
2230 }
2231
2232 static const TypeInfo vhost_user_scsi_pci_info = {
2233     .name          = TYPE_VHOST_USER_SCSI_PCI,
2234     .parent        = TYPE_VIRTIO_PCI,
2235     .instance_size = sizeof(VHostUserSCSIPCI),
2236     .instance_init = vhost_user_scsi_pci_instance_init,
2237     .class_init    = vhost_user_scsi_pci_class_init,
2238 };
2239 #endif
2240
2241 /* vhost-vsock-pci */
2242
2243 #ifdef CONFIG_VHOST_VSOCK
2244 static Property vhost_vsock_pci_properties[] = {
2245     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
2246     DEFINE_PROP_END_OF_LIST(),
2247 };
2248
2249 static void vhost_vsock_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2250 {
2251     VHostVSockPCI *dev = VHOST_VSOCK_PCI(vpci_dev);
2252     DeviceState *vdev = DEVICE(&dev->vdev);
2253
2254     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2255     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2256 }
2257
2258 static void vhost_vsock_pci_class_init(ObjectClass *klass, void *data)
2259 {
2260     DeviceClass *dc = DEVICE_CLASS(klass);
2261     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2262     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2263     k->realize = vhost_vsock_pci_realize;
2264     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
2265     dc->props = vhost_vsock_pci_properties;
2266     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2267     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_VSOCK;
2268     pcidev_k->revision = 0x00;
2269     pcidev_k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
2270 }
2271
2272 static void vhost_vsock_pci_instance_init(Object *obj)
2273 {
2274     VHostVSockPCI *dev = VHOST_VSOCK_PCI(obj);
2275
2276     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2277                                 TYPE_VHOST_VSOCK);
2278 }
2279
2280 static const TypeInfo vhost_vsock_pci_info = {
2281     .name          = TYPE_VHOST_VSOCK_PCI,
2282     .parent        = TYPE_VIRTIO_PCI,
2283     .instance_size = sizeof(VHostVSockPCI),
2284     .instance_init = vhost_vsock_pci_instance_init,
2285     .class_init    = vhost_vsock_pci_class_init,
2286 };
2287 #endif
2288
2289 /* virtio-balloon-pci */
2290
2291 static Property virtio_balloon_pci_properties[] = {
2292     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
2293     DEFINE_PROP_END_OF_LIST(),
2294 };
2295
2296 static void virtio_balloon_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2297 {
2298     VirtIOBalloonPCI *dev = VIRTIO_BALLOON_PCI(vpci_dev);
2299     DeviceState *vdev = DEVICE(&dev->vdev);
2300
2301     if (vpci_dev->class_code != PCI_CLASS_OTHERS &&
2302         vpci_dev->class_code != PCI_CLASS_MEMORY_RAM) { /* qemu < 1.1 */
2303         vpci_dev->class_code = PCI_CLASS_OTHERS;
2304     }
2305
2306     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2307     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2308 }
2309
2310 static void virtio_balloon_pci_class_init(ObjectClass *klass, void *data)
2311 {
2312     DeviceClass *dc = DEVICE_CLASS(klass);
2313     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2314     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2315     k->realize = virtio_balloon_pci_realize;
2316     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
2317     dc->props = virtio_balloon_pci_properties;
2318     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2319     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BALLOON;
2320     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
2321     pcidev_k->class_id = PCI_CLASS_OTHERS;
2322 }
2323
2324 static void virtio_balloon_pci_instance_init(Object *obj)
2325 {
2326     VirtIOBalloonPCI *dev = VIRTIO_BALLOON_PCI(obj);
2327
2328     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2329                                 TYPE_VIRTIO_BALLOON);
2330     object_property_add_alias(obj, "guest-stats", OBJECT(&dev->vdev),
2331                                   "guest-stats", &error_abort);
2332     object_property_add_alias(obj, "guest-stats-polling-interval",
2333                               OBJECT(&dev->vdev),
2334                               "guest-stats-polling-interval", &error_abort);
2335 }
2336
2337 static const TypeInfo virtio_balloon_pci_info = {
2338     .name          = TYPE_VIRTIO_BALLOON_PCI,
2339     .parent        = TYPE_VIRTIO_PCI,
2340     .instance_size = sizeof(VirtIOBalloonPCI),
2341     .instance_init = virtio_balloon_pci_instance_init,
2342     .class_init    = virtio_balloon_pci_class_init,
2343 };
2344
2345 /* virtio-serial-pci */
2346
2347 static void virtio_serial_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2348 {
2349     VirtIOSerialPCI *dev = VIRTIO_SERIAL_PCI(vpci_dev);
2350     DeviceState *vdev = DEVICE(&dev->vdev);
2351     DeviceState *proxy = DEVICE(vpci_dev);
2352     char *bus_name;
2353
2354     if (vpci_dev->class_code != PCI_CLASS_COMMUNICATION_OTHER &&
2355         vpci_dev->class_code != PCI_CLASS_DISPLAY_OTHER && /* qemu 0.10 */
2356         vpci_dev->class_code != PCI_CLASS_OTHERS) {        /* qemu-kvm  */
2357             vpci_dev->class_code = PCI_CLASS_COMMUNICATION_OTHER;
2358     }
2359
2360     /* backwards-compatibility with machines that were created with
2361        DEV_NVECTORS_UNSPECIFIED */
2362     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
2363         vpci_dev->nvectors = dev->vdev.serial.max_virtserial_ports + 1;
2364     }
2365
2366     /*
2367      * For command line compatibility, this sets the virtio-serial-device bus
2368      * name as before.
2369      */
2370     if (proxy->id) {
2371         bus_name = g_strdup_printf("%s.0", proxy->id);
2372         virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);
2373         g_free(bus_name);
2374     }
2375
2376     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2377     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2378 }
2379
2380 static Property virtio_serial_pci_properties[] = {
2381     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
2382                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
2383     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
2384     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
2385     DEFINE_PROP_END_OF_LIST(),
2386 };
2387
2388 static void virtio_serial_pci_class_init(ObjectClass *klass, void *data)
2389 {
2390     DeviceClass *dc = DEVICE_CLASS(klass);
2391     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2392     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2393     k->realize = virtio_serial_pci_realize;
2394     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
2395     dc->props = virtio_serial_pci_properties;
2396     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2397     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
2398     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
2399     pcidev_k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
2400 }
2401
2402 static void virtio_serial_pci_instance_init(Object *obj)
2403 {
2404     VirtIOSerialPCI *dev = VIRTIO_SERIAL_PCI(obj);
2405
2406     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2407                                 TYPE_VIRTIO_SERIAL);
2408 }
2409
2410 static const TypeInfo virtio_serial_pci_info = {
2411     .name          = TYPE_VIRTIO_SERIAL_PCI,
2412     .parent        = TYPE_VIRTIO_PCI,
2413     .instance_size = sizeof(VirtIOSerialPCI),
2414     .instance_init = virtio_serial_pci_instance_init,
2415     .class_init    = virtio_serial_pci_class_init,
2416 };
2417
2418 /* virtio-net-pci */
2419
2420 static Property virtio_net_properties[] = {
2421     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
2422                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
2423     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
2424     DEFINE_PROP_END_OF_LIST(),
2425 };
2426
2427 static void virtio_net_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2428 {
2429     DeviceState *qdev = DEVICE(vpci_dev);
2430     VirtIONetPCI *dev = VIRTIO_NET_PCI(vpci_dev);
2431     DeviceState *vdev = DEVICE(&dev->vdev);
2432
2433     virtio_net_set_netclient_name(&dev->vdev, qdev->id,
2434                                   object_get_typename(OBJECT(qdev)));
2435     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2436     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2437 }
2438
2439 static void virtio_net_pci_class_init(ObjectClass *klass, void *data)
2440 {
2441     DeviceClass *dc = DEVICE_CLASS(klass);
2442     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
2443     VirtioPCIClass *vpciklass = VIRTIO_PCI_CLASS(klass);
2444
2445     k->romfile = "efi-virtio.rom";
2446     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2447     k->device_id = PCI_DEVICE_ID_VIRTIO_NET;
2448     k->revision = VIRTIO_PCI_ABI_VERSION;
2449     k->class_id = PCI_CLASS_NETWORK_ETHERNET;
2450     set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
2451     dc->props = virtio_net_properties;
2452     vpciklass->realize = virtio_net_pci_realize;
2453 }
2454
2455 static void virtio_net_pci_instance_init(Object *obj)
2456 {
2457     VirtIONetPCI *dev = VIRTIO_NET_PCI(obj);
2458
2459     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2460                                 TYPE_VIRTIO_NET);
2461     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
2462                               "bootindex", &error_abort);
2463 }
2464
2465 static const TypeInfo virtio_net_pci_info = {
2466     .name          = TYPE_VIRTIO_NET_PCI,
2467     .parent        = TYPE_VIRTIO_PCI,
2468     .instance_size = sizeof(VirtIONetPCI),
2469     .instance_init = virtio_net_pci_instance_init,
2470     .class_init    = virtio_net_pci_class_init,
2471 };
2472
2473 /* virtio-rng-pci */
2474
2475 static void virtio_rng_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2476 {
2477     VirtIORngPCI *vrng = VIRTIO_RNG_PCI(vpci_dev);
2478     DeviceState *vdev = DEVICE(&vrng->vdev);
2479     Error *err = NULL;
2480
2481     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2482     object_property_set_bool(OBJECT(vdev), true, "realized", &err);
2483     if (err) {
2484         error_propagate(errp, err);
2485         return;
2486     }
2487
2488     object_property_set_link(OBJECT(vrng),
2489                              OBJECT(vrng->vdev.conf.rng), "rng",
2490                              NULL);
2491 }
2492
2493 static void virtio_rng_pci_class_init(ObjectClass *klass, void *data)
2494 {
2495     DeviceClass *dc = DEVICE_CLASS(klass);
2496     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2497     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2498
2499     k->realize = virtio_rng_pci_realize;
2500     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
2501
2502     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2503     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_RNG;
2504     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
2505     pcidev_k->class_id = PCI_CLASS_OTHERS;
2506 }
2507
2508 static void virtio_rng_initfn(Object *obj)
2509 {
2510     VirtIORngPCI *dev = VIRTIO_RNG_PCI(obj);
2511
2512     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2513                                 TYPE_VIRTIO_RNG);
2514 }
2515
2516 static const TypeInfo virtio_rng_pci_info = {
2517     .name          = TYPE_VIRTIO_RNG_PCI,
2518     .parent        = TYPE_VIRTIO_PCI,
2519     .instance_size = sizeof(VirtIORngPCI),
2520     .instance_init = virtio_rng_initfn,
2521     .class_init    = virtio_rng_pci_class_init,
2522 };
2523
2524 /* virtio-input-pci */
2525
2526 static Property virtio_input_pci_properties[] = {
2527     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
2528     DEFINE_PROP_END_OF_LIST(),
2529 };
2530
2531 static void virtio_input_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2532 {
2533     VirtIOInputPCI *vinput = VIRTIO_INPUT_PCI(vpci_dev);
2534     DeviceState *vdev = DEVICE(&vinput->vdev);
2535
2536     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2537     virtio_pci_force_virtio_1(vpci_dev);
2538     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2539 }
2540
2541 static void virtio_input_pci_class_init(ObjectClass *klass, void *data)
2542 {
2543     DeviceClass *dc = DEVICE_CLASS(klass);
2544     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2545     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2546
2547     dc->props = virtio_input_pci_properties;
2548     k->realize = virtio_input_pci_realize;
2549     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
2550
2551     pcidev_k->class_id = PCI_CLASS_INPUT_OTHER;
2552 }
2553
2554 static void virtio_input_hid_kbd_pci_class_init(ObjectClass *klass, void *data)
2555 {
2556     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2557
2558     pcidev_k->class_id = PCI_CLASS_INPUT_KEYBOARD;
2559 }
2560
2561 static void virtio_input_hid_mouse_pci_class_init(ObjectClass *klass,
2562                                                   void *data)
2563 {
2564     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2565
2566     pcidev_k->class_id = PCI_CLASS_INPUT_MOUSE;
2567 }
2568
2569 static void virtio_keyboard_initfn(Object *obj)
2570 {
2571     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2572
2573     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2574                                 TYPE_VIRTIO_KEYBOARD);
2575 }
2576
2577 static void virtio_mouse_initfn(Object *obj)
2578 {
2579     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2580
2581     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2582                                 TYPE_VIRTIO_MOUSE);
2583 }
2584
2585 static void virtio_tablet_initfn(Object *obj)
2586 {
2587     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2588
2589     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2590                                 TYPE_VIRTIO_TABLET);
2591 }
2592
2593 static const TypeInfo virtio_input_pci_info = {
2594     .name          = TYPE_VIRTIO_INPUT_PCI,
2595     .parent        = TYPE_VIRTIO_PCI,
2596     .instance_size = sizeof(VirtIOInputPCI),
2597     .class_init    = virtio_input_pci_class_init,
2598     .abstract      = true,
2599 };
2600
2601 static const TypeInfo virtio_input_hid_pci_info = {
2602     .name          = TYPE_VIRTIO_INPUT_HID_PCI,
2603     .parent        = TYPE_VIRTIO_INPUT_PCI,
2604     .instance_size = sizeof(VirtIOInputHIDPCI),
2605     .abstract      = true,
2606 };
2607
2608 static const TypeInfo virtio_keyboard_pci_info = {
2609     .name          = TYPE_VIRTIO_KEYBOARD_PCI,
2610     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2611     .class_init    = virtio_input_hid_kbd_pci_class_init,
2612     .instance_size = sizeof(VirtIOInputHIDPCI),
2613     .instance_init = virtio_keyboard_initfn,
2614 };
2615
2616 static const TypeInfo virtio_mouse_pci_info = {
2617     .name          = TYPE_VIRTIO_MOUSE_PCI,
2618     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2619     .class_init    = virtio_input_hid_mouse_pci_class_init,
2620     .instance_size = sizeof(VirtIOInputHIDPCI),
2621     .instance_init = virtio_mouse_initfn,
2622 };
2623
2624 static const TypeInfo virtio_tablet_pci_info = {
2625     .name          = TYPE_VIRTIO_TABLET_PCI,
2626     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2627     .instance_size = sizeof(VirtIOInputHIDPCI),
2628     .instance_init = virtio_tablet_initfn,
2629 };
2630
2631 #ifdef CONFIG_LINUX
2632 static void virtio_host_initfn(Object *obj)
2633 {
2634     VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(obj);
2635
2636     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2637                                 TYPE_VIRTIO_INPUT_HOST);
2638 }
2639
2640 static const TypeInfo virtio_host_pci_info = {
2641     .name          = TYPE_VIRTIO_INPUT_HOST_PCI,
2642     .parent        = TYPE_VIRTIO_INPUT_PCI,
2643     .instance_size = sizeof(VirtIOInputHostPCI),
2644     .instance_init = virtio_host_initfn,
2645 };
2646 #endif
2647
2648 /* virtio-pci-bus */
2649
2650 static void virtio_pci_bus_new(VirtioBusState *bus, size_t bus_size,
2651                                VirtIOPCIProxy *dev)
2652 {
2653     DeviceState *qdev = DEVICE(dev);
2654     char virtio_bus_name[] = "virtio-bus";
2655
2656     qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_PCI_BUS, qdev,
2657                         virtio_bus_name);
2658 }
2659
2660 static void virtio_pci_bus_class_init(ObjectClass *klass, void *data)
2661 {
2662     BusClass *bus_class = BUS_CLASS(klass);
2663     VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
2664     bus_class->max_dev = 1;
2665     k->notify = virtio_pci_notify;
2666     k->save_config = virtio_pci_save_config;
2667     k->load_config = virtio_pci_load_config;
2668     k->save_queue = virtio_pci_save_queue;
2669     k->load_queue = virtio_pci_load_queue;
2670     k->save_extra_state = virtio_pci_save_extra_state;
2671     k->load_extra_state = virtio_pci_load_extra_state;
2672     k->has_extra_state = virtio_pci_has_extra_state;
2673     k->query_guest_notifiers = virtio_pci_query_guest_notifiers;
2674     k->set_guest_notifiers = virtio_pci_set_guest_notifiers;
2675     k->set_host_notifier_mr = virtio_pci_set_host_notifier_mr;
2676     k->vmstate_change = virtio_pci_vmstate_change;
2677     k->pre_plugged = virtio_pci_pre_plugged;
2678     k->device_plugged = virtio_pci_device_plugged;
2679     k->device_unplugged = virtio_pci_device_unplugged;
2680     k->query_nvectors = virtio_pci_query_nvectors;
2681     k->ioeventfd_enabled = virtio_pci_ioeventfd_enabled;
2682     k->ioeventfd_assign = virtio_pci_ioeventfd_assign;
2683     k->get_dma_as = virtio_pci_get_dma_as;
2684 }
2685
2686 static const TypeInfo virtio_pci_bus_info = {
2687     .name          = TYPE_VIRTIO_PCI_BUS,
2688     .parent        = TYPE_VIRTIO_BUS,
2689     .instance_size = sizeof(VirtioPCIBusState),
2690     .class_init    = virtio_pci_bus_class_init,
2691 };
2692
2693 static void virtio_pci_register_types(void)
2694 {
2695     type_register_static(&virtio_rng_pci_info);
2696     type_register_static(&virtio_input_pci_info);
2697     type_register_static(&virtio_input_hid_pci_info);
2698     type_register_static(&virtio_keyboard_pci_info);
2699     type_register_static(&virtio_mouse_pci_info);
2700     type_register_static(&virtio_tablet_pci_info);
2701 #ifdef CONFIG_LINUX
2702     type_register_static(&virtio_host_pci_info);
2703 #endif
2704     type_register_static(&virtio_pci_bus_info);
2705     type_register_static(&virtio_pci_info);
2706 #ifdef CONFIG_VIRTFS
2707     type_register_static(&virtio_9p_pci_info);
2708 #endif
2709     type_register_static(&virtio_blk_pci_info);
2710 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
2711     type_register_static(&vhost_user_blk_pci_info);
2712 #endif
2713     type_register_static(&virtio_scsi_pci_info);
2714     type_register_static(&virtio_balloon_pci_info);
2715     type_register_static(&virtio_serial_pci_info);
2716     type_register_static(&virtio_net_pci_info);
2717 #ifdef CONFIG_VHOST_SCSI
2718     type_register_static(&vhost_scsi_pci_info);
2719 #endif
2720 #if defined(CONFIG_VHOST_USER) && defined(CONFIG_LINUX)
2721     type_register_static(&vhost_user_scsi_pci_info);
2722 #endif
2723 #ifdef CONFIG_VHOST_VSOCK
2724     type_register_static(&vhost_vsock_pci_info);
2725 #endif
2726 }
2727
2728 type_init(virtio_pci_register_types)