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