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 <inttypes.h>
  19
  20 #include "standard-headers/linux/virtio_pci.h"
  21 #include "hw/virtio/virtio.h"
  22 #include "hw/virtio/virtio-blk.h"
  23 #include "hw/virtio/virtio-net.h"
  24 #include "hw/virtio/virtio-serial.h"
  25 #include "hw/virtio/virtio-scsi.h"
  26 #include "hw/virtio/virtio-balloon.h"
  27 #include "hw/virtio/virtio-input.h"
  28 #include "hw/pci/pci.h"
  29 #include "qemu/error-report.h"
  30 #include "hw/pci/msi.h"
  31 #include "hw/pci/msix.h"
  32 #include "hw/loader.h"
  33 #include "sysemu/kvm.h"
  34 #include "sysemu/block-backend.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
  51 /* virtio device */
  52 /* DeviceState to VirtIOPCIProxy. For use off data-path. TODO: use QOM. */
  53 static inline VirtIOPCIProxy *to_virtio_pci_proxy(DeviceState *d)
  54 {
  55     return container_of(d, VirtIOPCIProxy, pci_dev.qdev);
  56 }
  57
  58 /* DeviceState to VirtIOPCIProxy. Note: used on datapath,
  59  * be careful and test performance if you change this.
  60  */
  61 static inline VirtIOPCIProxy *to_virtio_pci_proxy_fast(DeviceState *d)
  62 {
  63     return container_of(d, VirtIOPCIProxy, pci_dev.qdev);
  64 }
  65
  66 static void virtio_pci_notify(DeviceState *d, uint16_t vector)
  67 {
  68     VirtIOPCIProxy *proxy = to_virtio_pci_proxy_fast(d);
  69
  70     if (msix_enabled(&proxy->pci_dev))
  71         msix_notify(&proxy->pci_dev, vector);
  72     else {
  73         VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  74         pci_set_irq(&proxy->pci_dev, vdev->isr & 1);
  75     }
  76 }
  77
  78 static void virtio_pci_save_config(DeviceState *d, QEMUFile *f)
  79 {
  80     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
  81     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  82
  83     pci_device_save(&proxy->pci_dev, f);
  84     msix_save(&proxy->pci_dev, f);
  85     if (msix_present(&proxy->pci_dev))
  86         qemu_put_be16(f, vdev->config_vector);
  87 }
  88
  89 static void virtio_pci_save_queue(DeviceState *d, int n, QEMUFile *f)
  90 {
  91     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
  92     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
  93
  94     if (msix_present(&proxy->pci_dev))
  95         qemu_put_be16(f, virtio_queue_vector(vdev, n));
  96 }
  97
  98 static int virtio_pci_load_config(DeviceState *d, QEMUFile *f)
  99 {
 100     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 101     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 102
 103     int ret;
 104     ret = pci_device_load(&proxy->pci_dev, f);
 105     if (ret) {
 106         return ret;
 107     }
 108     msix_unuse_all_vectors(&proxy->pci_dev);
 109     msix_load(&proxy->pci_dev, f);
 110     if (msix_present(&proxy->pci_dev)) {
 111         qemu_get_be16s(f, &vdev->config_vector);
 112     } else {
 113         vdev->config_vector = VIRTIO_NO_VECTOR;
 114     }
 115     if (vdev->config_vector != VIRTIO_NO_VECTOR) {
 116         return msix_vector_use(&proxy->pci_dev, vdev->config_vector);
 117     }
 118     return 0;
 119 }
 120
 121 static int virtio_pci_load_queue(DeviceState *d, int n, QEMUFile *f)
 122 {
 123     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 124     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 125
 126     uint16_t vector;
 127     if (msix_present(&proxy->pci_dev)) {
 128         qemu_get_be16s(f, &vector);
 129     } else {
 130         vector = VIRTIO_NO_VECTOR;
 131     }
 132     virtio_queue_set_vector(vdev, n, vector);
 133     if (vector != VIRTIO_NO_VECTOR) {
 134         return msix_vector_use(&proxy->pci_dev, vector);
 135     }
 136     return 0;
 137 }
 138
 139 #define QEMU_VIRTIO_PCI_QUEUE_MEM_MULT 0x1000
 140
 141 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy,
 142                                                  int n, bool assign, bool set_handler)
 143 {
 144     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 145     VirtQueue *vq = virtio_get_queue(vdev, n);
 146     EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
 147     bool legacy = !(proxy->flags & VIRTIO_PCI_FLAG_DISABLE_LEGACY);
 148     bool modern = !(proxy->flags & VIRTIO_PCI_FLAG_DISABLE_MODERN);
 149     MemoryRegion *modern_mr = &proxy->notify.mr;
 150     MemoryRegion *legacy_mr = &proxy->bar;
 151     hwaddr modern_addr = QEMU_VIRTIO_PCI_QUEUE_MEM_MULT *
 152                          virtio_get_queue_index(vq);
 153     hwaddr legacy_addr = VIRTIO_PCI_QUEUE_NOTIFY;
 154     int r = 0;
 155
 156     if (assign) {
 157         r = event_notifier_init(notifier, 1);
 158         if (r < 0) {
 159             error_report("%s: unable to init event notifier: %d",
 160                          __func__, r);
 161             return r;
 162         }
 163         virtio_queue_set_host_notifier_fd_handler(vq, true, set_handler);
 164         if (modern) {
 165             memory_region_add_eventfd(modern_mr, modern_addr, 2,
 166                                       true, n, notifier);
 167         }
 168         if (legacy) {
 169             memory_region_add_eventfd(legacy_mr, legacy_addr, 2,
 170                                       true, n, notifier);
 171         }
 172     } else {
 173         if (modern) {
 174             memory_region_del_eventfd(modern_mr, modern_addr, 2,
 175                                       true, n, notifier);
 176         }
 177         if (legacy) {
 178             memory_region_del_eventfd(legacy_mr, legacy_addr, 2,
 179                                       true, n, notifier);
 180         }
 181         virtio_queue_set_host_notifier_fd_handler(vq, false, false);
 182         event_notifier_cleanup(notifier);
 183     }
 184     return r;
 185 }
 186
 187 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy)
 188 {
 189     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 190     int n, r;
 191
 192     if (!(proxy->flags & VIRTIO_PCI_FLAG_USE_IOEVENTFD) ||
 193         proxy->ioeventfd_disabled ||
 194         proxy->ioeventfd_started) {
 195         return;
 196     }
 197
 198     for (n = 0; n < VIRTIO_QUEUE_MAX; n++) {
 199         if (!virtio_queue_get_num(vdev, n)) {
 200             continue;
 201         }
 202
 203         r = virtio_pci_set_host_notifier_internal(proxy, n, true, true);
 204         if (r < 0) {
 205             goto assign_error;
 206         }
 207     }
 208     proxy->ioeventfd_started = true;
 209     return;
 210
 211 assign_error:
 212     while (--n >= 0) {
 213         if (!virtio_queue_get_num(vdev, n)) {
 214             continue;
 215         }
 216
 217         r = virtio_pci_set_host_notifier_internal(proxy, n, false, false);
 218         assert(r >= 0);
 219     }
 220     proxy->ioeventfd_started = false;
 221     error_report("%s: failed. Fallback to a userspace (slower).", __func__);
 222 }
 223
 224 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy)
 225 {
 226     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 227     int r;
 228     int n;
 229
 230     if (!proxy->ioeventfd_started) {
 231         return;
 232     }
 233
 234     for (n = 0; n < VIRTIO_QUEUE_MAX; n++) {
 235         if (!virtio_queue_get_num(vdev, n)) {
 236             continue;
 237         }
 238
 239         r = virtio_pci_set_host_notifier_internal(proxy, n, false, false);
 240         assert(r >= 0);
 241     }
 242     proxy->ioeventfd_started = false;
 243 }
 244
 245 static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 246 {
 247     VirtIOPCIProxy *proxy = opaque;
 248     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 249     hwaddr pa;
 250
 251     switch (addr) {
 252     case VIRTIO_PCI_GUEST_FEATURES:
 253         /* Guest does not negotiate properly?  We have to assume nothing. */
 254         if (val & (1 << VIRTIO_F_BAD_FEATURE)) {
 255             val = virtio_bus_get_vdev_bad_features(&proxy->bus);
 256         }
 257         virtio_set_features(vdev, val);
 258         break;
 259     case VIRTIO_PCI_QUEUE_PFN:
 260         pa = (hwaddr)val << VIRTIO_PCI_QUEUE_ADDR_SHIFT;
 261         if (pa == 0) {
 262             virtio_pci_stop_ioeventfd(proxy);
 263             virtio_reset(vdev);
 264             msix_unuse_all_vectors(&proxy->pci_dev);
 265         }
 266         else
 267             virtio_queue_set_addr(vdev, vdev->queue_sel, pa);
 268         break;
 269     case VIRTIO_PCI_QUEUE_SEL:
 270         if (val < VIRTIO_QUEUE_MAX)
 271             vdev->queue_sel = val;
 272         break;
 273     case VIRTIO_PCI_QUEUE_NOTIFY:
 274         if (val < VIRTIO_QUEUE_MAX) {
 275             virtio_queue_notify(vdev, val);
 276         }
 277         break;
 278     case VIRTIO_PCI_STATUS:
 279         if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) {
 280             virtio_pci_stop_ioeventfd(proxy);
 281         }
 282
 283         virtio_set_status(vdev, val & 0xFF);
 284
 285         if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
 286             virtio_pci_start_ioeventfd(proxy);
 287         }
 288
 289         if (vdev->status == 0) {
 290             virtio_reset(vdev);
 291             msix_unuse_all_vectors(&proxy->pci_dev);
 292         }
 293
 294         /* Linux before 2.6.34 drives the device without enabling
 295            the PCI device bus master bit. Enable it automatically
 296            for the guest. This is a PCI spec violation but so is
 297            initiating DMA with bus master bit clear. */
 298         if (val == (VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER)) {
 299             pci_default_write_config(&proxy->pci_dev, PCI_COMMAND,
 300                                      proxy->pci_dev.config[PCI_COMMAND] |
 301                                      PCI_COMMAND_MASTER, 1);
 302         }
 303         break;
 304     case VIRTIO_MSI_CONFIG_VECTOR:
 305         msix_vector_unuse(&proxy->pci_dev, vdev->config_vector);
 306         /* Make it possible for guest to discover an error took place. */
 307         if (msix_vector_use(&proxy->pci_dev, val) < 0)
 308             val = VIRTIO_NO_VECTOR;
 309         vdev->config_vector = val;
 310         break;
 311     case VIRTIO_MSI_QUEUE_VECTOR:
 312         msix_vector_unuse(&proxy->pci_dev,
 313                           virtio_queue_vector(vdev, vdev->queue_sel));
 314         /* Make it possible for guest to discover an error took place. */
 315         if (msix_vector_use(&proxy->pci_dev, val) < 0)
 316             val = VIRTIO_NO_VECTOR;
 317         virtio_queue_set_vector(vdev, vdev->queue_sel, val);
 318         break;
 319     default:
 320         error_report("%s: unexpected address 0x%x value 0x%x",
 321                      __func__, addr, val);
 322         break;
 323     }
 324 }
 325
 326 static uint32_t virtio_ioport_read(VirtIOPCIProxy *proxy, uint32_t addr)
 327 {
 328     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 329     uint32_t ret = 0xFFFFFFFF;
 330
 331     switch (addr) {
 332     case VIRTIO_PCI_HOST_FEATURES:
 333         ret = vdev->host_features;
 334         break;
 335     case VIRTIO_PCI_GUEST_FEATURES:
 336         ret = vdev->guest_features;
 337         break;
 338     case VIRTIO_PCI_QUEUE_PFN:
 339         ret = virtio_queue_get_addr(vdev, vdev->queue_sel)
 340               >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
 341         break;
 342     case VIRTIO_PCI_QUEUE_NUM:
 343         ret = virtio_queue_get_num(vdev, vdev->queue_sel);
 344         break;
 345     case VIRTIO_PCI_QUEUE_SEL:
 346         ret = vdev->queue_sel;
 347         break;
 348     case VIRTIO_PCI_STATUS:
 349         ret = vdev->status;
 350         break;
 351     case VIRTIO_PCI_ISR:
 352         /* reading from the ISR also clears it. */
 353         ret = vdev->isr;
 354         vdev->isr = 0;
 355         pci_irq_deassert(&proxy->pci_dev);
 356         break;
 357     case VIRTIO_MSI_CONFIG_VECTOR:
 358         ret = vdev->config_vector;
 359         break;
 360     case VIRTIO_MSI_QUEUE_VECTOR:
 361         ret = virtio_queue_vector(vdev, vdev->queue_sel);
 362         break;
 363     default:
 364         break;
 365     }
 366
 367     return ret;
 368 }
 369
 370 static uint64_t virtio_pci_config_read(void *opaque, hwaddr addr,
 371                                        unsigned size)
 372 {
 373     VirtIOPCIProxy *proxy = opaque;
 374     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 375     uint32_t config = VIRTIO_PCI_CONFIG_SIZE(&proxy->pci_dev);
 376     uint64_t val = 0;
 377     if (addr < config) {
 378         return virtio_ioport_read(proxy, addr);
 379     }
 380     addr -= config;
 381
 382     switch (size) {
 383     case 1:
 384         val = virtio_config_readb(vdev, addr);
 385         break;
 386     case 2:
 387         val = virtio_config_readw(vdev, addr);
 388         if (virtio_is_big_endian(vdev)) {
 389             val = bswap16(val);
 390         }
 391         break;
 392     case 4:
 393         val = virtio_config_readl(vdev, addr);
 394         if (virtio_is_big_endian(vdev)) {
 395             val = bswap32(val);
 396         }
 397         break;
 398     }
 399     return val;
 400 }
 401
 402 static void virtio_pci_config_write(void *opaque, hwaddr addr,
 403                                     uint64_t val, unsigned size)
 404 {
 405     VirtIOPCIProxy *proxy = opaque;
 406     uint32_t config = VIRTIO_PCI_CONFIG_SIZE(&proxy->pci_dev);
 407     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 408     if (addr < config) {
 409         virtio_ioport_write(proxy, addr, val);
 410         return;
 411     }
 412     addr -= config;
 413     /*
 414      * Virtio-PCI is odd. Ioports are LE but config space is target native
 415      * endian.
 416      */
 417     switch (size) {
 418     case 1:
 419         virtio_config_writeb(vdev, addr, val);
 420         break;
 421     case 2:
 422         if (virtio_is_big_endian(vdev)) {
 423             val = bswap16(val);
 424         }
 425         virtio_config_writew(vdev, addr, val);
 426         break;
 427     case 4:
 428         if (virtio_is_big_endian(vdev)) {
 429             val = bswap32(val);
 430         }
 431         virtio_config_writel(vdev, addr, val);
 432         break;
 433     }
 434 }
 435
 436 static const MemoryRegionOps virtio_pci_config_ops = {
 437     .read = virtio_pci_config_read,
 438     .write = virtio_pci_config_write,
 439     .impl = {
 440         .min_access_size = 1,
 441         .max_access_size = 4,
 442     },
 443     .endianness = DEVICE_LITTLE_ENDIAN,
 444 };
 445
 446 /* Below are generic functions to do memcpy from/to an address space,
 447  * without byteswaps, with input validation.
 448  *
 449  * As regular address_space_* APIs all do some kind of byteswap at least for
 450  * some host/target combinations, we are forced to explicitly convert to a
 451  * known-endianness integer value.
 452  * It doesn't really matter which endian format to go through, so the code
 453  * below selects the endian that causes the least amount of work on the given
 454  * host.
 455  *
 456  * Note: host pointer must be aligned.
 457  */
 458 static
 459 void virtio_address_space_write(AddressSpace *as, hwaddr addr,
 460                                 const uint8_t *buf, int len)
 461 {
 462     uint32_t val;
 463
 464     /* address_space_* APIs assume an aligned address.
 465      * As address is under guest control, handle illegal values.
 466      */
 467     addr &= ~(len - 1);
 468
 469     /* Make sure caller aligned buf properly */
 470     assert(!(((uintptr_t)buf) & (len - 1)));
 471
 472     switch (len) {
 473     case 1:
 474         val = pci_get_byte(buf);
 475         address_space_stb(as, addr, val, MEMTXATTRS_UNSPECIFIED, NULL);
 476         break;
 477     case 2:
 478         val = pci_get_word(buf);
 479         address_space_stw_le(as, addr, val, MEMTXATTRS_UNSPECIFIED, NULL);
 480         break;
 481     case 4:
 482         val = pci_get_long(buf);
 483         address_space_stl_le(as, addr, val, MEMTXATTRS_UNSPECIFIED, NULL);
 484         break;
 485     default:
 486         /* As length is under guest control, handle illegal values. */
 487         break;
 488     }
 489 }
 490
 491 static void
 492 virtio_address_space_read(AddressSpace *as, hwaddr addr, uint8_t *buf, int len)
 493 {
 494     uint32_t val;
 495
 496     /* address_space_* APIs assume an aligned address.
 497      * As address is under guest control, handle illegal values.
 498      */
 499     addr &= ~(len - 1);
 500
 501     /* Make sure caller aligned buf properly */
 502     assert(!(((uintptr_t)buf) & (len - 1)));
 503
 504     switch (len) {
 505     case 1:
 506         val = address_space_ldub(as, addr, MEMTXATTRS_UNSPECIFIED, NULL);
 507         pci_set_byte(buf, val);
 508         break;
 509     case 2:
 510         val = address_space_lduw_le(as, addr, MEMTXATTRS_UNSPECIFIED, NULL);
 511         pci_set_word(buf, val);
 512         break;
 513     case 4:
 514         val = address_space_ldl_le(as, addr, MEMTXATTRS_UNSPECIFIED, NULL);
 515         pci_set_long(buf, val);
 516         break;
 517     default:
 518         /* As length is under guest control, handle illegal values. */
 519         break;
 520     }
 521 }
 522
 523 static void virtio_write_config(PCIDevice *pci_dev, uint32_t address,
 524                                 uint32_t val, int len)
 525 {
 526     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 527     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 528     struct virtio_pci_cfg_cap *cfg;
 529
 530     pci_default_write_config(pci_dev, address, val, len);
 531
 532     if (range_covers_byte(address, len, PCI_COMMAND) &&
 533         !(pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
 534         virtio_pci_stop_ioeventfd(proxy);
 535         virtio_set_status(vdev, vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK);
 536     }
 537
 538     if (proxy->config_cap &&
 539         ranges_overlap(address, len, proxy->config_cap + offsetof(struct virtio_pci_cfg_cap,
 540                                                                   pci_cfg_data),
 541                        sizeof cfg->pci_cfg_data)) {
 542         uint32_t off;
 543         uint32_t len;
 544
 545         cfg = (void *)(proxy->pci_dev.config + proxy->config_cap);
 546         off = le32_to_cpu(cfg->cap.offset);
 547         len = le32_to_cpu(cfg->cap.length);
 548
 549         if (len == 1 || len == 2 || len == 4) {
 550             assert(len <= sizeof cfg->pci_cfg_data);
 551             virtio_address_space_write(&proxy->modern_as, off,
 552                                        cfg->pci_cfg_data, len);
 553         }
 554     }
 555 }
 556
 557 static uint32_t virtio_read_config(PCIDevice *pci_dev,
 558                                    uint32_t address, int len)
 559 {
 560     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 561     struct virtio_pci_cfg_cap *cfg;
 562
 563     if (proxy->config_cap &&
 564         ranges_overlap(address, len, proxy->config_cap + offsetof(struct virtio_pci_cfg_cap,
 565                                                                   pci_cfg_data),
 566                        sizeof cfg->pci_cfg_data)) {
 567         uint32_t off;
 568         uint32_t len;
 569
 570         cfg = (void *)(proxy->pci_dev.config + proxy->config_cap);
 571         off = le32_to_cpu(cfg->cap.offset);
 572         len = le32_to_cpu(cfg->cap.length);
 573
 574         if (len == 1 || len == 2 || len == 4) {
 575             assert(len <= sizeof cfg->pci_cfg_data);
 576             virtio_address_space_read(&proxy->modern_as, off,
 577                                       cfg->pci_cfg_data, len);
 578         }
 579     }
 580
 581     return pci_default_read_config(pci_dev, address, len);
 582 }
 583
 584 static int kvm_virtio_pci_vq_vector_use(VirtIOPCIProxy *proxy,
 585                                         unsigned int queue_no,
 586                                         unsigned int vector,
 587                                         MSIMessage msg)
 588 {
 589     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 590     int ret;
 591
 592     if (irqfd->users == 0) {
 593         ret = kvm_irqchip_add_msi_route(kvm_state, msg);
 594         if (ret < 0) {
 595             return ret;
 596         }
 597         irqfd->virq = ret;
 598     }
 599     irqfd->users++;
 600     return 0;
 601 }
 602
 603 static void kvm_virtio_pci_vq_vector_release(VirtIOPCIProxy *proxy,
 604                                              unsigned int vector)
 605 {
 606     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 607     if (--irqfd->users == 0) {
 608         kvm_irqchip_release_virq(kvm_state, irqfd->virq);
 609     }
 610 }
 611
 612 static int kvm_virtio_pci_irqfd_use(VirtIOPCIProxy *proxy,
 613                                  unsigned int queue_no,
 614                                  unsigned int vector)
 615 {
 616     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 617     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 618     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 619     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 620     int ret;
 621     ret = kvm_irqchip_add_irqfd_notifier(kvm_state, n, NULL, irqfd->virq);
 622     return ret;
 623 }
 624
 625 static void kvm_virtio_pci_irqfd_release(VirtIOPCIProxy *proxy,
 626                                       unsigned int queue_no,
 627                                       unsigned int vector)
 628 {
 629     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 630     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 631     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 632     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 633     int ret;
 634
 635     ret = kvm_irqchip_remove_irqfd_notifier(kvm_state, n, irqfd->virq);
 636     assert(ret == 0);
 637 }
 638
 639 static int kvm_virtio_pci_vector_use(VirtIOPCIProxy *proxy, int nvqs)
 640 {
 641     PCIDevice *dev = &proxy->pci_dev;
 642     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 643     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 644     unsigned int vector;
 645     int ret, queue_no;
 646     MSIMessage msg;
 647
 648     for (queue_no = 0; queue_no < nvqs; queue_no++) {
 649         if (!virtio_queue_get_num(vdev, queue_no)) {
 650             break;
 651         }
 652         vector = virtio_queue_vector(vdev, queue_no);
 653         if (vector >= msix_nr_vectors_allocated(dev)) {
 654             continue;
 655         }
 656         msg = msix_get_message(dev, vector);
 657         ret = kvm_virtio_pci_vq_vector_use(proxy, queue_no, vector, msg);
 658         if (ret < 0) {
 659             goto undo;
 660         }
 661         /* If guest supports masking, set up irqfd now.
 662          * Otherwise, delay until unmasked in the frontend.
 663          */
 664         if (k->guest_notifier_mask) {
 665             ret = kvm_virtio_pci_irqfd_use(proxy, queue_no, vector);
 666             if (ret < 0) {
 667                 kvm_virtio_pci_vq_vector_release(proxy, vector);
 668                 goto undo;
 669             }
 670         }
 671     }
 672     return 0;
 673
 674 undo:
 675     while (--queue_no >= 0) {
 676         vector = virtio_queue_vector(vdev, queue_no);
 677         if (vector >= msix_nr_vectors_allocated(dev)) {
 678             continue;
 679         }
 680         if (k->guest_notifier_mask) {
 681             kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 682         }
 683         kvm_virtio_pci_vq_vector_release(proxy, vector);
 684     }
 685     return ret;
 686 }
 687
 688 static void kvm_virtio_pci_vector_release(VirtIOPCIProxy *proxy, int nvqs)
 689 {
 690     PCIDevice *dev = &proxy->pci_dev;
 691     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 692     unsigned int vector;
 693     int queue_no;
 694     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 695
 696     for (queue_no = 0; queue_no < nvqs; queue_no++) {
 697         if (!virtio_queue_get_num(vdev, queue_no)) {
 698             break;
 699         }
 700         vector = virtio_queue_vector(vdev, queue_no);
 701         if (vector >= msix_nr_vectors_allocated(dev)) {
 702             continue;
 703         }
 704         /* If guest supports masking, clean up irqfd now.
 705          * Otherwise, it was cleaned when masked in the frontend.
 706          */
 707         if (k->guest_notifier_mask) {
 708             kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 709         }
 710         kvm_virtio_pci_vq_vector_release(proxy, vector);
 711     }
 712 }
 713
 714 static int virtio_pci_vq_vector_unmask(VirtIOPCIProxy *proxy,
 715                                        unsigned int queue_no,
 716                                        unsigned int vector,
 717                                        MSIMessage msg)
 718 {
 719     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 720     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 721     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 722     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 723     VirtIOIRQFD *irqfd;
 724     int ret = 0;
 725
 726     if (proxy->vector_irqfd) {
 727         irqfd = &proxy->vector_irqfd[vector];
 728         if (irqfd->msg.data != msg.data || irqfd->msg.address != msg.address) {
 729             ret = kvm_irqchip_update_msi_route(kvm_state, irqfd->virq, msg);
 730             if (ret < 0) {
 731                 return ret;
 732             }
 733         }
 734     }
 735
 736     /* If guest supports masking, irqfd is already setup, unmask it.
 737      * Otherwise, set it up now.
 738      */
 739     if (k->guest_notifier_mask) {
 740         k->guest_notifier_mask(vdev, queue_no, false);
 741         /* Test after unmasking to avoid losing events. */
 742         if (k->guest_notifier_pending &&
 743             k->guest_notifier_pending(vdev, queue_no)) {
 744             event_notifier_set(n);
 745         }
 746     } else {
 747         ret = kvm_virtio_pci_irqfd_use(proxy, queue_no, vector);
 748     }
 749     return ret;
 750 }
 751
 752 static void virtio_pci_vq_vector_mask(VirtIOPCIProxy *proxy,
 753                                              unsigned int queue_no,
 754                                              unsigned int vector)
 755 {
 756     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 757     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 758
 759     /* If guest supports masking, keep irqfd but mask it.
 760      * Otherwise, clean it up now.
 761      */
 762     if (k->guest_notifier_mask) {
 763         k->guest_notifier_mask(vdev, queue_no, true);
 764     } else {
 765         kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 766     }
 767 }
 768
 769 static int virtio_pci_vector_unmask(PCIDevice *dev, unsigned vector,
 770                                     MSIMessage msg)
 771 {
 772     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 773     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 774     VirtQueue *vq = virtio_vector_first_queue(vdev, vector);
 775     int ret, index, unmasked = 0;
 776
 777     while (vq) {
 778         index = virtio_get_queue_index(vq);
 779         if (!virtio_queue_get_num(vdev, index)) {
 780             break;
 781         }
 782         if (index < proxy->nvqs_with_notifiers) {
 783             ret = virtio_pci_vq_vector_unmask(proxy, index, vector, msg);
 784             if (ret < 0) {
 785                 goto undo;
 786             }
 787             ++unmasked;
 788         }
 789         vq = virtio_vector_next_queue(vq);
 790     }
 791
 792     return 0;
 793
 794 undo:
 795     vq = virtio_vector_first_queue(vdev, vector);
 796     while (vq && unmasked >= 0) {
 797         index = virtio_get_queue_index(vq);
 798         if (index < proxy->nvqs_with_notifiers) {
 799             virtio_pci_vq_vector_mask(proxy, index, vector);
 800             --unmasked;
 801         }
 802         vq = virtio_vector_next_queue(vq);
 803     }
 804     return ret;
 805 }
 806
 807 static void virtio_pci_vector_mask(PCIDevice *dev, unsigned vector)
 808 {
 809     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 810     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 811     VirtQueue *vq = virtio_vector_first_queue(vdev, vector);
 812     int index;
 813
 814     while (vq) {
 815         index = virtio_get_queue_index(vq);
 816         if (!virtio_queue_get_num(vdev, index)) {
 817             break;
 818         }
 819         if (index < proxy->nvqs_with_notifiers) {
 820             virtio_pci_vq_vector_mask(proxy, index, vector);
 821         }
 822         vq = virtio_vector_next_queue(vq);
 823     }
 824 }
 825
 826 static void virtio_pci_vector_poll(PCIDevice *dev,
 827                                    unsigned int vector_start,
 828                                    unsigned int vector_end)
 829 {
 830     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 831     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 832     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 833     int queue_no;
 834     unsigned int vector;
 835     EventNotifier *notifier;
 836     VirtQueue *vq;
 837
 838     for (queue_no = 0; queue_no < proxy->nvqs_with_notifiers; queue_no++) {
 839         if (!virtio_queue_get_num(vdev, queue_no)) {
 840             break;
 841         }
 842         vector = virtio_queue_vector(vdev, queue_no);
 843         if (vector < vector_start || vector >= vector_end ||
 844             !msix_is_masked(dev, vector)) {
 845             continue;
 846         }
 847         vq = virtio_get_queue(vdev, queue_no);
 848         notifier = virtio_queue_get_guest_notifier(vq);
 849         if (k->guest_notifier_pending) {
 850             if (k->guest_notifier_pending(vdev, queue_no)) {
 851                 msix_set_pending(dev, vector);
 852             }
 853         } else if (event_notifier_test_and_clear(notifier)) {
 854             msix_set_pending(dev, vector);
 855         }
 856     }
 857 }
 858
 859 static int virtio_pci_set_guest_notifier(DeviceState *d, int n, bool assign,
 860                                          bool with_irqfd)
 861 {
 862     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 863     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 864     VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
 865     VirtQueue *vq = virtio_get_queue(vdev, n);
 866     EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
 867
 868     if (assign) {
 869         int r = event_notifier_init(notifier, 0);
 870         if (r < 0) {
 871             return r;
 872         }
 873         virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd);
 874     } else {
 875         virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd);
 876         event_notifier_cleanup(notifier);
 877     }
 878
 879     if (!msix_enabled(&proxy->pci_dev) && vdc->guest_notifier_mask) {
 880         vdc->guest_notifier_mask(vdev, n, !assign);
 881     }
 882
 883     return 0;
 884 }
 885
 886 static bool virtio_pci_query_guest_notifiers(DeviceState *d)
 887 {
 888     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 889     return msix_enabled(&proxy->pci_dev);
 890 }
 891
 892 static int virtio_pci_set_guest_notifiers(DeviceState *d, int nvqs, bool assign)
 893 {
 894     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 895     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 896     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 897     int r, n;
 898     bool with_irqfd = msix_enabled(&proxy->pci_dev) &&
 899         kvm_msi_via_irqfd_enabled();
 900
 901     nvqs = MIN(nvqs, VIRTIO_QUEUE_MAX);
 902
 903     /* When deassigning, pass a consistent nvqs value
 904      * to avoid leaking notifiers.
 905      */
 906     assert(assign || nvqs == proxy->nvqs_with_notifiers);
 907
 908     proxy->nvqs_with_notifiers = nvqs;
 909
 910     /* Must unset vector notifier while guest notifier is still assigned */
 911     if ((proxy->vector_irqfd || k->guest_notifier_mask) && !assign) {
 912         msix_unset_vector_notifiers(&proxy->pci_dev);
 913         if (proxy->vector_irqfd) {
 914             kvm_virtio_pci_vector_release(proxy, nvqs);
 915             g_free(proxy->vector_irqfd);
 916             proxy->vector_irqfd = NULL;
 917         }
 918     }
 919
 920     for (n = 0; n < nvqs; n++) {
 921         if (!virtio_queue_get_num(vdev, n)) {
 922             break;
 923         }
 924
 925         r = virtio_pci_set_guest_notifier(d, n, assign, with_irqfd);
 926         if (r < 0) {
 927             goto assign_error;
 928         }
 929     }
 930
 931     /* Must set vector notifier after guest notifier has been assigned */
 932     if ((with_irqfd || k->guest_notifier_mask) && assign) {
 933         if (with_irqfd) {
 934             proxy->vector_irqfd =
 935                 g_malloc0(sizeof(*proxy->vector_irqfd) *
 936                           msix_nr_vectors_allocated(&proxy->pci_dev));
 937             r = kvm_virtio_pci_vector_use(proxy, nvqs);
 938             if (r < 0) {
 939                 goto assign_error;
 940             }
 941         }
 942         r = msix_set_vector_notifiers(&proxy->pci_dev,
 943                                       virtio_pci_vector_unmask,
 944                                       virtio_pci_vector_mask,
 945                                       virtio_pci_vector_poll);
 946         if (r < 0) {
 947             goto notifiers_error;
 948         }
 949     }
 950
 951     return 0;
 952
 953 notifiers_error:
 954     if (with_irqfd) {
 955         assert(assign);
 956         kvm_virtio_pci_vector_release(proxy, nvqs);
 957     }
 958
 959 assign_error:
 960     /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
 961     assert(assign);
 962     while (--n >= 0) {
 963         virtio_pci_set_guest_notifier(d, n, !assign, with_irqfd);
 964     }
 965     return r;
 966 }
 967
 968 static int virtio_pci_set_host_notifier(DeviceState *d, int n, bool assign)
 969 {
 970     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 971
 972     /* Stop using ioeventfd for virtqueue kick if the device starts using host
 973      * notifiers.  This makes it easy to avoid stepping on each others' toes.
 974      */
 975     proxy->ioeventfd_disabled = assign;
 976     if (assign) {
 977         virtio_pci_stop_ioeventfd(proxy);
 978     }
 979     /* We don't need to start here: it's not needed because backend
 980      * currently only stops on status change away from ok,
 981      * reset, vmstop and such. If we do add code to start here,
 982      * need to check vmstate, device state etc. */
 983     return virtio_pci_set_host_notifier_internal(proxy, n, assign, false);
 984 }
 985
 986 static void virtio_pci_vmstate_change(DeviceState *d, bool running)
 987 {
 988     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 989     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 990
 991     if (running) {
 992         /* Old QEMU versions did not set bus master enable on status write.
 993          * Detect DRIVER set and enable it.
 994          */
 995         if ((proxy->flags & VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION) &&
 996             (vdev->status & VIRTIO_CONFIG_S_DRIVER) &&
 997             !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
 998             pci_default_write_config(&proxy->pci_dev, PCI_COMMAND,
 999                                      proxy->pci_dev.config[PCI_COMMAND] |
1000                                      PCI_COMMAND_MASTER, 1);
1001         }
1002         virtio_pci_start_ioeventfd(proxy);
1003     } else {
1004         virtio_pci_stop_ioeventfd(proxy);
1005     }
1006 }
1007
1008 #ifdef CONFIG_VIRTFS
1009 static void virtio_9p_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1010 {
1011     V9fsPCIState *dev = VIRTIO_9P_PCI(vpci_dev);
1012     DeviceState *vdev = DEVICE(&dev->vdev);
1013
1014     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1015     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1016 }
1017
1018 static Property virtio_9p_pci_properties[] = {
1019     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1020                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1021     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
1022     DEFINE_PROP_END_OF_LIST(),
1023 };
1024
1025 static void virtio_9p_pci_class_init(ObjectClass *klass, void *data)
1026 {
1027     DeviceClass *dc = DEVICE_CLASS(klass);
1028     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1029     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1030
1031     k->realize = virtio_9p_pci_realize;
1032     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1033     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_9P;
1034     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1035     pcidev_k->class_id = 0x2;
1036     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1037     dc->props = virtio_9p_pci_properties;
1038 }
1039
1040 static void virtio_9p_pci_instance_init(Object *obj)
1041 {
1042     V9fsPCIState *dev = VIRTIO_9P_PCI(obj);
1043
1044     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1045                                 TYPE_VIRTIO_9P);
1046 }
1047
1048 static const TypeInfo virtio_9p_pci_info = {
1049     .name          = TYPE_VIRTIO_9P_PCI,
1050     .parent        = TYPE_VIRTIO_PCI,
1051     .instance_size = sizeof(V9fsPCIState),
1052     .instance_init = virtio_9p_pci_instance_init,
1053     .class_init    = virtio_9p_pci_class_init,
1054 };
1055 #endif /* CONFIG_VIRTFS */
1056
1057 /*
1058  * virtio-pci: This is the PCIDevice which has a virtio-pci-bus.
1059  */
1060
1061 static int virtio_pci_query_nvectors(DeviceState *d)
1062 {
1063     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1064
1065     return proxy->nvectors;
1066 }
1067
1068 static int virtio_pci_add_mem_cap(VirtIOPCIProxy *proxy,
1069                                    struct virtio_pci_cap *cap)
1070 {
1071     PCIDevice *dev = &proxy->pci_dev;
1072     int offset;
1073
1074     offset = pci_add_capability(dev, PCI_CAP_ID_VNDR, 0, cap->cap_len);
1075     assert(offset > 0);
1076
1077     assert(cap->cap_len >= sizeof *cap);
1078     memcpy(dev->config + offset + PCI_CAP_FLAGS, &cap->cap_len,
1079            cap->cap_len - PCI_CAP_FLAGS);
1080
1081     return offset;
1082 }
1083
1084 static uint64_t virtio_pci_common_read(void *opaque, hwaddr addr,
1085                                        unsigned size)
1086 {
1087     VirtIOPCIProxy *proxy = opaque;
1088     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1089     uint32_t val = 0;
1090     int i;
1091
1092     switch (addr) {
1093     case VIRTIO_PCI_COMMON_DFSELECT:
1094         val = proxy->dfselect;
1095         break;
1096     case VIRTIO_PCI_COMMON_DF:
1097         if (proxy->dfselect <= 1) {
1098             val = vdev->host_features >> (32 * proxy->dfselect);
1099         }
1100         break;
1101     case VIRTIO_PCI_COMMON_GFSELECT:
1102         val = proxy->gfselect;
1103         break;
1104     case VIRTIO_PCI_COMMON_GF:
1105         if (proxy->gfselect < ARRAY_SIZE(proxy->guest_features)) {
1106             val = proxy->guest_features[proxy->gfselect];
1107         }
1108         break;
1109     case VIRTIO_PCI_COMMON_MSIX:
1110         val = vdev->config_vector;
1111         break;
1112     case VIRTIO_PCI_COMMON_NUMQ:
1113         for (i = 0; i < VIRTIO_QUEUE_MAX; ++i) {
1114             if (virtio_queue_get_num(vdev, i)) {
1115                 val = i + 1;
1116             }
1117         }
1118         break;
1119     case VIRTIO_PCI_COMMON_STATUS:
1120         val = vdev->status;
1121         break;
1122     case VIRTIO_PCI_COMMON_CFGGENERATION:
1123         val = vdev->generation;
1124         break;
1125     case VIRTIO_PCI_COMMON_Q_SELECT:
1126         val = vdev->queue_sel;
1127         break;
1128     case VIRTIO_PCI_COMMON_Q_SIZE:
1129         val = virtio_queue_get_num(vdev, vdev->queue_sel);
1130         break;
1131     case VIRTIO_PCI_COMMON_Q_MSIX:
1132         val = virtio_queue_vector(vdev, vdev->queue_sel);
1133         break;
1134     case VIRTIO_PCI_COMMON_Q_ENABLE:
1135         val = proxy->vqs[vdev->queue_sel].enabled;
1136         break;
1137     case VIRTIO_PCI_COMMON_Q_NOFF:
1138         /* Simply map queues in order */
1139         val = vdev->queue_sel;
1140         break;
1141     case VIRTIO_PCI_COMMON_Q_DESCLO:
1142         val = proxy->vqs[vdev->queue_sel].desc[0];
1143         break;
1144     case VIRTIO_PCI_COMMON_Q_DESCHI:
1145         val = proxy->vqs[vdev->queue_sel].desc[1];
1146         break;
1147     case VIRTIO_PCI_COMMON_Q_AVAILLO:
1148         val = proxy->vqs[vdev->queue_sel].avail[0];
1149         break;
1150     case VIRTIO_PCI_COMMON_Q_AVAILHI:
1151         val = proxy->vqs[vdev->queue_sel].avail[1];
1152         break;
1153     case VIRTIO_PCI_COMMON_Q_USEDLO:
1154         val = proxy->vqs[vdev->queue_sel].used[0];
1155         break;
1156     case VIRTIO_PCI_COMMON_Q_USEDHI:
1157         val = proxy->vqs[vdev->queue_sel].used[1];
1158         break;
1159     default:
1160         val = 0;
1161     }
1162
1163     return val;
1164 }
1165
1166 static void virtio_pci_common_write(void *opaque, hwaddr addr,
1167                                     uint64_t val, unsigned size)
1168 {
1169     VirtIOPCIProxy *proxy = opaque;
1170     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1171
1172     switch (addr) {
1173     case VIRTIO_PCI_COMMON_DFSELECT:
1174         proxy->dfselect = val;
1175         break;
1176     case VIRTIO_PCI_COMMON_GFSELECT:
1177         proxy->gfselect = val;
1178         break;
1179     case VIRTIO_PCI_COMMON_GF:
1180         if (proxy->gfselect < ARRAY_SIZE(proxy->guest_features)) {
1181             proxy->guest_features[proxy->gfselect] = val;
1182             virtio_set_features(vdev,
1183                                 (((uint64_t)proxy->guest_features[1]) << 32) |
1184                                 proxy->guest_features[0]);
1185         }
1186         break;
1187     case VIRTIO_PCI_COMMON_MSIX:
1188         msix_vector_unuse(&proxy->pci_dev, vdev->config_vector);
1189         /* Make it possible for guest to discover an error took place. */
1190         if (msix_vector_use(&proxy->pci_dev, val) < 0) {
1191             val = VIRTIO_NO_VECTOR;
1192         }
1193         vdev->config_vector = val;
1194         break;
1195     case VIRTIO_PCI_COMMON_STATUS:
1196         if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) {
1197             virtio_pci_stop_ioeventfd(proxy);
1198         }
1199
1200         virtio_set_status(vdev, val & 0xFF);
1201
1202         if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
1203             virtio_pci_start_ioeventfd(proxy);
1204         }
1205
1206         if (vdev->status == 0) {
1207             virtio_reset(vdev);
1208             msix_unuse_all_vectors(&proxy->pci_dev);
1209         }
1210
1211         break;
1212     case VIRTIO_PCI_COMMON_Q_SELECT:
1213         if (val < VIRTIO_QUEUE_MAX) {
1214             vdev->queue_sel = val;
1215         }
1216         break;
1217     case VIRTIO_PCI_COMMON_Q_SIZE:
1218         proxy->vqs[vdev->queue_sel].num = val;
1219         break;
1220     case VIRTIO_PCI_COMMON_Q_MSIX:
1221         msix_vector_unuse(&proxy->pci_dev,
1222                           virtio_queue_vector(vdev, vdev->queue_sel));
1223         /* Make it possible for guest to discover an error took place. */
1224         if (msix_vector_use(&proxy->pci_dev, val) < 0) {
1225             val = VIRTIO_NO_VECTOR;
1226         }
1227         virtio_queue_set_vector(vdev, vdev->queue_sel, val);
1228         break;
1229     case VIRTIO_PCI_COMMON_Q_ENABLE:
1230         /* TODO: need a way to put num back on reset. */
1231         virtio_queue_set_num(vdev, vdev->queue_sel,
1232                              proxy->vqs[vdev->queue_sel].num);
1233         virtio_queue_set_rings(vdev, vdev->queue_sel,
1234                        ((uint64_t)proxy->vqs[vdev->queue_sel].desc[1]) << 32 |
1235                        proxy->vqs[vdev->queue_sel].desc[0],
1236                        ((uint64_t)proxy->vqs[vdev->queue_sel].avail[1]) << 32 |
1237                        proxy->vqs[vdev->queue_sel].avail[0],
1238                        ((uint64_t)proxy->vqs[vdev->queue_sel].used[1]) << 32 |
1239                        proxy->vqs[vdev->queue_sel].used[0]);
1240         break;
1241     case VIRTIO_PCI_COMMON_Q_DESCLO:
1242         proxy->vqs[vdev->queue_sel].desc[0] = val;
1243         break;
1244     case VIRTIO_PCI_COMMON_Q_DESCHI:
1245         proxy->vqs[vdev->queue_sel].desc[1] = val;
1246         break;
1247     case VIRTIO_PCI_COMMON_Q_AVAILLO:
1248         proxy->vqs[vdev->queue_sel].avail[0] = val;
1249         break;
1250     case VIRTIO_PCI_COMMON_Q_AVAILHI:
1251         proxy->vqs[vdev->queue_sel].avail[1] = val;
1252         break;
1253     case VIRTIO_PCI_COMMON_Q_USEDLO:
1254         proxy->vqs[vdev->queue_sel].used[0] = val;
1255         break;
1256     case VIRTIO_PCI_COMMON_Q_USEDHI:
1257         proxy->vqs[vdev->queue_sel].used[1] = val;
1258         break;
1259     default:
1260         break;
1261     }
1262 }
1263
1264
1265 static uint64_t virtio_pci_notify_read(void *opaque, hwaddr addr,
1266                                        unsigned size)
1267 {
1268     return 0;
1269 }
1270
1271 static void virtio_pci_notify_write(void *opaque, hwaddr addr,
1272                                     uint64_t val, unsigned size)
1273 {
1274     VirtIODevice *vdev = opaque;
1275     unsigned queue = addr / QEMU_VIRTIO_PCI_QUEUE_MEM_MULT;
1276
1277     if (queue < VIRTIO_QUEUE_MAX) {
1278         virtio_queue_notify(vdev, queue);
1279     }
1280 }
1281
1282 static uint64_t virtio_pci_isr_read(void *opaque, hwaddr addr,
1283                                     unsigned size)
1284 {
1285     VirtIOPCIProxy *proxy = opaque;
1286     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1287     uint64_t val = vdev->isr;
1288
1289     vdev->isr = 0;
1290     pci_irq_deassert(&proxy->pci_dev);
1291
1292     return val;
1293 }
1294
1295 static void virtio_pci_isr_write(void *opaque, hwaddr addr,
1296                                  uint64_t val, unsigned size)
1297 {
1298 }
1299
1300 static uint64_t virtio_pci_device_read(void *opaque, hwaddr addr,
1301                                        unsigned size)
1302 {
1303     VirtIODevice *vdev = opaque;
1304     uint64_t val = 0;
1305
1306     switch (size) {
1307     case 1:
1308         val = virtio_config_modern_readb(vdev, addr);
1309         break;
1310     case 2:
1311         val = virtio_config_modern_readw(vdev, addr);
1312         break;
1313     case 4:
1314         val = virtio_config_modern_readl(vdev, addr);
1315         break;
1316     }
1317     return val;
1318 }
1319
1320 static void virtio_pci_device_write(void *opaque, hwaddr addr,
1321                                     uint64_t val, unsigned size)
1322 {
1323     VirtIODevice *vdev = opaque;
1324     switch (size) {
1325     case 1:
1326         virtio_config_modern_writeb(vdev, addr, val);
1327         break;
1328     case 2:
1329         virtio_config_modern_writew(vdev, addr, val);
1330         break;
1331     case 4:
1332         virtio_config_modern_writel(vdev, addr, val);
1333         break;
1334     }
1335 }
1336
1337 static void virtio_pci_modern_regions_init(VirtIOPCIProxy *proxy)
1338 {
1339     static const MemoryRegionOps common_ops = {
1340         .read = virtio_pci_common_read,
1341         .write = virtio_pci_common_write,
1342         .impl = {
1343             .min_access_size = 1,
1344             .max_access_size = 4,
1345         },
1346         .endianness = DEVICE_LITTLE_ENDIAN,
1347     };
1348     static const MemoryRegionOps isr_ops = {
1349         .read = virtio_pci_isr_read,
1350         .write = virtio_pci_isr_write,
1351         .impl = {
1352             .min_access_size = 1,
1353             .max_access_size = 4,
1354         },
1355         .endianness = DEVICE_LITTLE_ENDIAN,
1356     };
1357     static const MemoryRegionOps device_ops = {
1358         .read = virtio_pci_device_read,
1359         .write = virtio_pci_device_write,
1360         .impl = {
1361             .min_access_size = 1,
1362             .max_access_size = 4,
1363         },
1364         .endianness = DEVICE_LITTLE_ENDIAN,
1365     };
1366     static const MemoryRegionOps notify_ops = {
1367         .read = virtio_pci_notify_read,
1368         .write = virtio_pci_notify_write,
1369         .impl = {
1370             .min_access_size = 1,
1371             .max_access_size = 4,
1372         },
1373         .endianness = DEVICE_LITTLE_ENDIAN,
1374     };
1375
1376     memory_region_init_io(&proxy->common.mr, OBJECT(proxy),
1377                           &common_ops,
1378                           proxy,
1379                           "virtio-pci-common",
1380                           proxy->common.size);
1381
1382     memory_region_init_io(&proxy->isr.mr, OBJECT(proxy),
1383                           &isr_ops,
1384                           proxy,
1385                           "virtio-pci-isr",
1386                           proxy->isr.size);
1387
1388     memory_region_init_io(&proxy->device.mr, OBJECT(proxy),
1389                           &device_ops,
1390                           virtio_bus_get_device(&proxy->bus),
1391                           "virtio-pci-device",
1392                           proxy->device.size);
1393
1394     memory_region_init_io(&proxy->notify.mr, OBJECT(proxy),
1395                           &notify_ops,
1396                           virtio_bus_get_device(&proxy->bus),
1397                           "virtio-pci-notify",
1398                           proxy->notify.size);
1399 }
1400
1401 static void virtio_pci_modern_region_map(VirtIOPCIProxy *proxy,
1402                                          VirtIOPCIRegion *region,
1403                                          struct virtio_pci_cap *cap)
1404 {
1405     memory_region_add_subregion(&proxy->modern_bar,
1406                                 region->offset,
1407                                 &region->mr);
1408
1409     cap->cfg_type = region->type;
1410     cap->bar = proxy->modern_mem_bar;
1411     cap->offset = cpu_to_le32(region->offset);
1412     cap->length = cpu_to_le32(region->size);
1413     virtio_pci_add_mem_cap(proxy, cap);
1414 }
1415
1416 /* This is called by virtio-bus just after the device is plugged. */
1417 static void virtio_pci_device_plugged(DeviceState *d, Error **errp)
1418 {
1419     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1420     VirtioBusState *bus = &proxy->bus;
1421     bool legacy = !(proxy->flags & VIRTIO_PCI_FLAG_DISABLE_LEGACY);
1422     bool modern = !(proxy->flags & VIRTIO_PCI_FLAG_DISABLE_MODERN);
1423     uint8_t *config;
1424     uint32_t size;
1425     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1426
1427     config = proxy->pci_dev.config;
1428     if (proxy->class_code) {
1429         pci_config_set_class(config, proxy->class_code);
1430     }
1431
1432     if (legacy) {
1433         /* legacy and transitional */
1434         pci_set_word(config + PCI_SUBSYSTEM_VENDOR_ID,
1435                      pci_get_word(config + PCI_VENDOR_ID));
1436         pci_set_word(config + PCI_SUBSYSTEM_ID, virtio_bus_get_vdev_id(bus));
1437     } else {
1438         /* pure virtio-1.0 */
1439         pci_set_word(config + PCI_VENDOR_ID,
1440                      PCI_VENDOR_ID_REDHAT_QUMRANET);
1441         pci_set_word(config + PCI_DEVICE_ID,
1442                      0x1040 + virtio_bus_get_vdev_id(bus));
1443         pci_config_set_revision(config, 1);
1444     }
1445     config[PCI_INTERRUPT_PIN] = 1;
1446
1447
1448     if (modern) {
1449         struct virtio_pci_cap cap = {
1450             .cap_len = sizeof cap,
1451         };
1452         struct virtio_pci_notify_cap notify = {
1453             .cap.cap_len = sizeof notify,
1454             .notify_off_multiplier =
1455                 cpu_to_le32(QEMU_VIRTIO_PCI_QUEUE_MEM_MULT),
1456         };
1457         struct virtio_pci_cfg_cap cfg = {
1458             .cap.cap_len = sizeof cfg,
1459             .cap.cfg_type = VIRTIO_PCI_CAP_PCI_CFG,
1460         };
1461         struct virtio_pci_cfg_cap *cfg_mask;
1462
1463         /* TODO: add io access for speed */
1464
1465         virtio_add_feature(&vdev->host_features, VIRTIO_F_VERSION_1);
1466         virtio_pci_modern_regions_init(proxy);
1467         virtio_pci_modern_region_map(proxy, &proxy->common, &cap);
1468         virtio_pci_modern_region_map(proxy, &proxy->isr, &cap);
1469         virtio_pci_modern_region_map(proxy, &proxy->device, &cap);
1470         virtio_pci_modern_region_map(proxy, &proxy->notify, &notify.cap);
1471
1472         pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar,
1473                          PCI_BASE_ADDRESS_SPACE_MEMORY |
1474                          PCI_BASE_ADDRESS_MEM_PREFETCH |
1475                          PCI_BASE_ADDRESS_MEM_TYPE_64,
1476                          &proxy->modern_bar);
1477
1478         proxy->config_cap = virtio_pci_add_mem_cap(proxy, &cfg.cap);
1479         cfg_mask = (void *)(proxy->pci_dev.wmask + proxy->config_cap);
1480         pci_set_byte(&cfg_mask->cap.bar, ~0x0);
1481         pci_set_long((uint8_t *)&cfg_mask->cap.offset, ~0x0);
1482         pci_set_long((uint8_t *)&cfg_mask->cap.length, ~0x0);
1483         pci_set_long(cfg_mask->pci_cfg_data, ~0x0);
1484     }
1485
1486     if (proxy->nvectors &&
1487         msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors,
1488                                 proxy->msix_bar)) {
1489         error_report("unable to init msix vectors to %" PRIu32,
1490                      proxy->nvectors);
1491         proxy->nvectors = 0;
1492     }
1493
1494     proxy->pci_dev.config_write = virtio_write_config;
1495     proxy->pci_dev.config_read = virtio_read_config;
1496
1497     if (legacy) {
1498         size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev)
1499             + virtio_bus_get_vdev_config_len(bus);
1500         if (size & (size - 1)) {
1501             size = 1 << qemu_fls(size);
1502         }
1503
1504         memory_region_init_io(&proxy->bar, OBJECT(proxy),
1505                               &virtio_pci_config_ops,
1506                               proxy, "virtio-pci", size);
1507
1508         pci_register_bar(&proxy->pci_dev, proxy->legacy_io_bar,
1509                          PCI_BASE_ADDRESS_SPACE_IO, &proxy->bar);
1510     }
1511
1512     if (!kvm_has_many_ioeventfds()) {
1513         proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
1514     }
1515
1516     virtio_add_feature(&vdev->host_features, VIRTIO_F_BAD_FEATURE);
1517 }
1518
1519 static void virtio_pci_device_unplugged(DeviceState *d)
1520 {
1521     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1522
1523     virtio_pci_stop_ioeventfd(proxy);
1524 }
1525
1526 static void virtio_pci_realize(PCIDevice *pci_dev, Error **errp)
1527 {
1528     VirtIOPCIProxy *proxy = VIRTIO_PCI(pci_dev);
1529     VirtioPCIClass *k = VIRTIO_PCI_GET_CLASS(pci_dev);
1530
1531     /*
1532      * virtio pci bar layout used by default.
1533      * subclasses can re-arrange things if needed.
1534      *
1535      *   region 0   --  virtio legacy io bar
1536      *   region 1   --  msi-x bar
1537      *   region 4+5 --  virtio modern memory (64bit) bar
1538      *
1539      */
1540     proxy->legacy_io_bar  = 0;
1541     proxy->msix_bar       = 1;
1542     proxy->modern_mem_bar = 4;
1543
1544     proxy->common.offset = 0x0;
1545     proxy->common.size = 0x1000;
1546     proxy->common.type = VIRTIO_PCI_CAP_COMMON_CFG;
1547
1548     proxy->isr.offset = 0x1000;
1549     proxy->isr.size = 0x1000;
1550     proxy->isr.type = VIRTIO_PCI_CAP_ISR_CFG;
1551
1552     proxy->device.offset = 0x2000;
1553     proxy->device.size = 0x1000;
1554     proxy->device.type = VIRTIO_PCI_CAP_DEVICE_CFG;
1555
1556     proxy->notify.offset = 0x3000;
1557     proxy->notify.size =
1558         QEMU_VIRTIO_PCI_QUEUE_MEM_MULT * VIRTIO_QUEUE_MAX;
1559     proxy->notify.type = VIRTIO_PCI_CAP_NOTIFY_CFG;
1560
1561     /* subclasses can enforce modern, so do this unconditionally */
1562     memory_region_init(&proxy->modern_bar, OBJECT(proxy), "virtio-pci",
1563                        2 * QEMU_VIRTIO_PCI_QUEUE_MEM_MULT *
1564                        VIRTIO_QUEUE_MAX);
1565
1566     memory_region_init_alias(&proxy->modern_cfg,
1567                              OBJECT(proxy),
1568                              "virtio-pci-cfg",
1569                              &proxy->modern_bar,
1570                              0,
1571                              memory_region_size(&proxy->modern_bar));
1572
1573     address_space_init(&proxy->modern_as, &proxy->modern_cfg, "virtio-pci-cfg-as");
1574
1575     virtio_pci_bus_new(&proxy->bus, sizeof(proxy->bus), proxy);
1576     if (k->realize) {
1577         k->realize(proxy, errp);
1578     }
1579 }
1580
1581 static void virtio_pci_exit(PCIDevice *pci_dev)
1582 {
1583     VirtIOPCIProxy *proxy = VIRTIO_PCI(pci_dev);
1584
1585     msix_uninit_exclusive_bar(pci_dev);
1586     address_space_destroy(&proxy->modern_as);
1587 }
1588
1589 static void virtio_pci_reset(DeviceState *qdev)
1590 {
1591     VirtIOPCIProxy *proxy = VIRTIO_PCI(qdev);
1592     VirtioBusState *bus = VIRTIO_BUS(&proxy->bus);
1593     virtio_pci_stop_ioeventfd(proxy);
1594     virtio_bus_reset(bus);
1595     msix_unuse_all_vectors(&proxy->pci_dev);
1596 }
1597
1598 static Property virtio_pci_properties[] = {
1599     DEFINE_PROP_BIT("virtio-pci-bus-master-bug-migration", VirtIOPCIProxy, flags,
1600                     VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT, false),
1601     DEFINE_PROP_BIT("disable-legacy", VirtIOPCIProxy, flags,
1602                     VIRTIO_PCI_FLAG_DISABLE_LEGACY_BIT, false),
1603     DEFINE_PROP_BIT("disable-modern", VirtIOPCIProxy, flags,
1604                     VIRTIO_PCI_FLAG_DISABLE_MODERN_BIT, true),
1605     DEFINE_PROP_END_OF_LIST(),
1606 };
1607
1608 static void virtio_pci_class_init(ObjectClass *klass, void *data)
1609 {
1610     DeviceClass *dc = DEVICE_CLASS(klass);
1611     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1612
1613     dc->props = virtio_pci_properties;
1614     k->realize = virtio_pci_realize;
1615     k->exit = virtio_pci_exit;
1616     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1617     k->revision = VIRTIO_PCI_ABI_VERSION;
1618     k->class_id = PCI_CLASS_OTHERS;
1619     dc->reset = virtio_pci_reset;
1620 }
1621
1622 static const TypeInfo virtio_pci_info = {
1623     .name          = TYPE_VIRTIO_PCI,
1624     .parent        = TYPE_PCI_DEVICE,
1625     .instance_size = sizeof(VirtIOPCIProxy),
1626     .class_init    = virtio_pci_class_init,
1627     .class_size    = sizeof(VirtioPCIClass),
1628     .abstract      = true,
1629 };
1630
1631 /* virtio-blk-pci */
1632
1633 static Property virtio_blk_pci_properties[] = {
1634     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
1635     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1636                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1637     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
1638     DEFINE_PROP_END_OF_LIST(),
1639 };
1640
1641 static void virtio_blk_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1642 {
1643     VirtIOBlkPCI *dev = VIRTIO_BLK_PCI(vpci_dev);
1644     DeviceState *vdev = DEVICE(&dev->vdev);
1645
1646     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1647     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1648 }
1649
1650 static void virtio_blk_pci_class_init(ObjectClass *klass, void *data)
1651 {
1652     DeviceClass *dc = DEVICE_CLASS(klass);
1653     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1654     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1655
1656     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1657     dc->props = virtio_blk_pci_properties;
1658     k->realize = virtio_blk_pci_realize;
1659     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1660     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BLOCK;
1661     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1662     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
1663 }
1664
1665 static void virtio_blk_pci_instance_init(Object *obj)
1666 {
1667     VirtIOBlkPCI *dev = VIRTIO_BLK_PCI(obj);
1668
1669     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1670                                 TYPE_VIRTIO_BLK);
1671     object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev),"iothread",
1672                               &error_abort);
1673     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
1674                               "bootindex", &error_abort);
1675 }
1676
1677 static const TypeInfo virtio_blk_pci_info = {
1678     .name          = TYPE_VIRTIO_BLK_PCI,
1679     .parent        = TYPE_VIRTIO_PCI,
1680     .instance_size = sizeof(VirtIOBlkPCI),
1681     .instance_init = virtio_blk_pci_instance_init,
1682     .class_init    = virtio_blk_pci_class_init,
1683 };
1684
1685 /* virtio-scsi-pci */
1686
1687 static Property virtio_scsi_pci_properties[] = {
1688     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1689                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1690     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
1691                        DEV_NVECTORS_UNSPECIFIED),
1692     DEFINE_PROP_END_OF_LIST(),
1693 };
1694
1695 static void virtio_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1696 {
1697     VirtIOSCSIPCI *dev = VIRTIO_SCSI_PCI(vpci_dev);
1698     DeviceState *vdev = DEVICE(&dev->vdev);
1699     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
1700     DeviceState *proxy = DEVICE(vpci_dev);
1701     char *bus_name;
1702
1703     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
1704         vpci_dev->nvectors = vs->conf.num_queues + 3;
1705     }
1706
1707     /*
1708      * For command line compatibility, this sets the virtio-scsi-device bus
1709      * name as before.
1710      */
1711     if (proxy->id) {
1712         bus_name = g_strdup_printf("%s.0", proxy->id);
1713         virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);
1714         g_free(bus_name);
1715     }
1716
1717     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1718     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1719 }
1720
1721 static void virtio_scsi_pci_class_init(ObjectClass *klass, void *data)
1722 {
1723     DeviceClass *dc = DEVICE_CLASS(klass);
1724     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1725     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1726
1727     k->realize = virtio_scsi_pci_realize;
1728     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1729     dc->props = virtio_scsi_pci_properties;
1730     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1731     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
1732     pcidev_k->revision = 0x00;
1733     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
1734 }
1735
1736 static void virtio_scsi_pci_instance_init(Object *obj)
1737 {
1738     VirtIOSCSIPCI *dev = VIRTIO_SCSI_PCI(obj);
1739
1740     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1741                                 TYPE_VIRTIO_SCSI);
1742     object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev), "iothread",
1743                               &error_abort);
1744 }
1745
1746 static const TypeInfo virtio_scsi_pci_info = {
1747     .name          = TYPE_VIRTIO_SCSI_PCI,
1748     .parent        = TYPE_VIRTIO_PCI,
1749     .instance_size = sizeof(VirtIOSCSIPCI),
1750     .instance_init = virtio_scsi_pci_instance_init,
1751     .class_init    = virtio_scsi_pci_class_init,
1752 };
1753
1754 /* vhost-scsi-pci */
1755
1756 #ifdef CONFIG_VHOST_SCSI
1757 static Property vhost_scsi_pci_properties[] = {
1758     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
1759                        DEV_NVECTORS_UNSPECIFIED),
1760     DEFINE_PROP_END_OF_LIST(),
1761 };
1762
1763 static void vhost_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1764 {
1765     VHostSCSIPCI *dev = VHOST_SCSI_PCI(vpci_dev);
1766     DeviceState *vdev = DEVICE(&dev->vdev);
1767     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
1768
1769     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
1770         vpci_dev->nvectors = vs->conf.num_queues + 3;
1771     }
1772
1773     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1774     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1775 }
1776
1777 static void vhost_scsi_pci_class_init(ObjectClass *klass, void *data)
1778 {
1779     DeviceClass *dc = DEVICE_CLASS(klass);
1780     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1781     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1782     k->realize = vhost_scsi_pci_realize;
1783     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1784     dc->props = vhost_scsi_pci_properties;
1785     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1786     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
1787     pcidev_k->revision = 0x00;
1788     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
1789 }
1790
1791 static void vhost_scsi_pci_instance_init(Object *obj)
1792 {
1793     VHostSCSIPCI *dev = VHOST_SCSI_PCI(obj);
1794
1795     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1796                                 TYPE_VHOST_SCSI);
1797     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
1798                               "bootindex", &error_abort);
1799 }
1800
1801 static const TypeInfo vhost_scsi_pci_info = {
1802     .name          = TYPE_VHOST_SCSI_PCI,
1803     .parent        = TYPE_VIRTIO_PCI,
1804     .instance_size = sizeof(VHostSCSIPCI),
1805     .instance_init = vhost_scsi_pci_instance_init,
1806     .class_init    = vhost_scsi_pci_class_init,
1807 };
1808 #endif
1809
1810 /* virtio-balloon-pci */
1811
1812 static Property virtio_balloon_pci_properties[] = {
1813     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
1814     DEFINE_PROP_END_OF_LIST(),
1815 };
1816
1817 static void virtio_balloon_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1818 {
1819     VirtIOBalloonPCI *dev = VIRTIO_BALLOON_PCI(vpci_dev);
1820     DeviceState *vdev = DEVICE(&dev->vdev);
1821
1822     if (vpci_dev->class_code != PCI_CLASS_OTHERS &&
1823         vpci_dev->class_code != PCI_CLASS_MEMORY_RAM) { /* qemu < 1.1 */
1824         vpci_dev->class_code = PCI_CLASS_OTHERS;
1825     }
1826
1827     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1828     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1829 }
1830
1831 static void virtio_balloon_pci_class_init(ObjectClass *klass, void *data)
1832 {
1833     DeviceClass *dc = DEVICE_CLASS(klass);
1834     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1835     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1836     k->realize = virtio_balloon_pci_realize;
1837     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
1838     dc->props = virtio_balloon_pci_properties;
1839     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1840     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BALLOON;
1841     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1842     pcidev_k->class_id = PCI_CLASS_OTHERS;
1843 }
1844
1845 static void virtio_balloon_pci_instance_init(Object *obj)
1846 {
1847     VirtIOBalloonPCI *dev = VIRTIO_BALLOON_PCI(obj);
1848
1849     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1850                                 TYPE_VIRTIO_BALLOON);
1851     object_property_add_alias(obj, "guest-stats", OBJECT(&dev->vdev),
1852                                   "guest-stats", &error_abort);
1853     object_property_add_alias(obj, "guest-stats-polling-interval",
1854                               OBJECT(&dev->vdev),
1855                               "guest-stats-polling-interval", &error_abort);
1856 }
1857
1858 static const TypeInfo virtio_balloon_pci_info = {
1859     .name          = TYPE_VIRTIO_BALLOON_PCI,
1860     .parent        = TYPE_VIRTIO_PCI,
1861     .instance_size = sizeof(VirtIOBalloonPCI),
1862     .instance_init = virtio_balloon_pci_instance_init,
1863     .class_init    = virtio_balloon_pci_class_init,
1864 };
1865
1866 /* virtio-serial-pci */
1867
1868 static void virtio_serial_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1869 {
1870     VirtIOSerialPCI *dev = VIRTIO_SERIAL_PCI(vpci_dev);
1871     DeviceState *vdev = DEVICE(&dev->vdev);
1872     DeviceState *proxy = DEVICE(vpci_dev);
1873     char *bus_name;
1874
1875     if (vpci_dev->class_code != PCI_CLASS_COMMUNICATION_OTHER &&
1876         vpci_dev->class_code != PCI_CLASS_DISPLAY_OTHER && /* qemu 0.10 */
1877         vpci_dev->class_code != PCI_CLASS_OTHERS) {        /* qemu-kvm  */
1878             vpci_dev->class_code = PCI_CLASS_COMMUNICATION_OTHER;
1879     }
1880
1881     /* backwards-compatibility with machines that were created with
1882        DEV_NVECTORS_UNSPECIFIED */
1883     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
1884         vpci_dev->nvectors = dev->vdev.serial.max_virtserial_ports + 1;
1885     }
1886
1887     /*
1888      * For command line compatibility, this sets the virtio-serial-device bus
1889      * name as before.
1890      */
1891     if (proxy->id) {
1892         bus_name = g_strdup_printf("%s.0", proxy->id);
1893         virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);
1894         g_free(bus_name);
1895     }
1896
1897     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1898     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1899 }
1900
1901 static Property virtio_serial_pci_properties[] = {
1902     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1903                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1904     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
1905     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
1906     DEFINE_PROP_END_OF_LIST(),
1907 };
1908
1909 static void virtio_serial_pci_class_init(ObjectClass *klass, void *data)
1910 {
1911     DeviceClass *dc = DEVICE_CLASS(klass);
1912     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1913     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1914     k->realize = virtio_serial_pci_realize;
1915     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
1916     dc->props = virtio_serial_pci_properties;
1917     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1918     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
1919     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1920     pcidev_k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
1921 }
1922
1923 static void virtio_serial_pci_instance_init(Object *obj)
1924 {
1925     VirtIOSerialPCI *dev = VIRTIO_SERIAL_PCI(obj);
1926
1927     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1928                                 TYPE_VIRTIO_SERIAL);
1929 }
1930
1931 static const TypeInfo virtio_serial_pci_info = {
1932     .name          = TYPE_VIRTIO_SERIAL_PCI,
1933     .parent        = TYPE_VIRTIO_PCI,
1934     .instance_size = sizeof(VirtIOSerialPCI),
1935     .instance_init = virtio_serial_pci_instance_init,
1936     .class_init    = virtio_serial_pci_class_init,
1937 };
1938
1939 /* virtio-net-pci */
1940
1941 static Property virtio_net_properties[] = {
1942     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1943                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
1944     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
1945     DEFINE_PROP_END_OF_LIST(),
1946 };
1947
1948 static void virtio_net_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1949 {
1950     DeviceState *qdev = DEVICE(vpci_dev);
1951     VirtIONetPCI *dev = VIRTIO_NET_PCI(vpci_dev);
1952     DeviceState *vdev = DEVICE(&dev->vdev);
1953
1954     virtio_net_set_netclient_name(&dev->vdev, qdev->id,
1955                                   object_get_typename(OBJECT(qdev)));
1956     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1957     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1958 }
1959
1960 static void virtio_net_pci_class_init(ObjectClass *klass, void *data)
1961 {
1962     DeviceClass *dc = DEVICE_CLASS(klass);
1963     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1964     VirtioPCIClass *vpciklass = VIRTIO_PCI_CLASS(klass);
1965
1966     k->romfile = "efi-virtio.rom";
1967     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1968     k->device_id = PCI_DEVICE_ID_VIRTIO_NET;
1969     k->revision = VIRTIO_PCI_ABI_VERSION;
1970     k->class_id = PCI_CLASS_NETWORK_ETHERNET;
1971     set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
1972     dc->props = virtio_net_properties;
1973     vpciklass->realize = virtio_net_pci_realize;
1974 }
1975
1976 static void virtio_net_pci_instance_init(Object *obj)
1977 {
1978     VirtIONetPCI *dev = VIRTIO_NET_PCI(obj);
1979
1980     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1981                                 TYPE_VIRTIO_NET);
1982     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
1983                               "bootindex", &error_abort);
1984 }
1985
1986 static const TypeInfo virtio_net_pci_info = {
1987     .name          = TYPE_VIRTIO_NET_PCI,
1988     .parent        = TYPE_VIRTIO_PCI,
1989     .instance_size = sizeof(VirtIONetPCI),
1990     .instance_init = virtio_net_pci_instance_init,
1991     .class_init    = virtio_net_pci_class_init,
1992 };
1993
1994 /* virtio-rng-pci */
1995
1996 static Property virtio_rng_pci_properties[] = {
1997     DEFINE_PROP_END_OF_LIST(),
1998 };
1999
2000 static void virtio_rng_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2001 {
2002     VirtIORngPCI *vrng = VIRTIO_RNG_PCI(vpci_dev);
2003     DeviceState *vdev = DEVICE(&vrng->vdev);
2004     Error *err = NULL;
2005
2006     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2007     object_property_set_bool(OBJECT(vdev), true, "realized", &err);
2008     if (err) {
2009         error_propagate(errp, err);
2010         return;
2011     }
2012
2013     object_property_set_link(OBJECT(vrng),
2014                              OBJECT(vrng->vdev.conf.rng), "rng",
2015                              NULL);
2016 }
2017
2018 static void virtio_rng_pci_class_init(ObjectClass *klass, void *data)
2019 {
2020     DeviceClass *dc = DEVICE_CLASS(klass);
2021     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2022     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2023
2024     k->realize = virtio_rng_pci_realize;
2025     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
2026     dc->props = virtio_rng_pci_properties;
2027
2028     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
2029     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_RNG;
2030     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
2031     pcidev_k->class_id = PCI_CLASS_OTHERS;
2032 }
2033
2034 static void virtio_rng_initfn(Object *obj)
2035 {
2036     VirtIORngPCI *dev = VIRTIO_RNG_PCI(obj);
2037
2038     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2039                                 TYPE_VIRTIO_RNG);
2040     object_property_add_alias(obj, "rng", OBJECT(&dev->vdev), "rng",
2041                               &error_abort);
2042 }
2043
2044 static const TypeInfo virtio_rng_pci_info = {
2045     .name          = TYPE_VIRTIO_RNG_PCI,
2046     .parent        = TYPE_VIRTIO_PCI,
2047     .instance_size = sizeof(VirtIORngPCI),
2048     .instance_init = virtio_rng_initfn,
2049     .class_init    = virtio_rng_pci_class_init,
2050 };
2051
2052 /* virtio-input-pci */
2053
2054 static Property virtio_input_pci_properties[] = {
2055     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
2056     DEFINE_PROP_END_OF_LIST(),
2057 };
2058
2059 static void virtio_input_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
2060 {
2061     VirtIOInputPCI *vinput = VIRTIO_INPUT_PCI(vpci_dev);
2062     DeviceState *vdev = DEVICE(&vinput->vdev);
2063
2064     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
2065     /* force virtio-1.0 */
2066     vpci_dev->flags &= ~VIRTIO_PCI_FLAG_DISABLE_MODERN;
2067     vpci_dev->flags |= VIRTIO_PCI_FLAG_DISABLE_LEGACY;
2068     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
2069 }
2070
2071 static void virtio_input_pci_class_init(ObjectClass *klass, void *data)
2072 {
2073     DeviceClass *dc = DEVICE_CLASS(klass);
2074     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
2075     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2076
2077     dc->props = virtio_input_pci_properties;
2078     k->realize = virtio_input_pci_realize;
2079     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
2080
2081     pcidev_k->class_id = PCI_CLASS_INPUT_OTHER;
2082 }
2083
2084 static void virtio_input_hid_kbd_pci_class_init(ObjectClass *klass, void *data)
2085 {
2086     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2087
2088     pcidev_k->class_id = PCI_CLASS_INPUT_KEYBOARD;
2089 }
2090
2091 static void virtio_input_hid_mouse_pci_class_init(ObjectClass *klass,
2092                                                   void *data)
2093 {
2094     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2095
2096     pcidev_k->class_id = PCI_CLASS_INPUT_MOUSE;
2097 }
2098
2099 static void virtio_keyboard_initfn(Object *obj)
2100 {
2101     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2102
2103     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2104                                 TYPE_VIRTIO_KEYBOARD);
2105 }
2106
2107 static void virtio_mouse_initfn(Object *obj)
2108 {
2109     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2110
2111     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2112                                 TYPE_VIRTIO_MOUSE);
2113 }
2114
2115 static void virtio_tablet_initfn(Object *obj)
2116 {
2117     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2118
2119     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2120                                 TYPE_VIRTIO_TABLET);
2121 }
2122
2123 static void virtio_host_initfn(Object *obj)
2124 {
2125     VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(obj);
2126
2127     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2128                                 TYPE_VIRTIO_INPUT_HOST);
2129 }
2130
2131 static const TypeInfo virtio_input_pci_info = {
2132     .name          = TYPE_VIRTIO_INPUT_PCI,
2133     .parent        = TYPE_VIRTIO_PCI,
2134     .instance_size = sizeof(VirtIOInputPCI),
2135     .class_init    = virtio_input_pci_class_init,
2136     .abstract      = true,
2137 };
2138
2139 static const TypeInfo virtio_input_hid_pci_info = {
2140     .name          = TYPE_VIRTIO_INPUT_HID_PCI,
2141     .parent        = TYPE_VIRTIO_INPUT_PCI,
2142     .instance_size = sizeof(VirtIOInputHIDPCI),
2143     .abstract      = true,
2144 };
2145
2146 static const TypeInfo virtio_keyboard_pci_info = {
2147     .name          = TYPE_VIRTIO_KEYBOARD_PCI,
2148     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2149     .class_init    = virtio_input_hid_kbd_pci_class_init,
2150     .instance_size = sizeof(VirtIOInputHIDPCI),
2151     .instance_init = virtio_keyboard_initfn,
2152 };
2153
2154 static const TypeInfo virtio_mouse_pci_info = {
2155     .name          = TYPE_VIRTIO_MOUSE_PCI,
2156     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2157     .class_init    = virtio_input_hid_mouse_pci_class_init,
2158     .instance_size = sizeof(VirtIOInputHIDPCI),
2159     .instance_init = virtio_mouse_initfn,
2160 };
2161
2162 static const TypeInfo virtio_tablet_pci_info = {
2163     .name          = TYPE_VIRTIO_TABLET_PCI,
2164     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2165     .instance_size = sizeof(VirtIOInputHIDPCI),
2166     .instance_init = virtio_tablet_initfn,
2167 };
2168
2169 static const TypeInfo virtio_host_pci_info = {
2170     .name          = TYPE_VIRTIO_INPUT_HOST_PCI,
2171     .parent        = TYPE_VIRTIO_INPUT_PCI,
2172     .instance_size = sizeof(VirtIOInputHostPCI),
2173     .instance_init = virtio_host_initfn,
2174 };
2175
2176 /* virtio-pci-bus */
2177
2178 static void virtio_pci_bus_new(VirtioBusState *bus, size_t bus_size,
2179                                VirtIOPCIProxy *dev)
2180 {
2181     DeviceState *qdev = DEVICE(dev);
2182     char virtio_bus_name[] = "virtio-bus";
2183
2184     qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_PCI_BUS, qdev,
2185                         virtio_bus_name);
2186 }
2187
2188 static void virtio_pci_bus_class_init(ObjectClass *klass, void *data)
2189 {
2190     BusClass *bus_class = BUS_CLASS(klass);
2191     VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
2192     bus_class->max_dev = 1;
2193     k->notify = virtio_pci_notify;
2194     k->save_config = virtio_pci_save_config;
2195     k->load_config = virtio_pci_load_config;
2196     k->save_queue = virtio_pci_save_queue;
2197     k->load_queue = virtio_pci_load_queue;
2198     k->query_guest_notifiers = virtio_pci_query_guest_notifiers;
2199     k->set_host_notifier = virtio_pci_set_host_notifier;
2200     k->set_guest_notifiers = virtio_pci_set_guest_notifiers;
2201     k->vmstate_change = virtio_pci_vmstate_change;
2202     k->device_plugged = virtio_pci_device_plugged;
2203     k->device_unplugged = virtio_pci_device_unplugged;
2204     k->query_nvectors = virtio_pci_query_nvectors;
2205 }
2206
2207 static const TypeInfo virtio_pci_bus_info = {
2208     .name          = TYPE_VIRTIO_PCI_BUS,
2209     .parent        = TYPE_VIRTIO_BUS,
2210     .instance_size = sizeof(VirtioPCIBusState),
2211     .class_init    = virtio_pci_bus_class_init,
2212 };
2213
2214 static void virtio_pci_register_types(void)
2215 {
2216     type_register_static(&virtio_rng_pci_info);
2217     type_register_static(&virtio_input_pci_info);
2218     type_register_static(&virtio_input_hid_pci_info);
2219     type_register_static(&virtio_keyboard_pci_info);
2220     type_register_static(&virtio_mouse_pci_info);
2221     type_register_static(&virtio_tablet_pci_info);
2222     type_register_static(&virtio_host_pci_info);
2223     type_register_static(&virtio_pci_bus_info);
2224     type_register_static(&virtio_pci_info);
2225 #ifdef CONFIG_VIRTFS
2226     type_register_static(&virtio_9p_pci_info);
2227 #endif
2228     type_register_static(&virtio_blk_pci_info);
2229     type_register_static(&virtio_scsi_pci_info);
2230     type_register_static(&virtio_balloon_pci_info);
2231     type_register_static(&virtio_serial_pci_info);
2232     type_register_static(&virtio_net_pci_info);
2233 #ifdef CONFIG_VHOST_SCSI
2234     type_register_static(&vhost_scsi_pci_info);
2235 #endif
2236 }
2237
2238 type_init(virtio_pci_register_types)