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 static void virtio_write_config(PCIDevice *pci_dev, uint32_t address,
 447                                 uint32_t val, int len)
 448 {
 449     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 450     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 451     struct virtio_pci_cfg_cap *cfg;
 452
 453     pci_default_write_config(pci_dev, address, val, len);
 454
 455     if (range_covers_byte(address, len, PCI_COMMAND) &&
 456         !(pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
 457         virtio_pci_stop_ioeventfd(proxy);
 458         virtio_set_status(vdev, vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK);
 459     }
 460
 461     if (proxy->config_cap &&
 462         ranges_overlap(address, len, proxy->config_cap + offsetof(struct virtio_pci_cfg_cap,
 463                                                                   pci_cfg_data),
 464                        sizeof cfg->pci_cfg_data)) {
 465         uint32_t off;
 466         uint32_t len;
 467
 468         cfg = (void *)(proxy->pci_dev.config + proxy->config_cap);
 469         off = le32_to_cpu(cfg->cap.offset);
 470         len = le32_to_cpu(cfg->cap.length);
 471
 472         if ((len == 1 || len == 2 || len == 4)) {
 473             address_space_write(&proxy->modern_as, off,
 474                                 MEMTXATTRS_UNSPECIFIED,
 475                                 cfg->pci_cfg_data, len);
 476         }
 477     }
 478 }
 479
 480 static uint32_t virtio_read_config(PCIDevice *pci_dev,
 481                                    uint32_t address, int len)
 482 {
 483     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 484     struct virtio_pci_cfg_cap *cfg;
 485
 486     if (proxy->config_cap &&
 487         ranges_overlap(address, len, proxy->config_cap + offsetof(struct virtio_pci_cfg_cap,
 488                                                                   pci_cfg_data),
 489                        sizeof cfg->pci_cfg_data)) {
 490         uint32_t off;
 491         uint32_t len;
 492
 493         cfg = (void *)(proxy->pci_dev.config + proxy->config_cap);
 494         off = le32_to_cpu(cfg->cap.offset);
 495         len = le32_to_cpu(cfg->cap.length);
 496
 497         if ((len == 1 || len == 2 || len == 4)) {
 498             address_space_read(&proxy->modern_as, off,
 499                                 MEMTXATTRS_UNSPECIFIED,
 500                                 cfg->pci_cfg_data, len);
 501         }
 502     }
 503
 504     return pci_default_read_config(pci_dev, address, len);
 505 }
 506
 507 static int kvm_virtio_pci_vq_vector_use(VirtIOPCIProxy *proxy,
 508                                         unsigned int queue_no,
 509                                         unsigned int vector,
 510                                         MSIMessage msg)
 511 {
 512     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 513     int ret;
 514
 515     if (irqfd->users == 0) {
 516         ret = kvm_irqchip_add_msi_route(kvm_state, msg);
 517         if (ret < 0) {
 518             return ret;
 519         }
 520         irqfd->virq = ret;
 521     }
 522     irqfd->users++;
 523     return 0;
 524 }
 525
 526 static void kvm_virtio_pci_vq_vector_release(VirtIOPCIProxy *proxy,
 527                                              unsigned int vector)
 528 {
 529     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 530     if (--irqfd->users == 0) {
 531         kvm_irqchip_release_virq(kvm_state, irqfd->virq);
 532     }
 533 }
 534
 535 static int kvm_virtio_pci_irqfd_use(VirtIOPCIProxy *proxy,
 536                                  unsigned int queue_no,
 537                                  unsigned int vector)
 538 {
 539     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 540     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 541     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 542     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 543     int ret;
 544     ret = kvm_irqchip_add_irqfd_notifier(kvm_state, n, NULL, irqfd->virq);
 545     return ret;
 546 }
 547
 548 static void kvm_virtio_pci_irqfd_release(VirtIOPCIProxy *proxy,
 549                                       unsigned int queue_no,
 550                                       unsigned int vector)
 551 {
 552     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 553     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 554     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 555     VirtIOIRQFD *irqfd = &proxy->vector_irqfd[vector];
 556     int ret;
 557
 558     ret = kvm_irqchip_remove_irqfd_notifier(kvm_state, n, irqfd->virq);
 559     assert(ret == 0);
 560 }
 561
 562 static int kvm_virtio_pci_vector_use(VirtIOPCIProxy *proxy, int nvqs)
 563 {
 564     PCIDevice *dev = &proxy->pci_dev;
 565     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 566     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 567     unsigned int vector;
 568     int ret, queue_no;
 569     MSIMessage msg;
 570
 571     for (queue_no = 0; queue_no < nvqs; queue_no++) {
 572         if (!virtio_queue_get_num(vdev, queue_no)) {
 573             break;
 574         }
 575         vector = virtio_queue_vector(vdev, queue_no);
 576         if (vector >= msix_nr_vectors_allocated(dev)) {
 577             continue;
 578         }
 579         msg = msix_get_message(dev, vector);
 580         ret = kvm_virtio_pci_vq_vector_use(proxy, queue_no, vector, msg);
 581         if (ret < 0) {
 582             goto undo;
 583         }
 584         /* If guest supports masking, set up irqfd now.
 585          * Otherwise, delay until unmasked in the frontend.
 586          */
 587         if (k->guest_notifier_mask) {
 588             ret = kvm_virtio_pci_irqfd_use(proxy, queue_no, vector);
 589             if (ret < 0) {
 590                 kvm_virtio_pci_vq_vector_release(proxy, vector);
 591                 goto undo;
 592             }
 593         }
 594     }
 595     return 0;
 596
 597 undo:
 598     while (--queue_no >= 0) {
 599         vector = virtio_queue_vector(vdev, queue_no);
 600         if (vector >= msix_nr_vectors_allocated(dev)) {
 601             continue;
 602         }
 603         if (k->guest_notifier_mask) {
 604             kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 605         }
 606         kvm_virtio_pci_vq_vector_release(proxy, vector);
 607     }
 608     return ret;
 609 }
 610
 611 static void kvm_virtio_pci_vector_release(VirtIOPCIProxy *proxy, int nvqs)
 612 {
 613     PCIDevice *dev = &proxy->pci_dev;
 614     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 615     unsigned int vector;
 616     int queue_no;
 617     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 618
 619     for (queue_no = 0; queue_no < nvqs; queue_no++) {
 620         if (!virtio_queue_get_num(vdev, queue_no)) {
 621             break;
 622         }
 623         vector = virtio_queue_vector(vdev, queue_no);
 624         if (vector >= msix_nr_vectors_allocated(dev)) {
 625             continue;
 626         }
 627         /* If guest supports masking, clean up irqfd now.
 628          * Otherwise, it was cleaned when masked in the frontend.
 629          */
 630         if (k->guest_notifier_mask) {
 631             kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 632         }
 633         kvm_virtio_pci_vq_vector_release(proxy, vector);
 634     }
 635 }
 636
 637 static int virtio_pci_vq_vector_unmask(VirtIOPCIProxy *proxy,
 638                                        unsigned int queue_no,
 639                                        unsigned int vector,
 640                                        MSIMessage msg)
 641 {
 642     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 643     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 644     VirtQueue *vq = virtio_get_queue(vdev, queue_no);
 645     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 646     VirtIOIRQFD *irqfd;
 647     int ret = 0;
 648
 649     if (proxy->vector_irqfd) {
 650         irqfd = &proxy->vector_irqfd[vector];
 651         if (irqfd->msg.data != msg.data || irqfd->msg.address != msg.address) {
 652             ret = kvm_irqchip_update_msi_route(kvm_state, irqfd->virq, msg);
 653             if (ret < 0) {
 654                 return ret;
 655             }
 656         }
 657     }
 658
 659     /* If guest supports masking, irqfd is already setup, unmask it.
 660      * Otherwise, set it up now.
 661      */
 662     if (k->guest_notifier_mask) {
 663         k->guest_notifier_mask(vdev, queue_no, false);
 664         /* Test after unmasking to avoid losing events. */
 665         if (k->guest_notifier_pending &&
 666             k->guest_notifier_pending(vdev, queue_no)) {
 667             event_notifier_set(n);
 668         }
 669     } else {
 670         ret = kvm_virtio_pci_irqfd_use(proxy, queue_no, vector);
 671     }
 672     return ret;
 673 }
 674
 675 static void virtio_pci_vq_vector_mask(VirtIOPCIProxy *proxy,
 676                                              unsigned int queue_no,
 677                                              unsigned int vector)
 678 {
 679     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 680     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 681
 682     /* If guest supports masking, keep irqfd but mask it.
 683      * Otherwise, clean it up now.
 684      */
 685     if (k->guest_notifier_mask) {
 686         k->guest_notifier_mask(vdev, queue_no, true);
 687     } else {
 688         kvm_virtio_pci_irqfd_release(proxy, queue_no, vector);
 689     }
 690 }
 691
 692 static int virtio_pci_vector_unmask(PCIDevice *dev, unsigned vector,
 693                                     MSIMessage msg)
 694 {
 695     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 696     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 697     VirtQueue *vq = virtio_vector_first_queue(vdev, vector);
 698     int ret, index, unmasked = 0;
 699
 700     while (vq) {
 701         index = virtio_get_queue_index(vq);
 702         if (!virtio_queue_get_num(vdev, index)) {
 703             break;
 704         }
 705         if (index < proxy->nvqs_with_notifiers) {
 706             ret = virtio_pci_vq_vector_unmask(proxy, index, vector, msg);
 707             if (ret < 0) {
 708                 goto undo;
 709             }
 710             ++unmasked;
 711         }
 712         vq = virtio_vector_next_queue(vq);
 713     }
 714
 715     return 0;
 716
 717 undo:
 718     vq = virtio_vector_first_queue(vdev, vector);
 719     while (vq && unmasked >= 0) {
 720         index = virtio_get_queue_index(vq);
 721         if (index < proxy->nvqs_with_notifiers) {
 722             virtio_pci_vq_vector_mask(proxy, index, vector);
 723             --unmasked;
 724         }
 725         vq = virtio_vector_next_queue(vq);
 726     }
 727     return ret;
 728 }
 729
 730 static void virtio_pci_vector_mask(PCIDevice *dev, unsigned vector)
 731 {
 732     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 733     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 734     VirtQueue *vq = virtio_vector_first_queue(vdev, vector);
 735     int index;
 736
 737     while (vq) {
 738         index = virtio_get_queue_index(vq);
 739         if (!virtio_queue_get_num(vdev, index)) {
 740             break;
 741         }
 742         if (index < proxy->nvqs_with_notifiers) {
 743             virtio_pci_vq_vector_mask(proxy, index, vector);
 744         }
 745         vq = virtio_vector_next_queue(vq);
 746     }
 747 }
 748
 749 static void virtio_pci_vector_poll(PCIDevice *dev,
 750                                    unsigned int vector_start,
 751                                    unsigned int vector_end)
 752 {
 753     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
 754     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 755     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 756     int queue_no;
 757     unsigned int vector;
 758     EventNotifier *notifier;
 759     VirtQueue *vq;
 760
 761     for (queue_no = 0; queue_no < proxy->nvqs_with_notifiers; queue_no++) {
 762         if (!virtio_queue_get_num(vdev, queue_no)) {
 763             break;
 764         }
 765         vector = virtio_queue_vector(vdev, queue_no);
 766         if (vector < vector_start || vector >= vector_end ||
 767             !msix_is_masked(dev, vector)) {
 768             continue;
 769         }
 770         vq = virtio_get_queue(vdev, queue_no);
 771         notifier = virtio_queue_get_guest_notifier(vq);
 772         if (k->guest_notifier_pending) {
 773             if (k->guest_notifier_pending(vdev, queue_no)) {
 774                 msix_set_pending(dev, vector);
 775             }
 776         } else if (event_notifier_test_and_clear(notifier)) {
 777             msix_set_pending(dev, vector);
 778         }
 779     }
 780 }
 781
 782 static int virtio_pci_set_guest_notifier(DeviceState *d, int n, bool assign,
 783                                          bool with_irqfd)
 784 {
 785     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 786     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 787     VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
 788     VirtQueue *vq = virtio_get_queue(vdev, n);
 789     EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
 790
 791     if (assign) {
 792         int r = event_notifier_init(notifier, 0);
 793         if (r < 0) {
 794             return r;
 795         }
 796         virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd);
 797     } else {
 798         virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd);
 799         event_notifier_cleanup(notifier);
 800     }
 801
 802     if (!msix_enabled(&proxy->pci_dev) && vdc->guest_notifier_mask) {
 803         vdc->guest_notifier_mask(vdev, n, !assign);
 804     }
 805
 806     return 0;
 807 }
 808
 809 static bool virtio_pci_query_guest_notifiers(DeviceState *d)
 810 {
 811     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 812     return msix_enabled(&proxy->pci_dev);
 813 }
 814
 815 static int virtio_pci_set_guest_notifiers(DeviceState *d, int nvqs, bool assign)
 816 {
 817     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 818     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 819     VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
 820     int r, n;
 821     bool with_irqfd = msix_enabled(&proxy->pci_dev) &&
 822         kvm_msi_via_irqfd_enabled();
 823
 824     nvqs = MIN(nvqs, VIRTIO_QUEUE_MAX);
 825
 826     /* When deassigning, pass a consistent nvqs value
 827      * to avoid leaking notifiers.
 828      */
 829     assert(assign || nvqs == proxy->nvqs_with_notifiers);
 830
 831     proxy->nvqs_with_notifiers = nvqs;
 832
 833     /* Must unset vector notifier while guest notifier is still assigned */
 834     if ((proxy->vector_irqfd || k->guest_notifier_mask) && !assign) {
 835         msix_unset_vector_notifiers(&proxy->pci_dev);
 836         if (proxy->vector_irqfd) {
 837             kvm_virtio_pci_vector_release(proxy, nvqs);
 838             g_free(proxy->vector_irqfd);
 839             proxy->vector_irqfd = NULL;
 840         }
 841     }
 842
 843     for (n = 0; n < nvqs; n++) {
 844         if (!virtio_queue_get_num(vdev, n)) {
 845             break;
 846         }
 847
 848         r = virtio_pci_set_guest_notifier(d, n, assign, with_irqfd);
 849         if (r < 0) {
 850             goto assign_error;
 851         }
 852     }
 853
 854     /* Must set vector notifier after guest notifier has been assigned */
 855     if ((with_irqfd || k->guest_notifier_mask) && assign) {
 856         if (with_irqfd) {
 857             proxy->vector_irqfd =
 858                 g_malloc0(sizeof(*proxy->vector_irqfd) *
 859                           msix_nr_vectors_allocated(&proxy->pci_dev));
 860             r = kvm_virtio_pci_vector_use(proxy, nvqs);
 861             if (r < 0) {
 862                 goto assign_error;
 863             }
 864         }
 865         r = msix_set_vector_notifiers(&proxy->pci_dev,
 866                                       virtio_pci_vector_unmask,
 867                                       virtio_pci_vector_mask,
 868                                       virtio_pci_vector_poll);
 869         if (r < 0) {
 870             goto notifiers_error;
 871         }
 872     }
 873
 874     return 0;
 875
 876 notifiers_error:
 877     if (with_irqfd) {
 878         assert(assign);
 879         kvm_virtio_pci_vector_release(proxy, nvqs);
 880     }
 881
 882 assign_error:
 883     /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
 884     assert(assign);
 885     while (--n >= 0) {
 886         virtio_pci_set_guest_notifier(d, n, !assign, with_irqfd);
 887     }
 888     return r;
 889 }
 890
 891 static int virtio_pci_set_host_notifier(DeviceState *d, int n, bool assign)
 892 {
 893     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 894
 895     /* Stop using ioeventfd for virtqueue kick if the device starts using host
 896      * notifiers.  This makes it easy to avoid stepping on each others' toes.
 897      */
 898     proxy->ioeventfd_disabled = assign;
 899     if (assign) {
 900         virtio_pci_stop_ioeventfd(proxy);
 901     }
 902     /* We don't need to start here: it's not needed because backend
 903      * currently only stops on status change away from ok,
 904      * reset, vmstop and such. If we do add code to start here,
 905      * need to check vmstate, device state etc. */
 906     return virtio_pci_set_host_notifier_internal(proxy, n, assign, false);
 907 }
 908
 909 static void virtio_pci_vmstate_change(DeviceState *d, bool running)
 910 {
 911     VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
 912     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
 913
 914     if (running) {
 915         /* Old QEMU versions did not set bus master enable on status write.
 916          * Detect DRIVER set and enable it.
 917          */
 918         if ((proxy->flags & VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION) &&
 919             (vdev->status & VIRTIO_CONFIG_S_DRIVER) &&
 920             !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
 921             pci_default_write_config(&proxy->pci_dev, PCI_COMMAND,
 922                                      proxy->pci_dev.config[PCI_COMMAND] |
 923                                      PCI_COMMAND_MASTER, 1);
 924         }
 925         virtio_pci_start_ioeventfd(proxy);
 926     } else {
 927         virtio_pci_stop_ioeventfd(proxy);
 928     }
 929 }
 930
 931 #ifdef CONFIG_VIRTFS
 932 static void virtio_9p_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
 933 {
 934     V9fsPCIState *dev = VIRTIO_9P_PCI(vpci_dev);
 935     DeviceState *vdev = DEVICE(&dev->vdev);
 936
 937     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
 938     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
 939 }
 940
 941 static Property virtio_9p_pci_properties[] = {
 942     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
 943                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
 944     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
 945     DEFINE_PROP_END_OF_LIST(),
 946 };
 947
 948 static void virtio_9p_pci_class_init(ObjectClass *klass, void *data)
 949 {
 950     DeviceClass *dc = DEVICE_CLASS(klass);
 951     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
 952     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
 953
 954     k->realize = virtio_9p_pci_realize;
 955     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
 956     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_9P;
 957     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
 958     pcidev_k->class_id = 0x2;
 959     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 960     dc->props = virtio_9p_pci_properties;
 961 }
 962
 963 static void virtio_9p_pci_instance_init(Object *obj)
 964 {
 965     V9fsPCIState *dev = VIRTIO_9P_PCI(obj);
 966
 967     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
 968                                 TYPE_VIRTIO_9P);
 969 }
 970
 971 static const TypeInfo virtio_9p_pci_info = {
 972     .name          = TYPE_VIRTIO_9P_PCI,
 973     .parent        = TYPE_VIRTIO_PCI,
 974     .instance_size = sizeof(V9fsPCIState),
 975     .instance_init = virtio_9p_pci_instance_init,
 976     .class_init    = virtio_9p_pci_class_init,
 977 };
 978 #endif /* CONFIG_VIRTFS */
 979
 980 /*
 981  * virtio-pci: This is the PCIDevice which has a virtio-pci-bus.
 982  */
 983
 984 static int virtio_pci_query_nvectors(DeviceState *d)
 985 {
 986     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
 987
 988     return proxy->nvectors;
 989 }
 990
 991 static int virtio_pci_add_mem_cap(VirtIOPCIProxy *proxy,
 992                                    struct virtio_pci_cap *cap)
 993 {
 994     PCIDevice *dev = &proxy->pci_dev;
 995     int offset;
 996
 997     offset = pci_add_capability(dev, PCI_CAP_ID_VNDR, 0, cap->cap_len);
 998     assert(offset > 0);
 999
1000     assert(cap->cap_len >= sizeof *cap);
1001     memcpy(dev->config + offset + PCI_CAP_FLAGS, &cap->cap_len,
1002            cap->cap_len - PCI_CAP_FLAGS);
1003
1004     return offset;
1005 }
1006
1007 static uint64_t virtio_pci_common_read(void *opaque, hwaddr addr,
1008                                        unsigned size)
1009 {
1010     VirtIOPCIProxy *proxy = opaque;
1011     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1012     uint32_t val = 0;
1013     int i;
1014
1015     switch (addr) {
1016     case VIRTIO_PCI_COMMON_DFSELECT:
1017         val = proxy->dfselect;
1018         break;
1019     case VIRTIO_PCI_COMMON_DF:
1020         if (proxy->dfselect <= 1) {
1021             val = vdev->host_features >> (32 * proxy->dfselect);
1022         }
1023         break;
1024     case VIRTIO_PCI_COMMON_GFSELECT:
1025         val = proxy->gfselect;
1026         break;
1027     case VIRTIO_PCI_COMMON_GF:
1028         if (proxy->gfselect < ARRAY_SIZE(proxy->guest_features)) {
1029             val = proxy->guest_features[proxy->gfselect];
1030         }
1031         break;
1032     case VIRTIO_PCI_COMMON_MSIX:
1033         val = vdev->config_vector;
1034         break;
1035     case VIRTIO_PCI_COMMON_NUMQ:
1036         for (i = 0; i < VIRTIO_QUEUE_MAX; ++i) {
1037             if (virtio_queue_get_num(vdev, i)) {
1038                 val = i + 1;
1039             }
1040         }
1041         break;
1042     case VIRTIO_PCI_COMMON_STATUS:
1043         val = vdev->status;
1044         break;
1045     case VIRTIO_PCI_COMMON_CFGGENERATION:
1046         val = vdev->generation;
1047         break;
1048     case VIRTIO_PCI_COMMON_Q_SELECT:
1049         val = vdev->queue_sel;
1050         break;
1051     case VIRTIO_PCI_COMMON_Q_SIZE:
1052         val = virtio_queue_get_num(vdev, vdev->queue_sel);
1053         break;
1054     case VIRTIO_PCI_COMMON_Q_MSIX:
1055         val = virtio_queue_vector(vdev, vdev->queue_sel);
1056         break;
1057     case VIRTIO_PCI_COMMON_Q_ENABLE:
1058         val = proxy->vqs[vdev->queue_sel].enabled;
1059         break;
1060     case VIRTIO_PCI_COMMON_Q_NOFF:
1061         /* Simply map queues in order */
1062         val = vdev->queue_sel;
1063         break;
1064     case VIRTIO_PCI_COMMON_Q_DESCLO:
1065         val = proxy->vqs[vdev->queue_sel].desc[0];
1066         break;
1067     case VIRTIO_PCI_COMMON_Q_DESCHI:
1068         val = proxy->vqs[vdev->queue_sel].desc[1];
1069         break;
1070     case VIRTIO_PCI_COMMON_Q_AVAILLO:
1071         val = proxy->vqs[vdev->queue_sel].avail[0];
1072         break;
1073     case VIRTIO_PCI_COMMON_Q_AVAILHI:
1074         val = proxy->vqs[vdev->queue_sel].avail[1];
1075         break;
1076     case VIRTIO_PCI_COMMON_Q_USEDLO:
1077         val = proxy->vqs[vdev->queue_sel].used[0];
1078         break;
1079     case VIRTIO_PCI_COMMON_Q_USEDHI:
1080         val = proxy->vqs[vdev->queue_sel].used[1];
1081         break;
1082     default:
1083         val = 0;
1084     }
1085
1086     return val;
1087 }
1088
1089 static void virtio_pci_common_write(void *opaque, hwaddr addr,
1090                                     uint64_t val, unsigned size)
1091 {
1092     VirtIOPCIProxy *proxy = opaque;
1093     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1094
1095     switch (addr) {
1096     case VIRTIO_PCI_COMMON_DFSELECT:
1097         proxy->dfselect = val;
1098         break;
1099     case VIRTIO_PCI_COMMON_GFSELECT:
1100         proxy->gfselect = val;
1101         break;
1102     case VIRTIO_PCI_COMMON_GF:
1103         if (proxy->gfselect < ARRAY_SIZE(proxy->guest_features)) {
1104             proxy->guest_features[proxy->gfselect] = val;
1105             virtio_set_features(vdev,
1106                                 (((uint64_t)proxy->guest_features[1]) << 32) |
1107                                 proxy->guest_features[0]);
1108         }
1109         break;
1110     case VIRTIO_PCI_COMMON_MSIX:
1111         msix_vector_unuse(&proxy->pci_dev, vdev->config_vector);
1112         /* Make it possible for guest to discover an error took place. */
1113         if (msix_vector_use(&proxy->pci_dev, val) < 0) {
1114             val = VIRTIO_NO_VECTOR;
1115         }
1116         vdev->config_vector = val;
1117         break;
1118     case VIRTIO_PCI_COMMON_STATUS:
1119         if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) {
1120             virtio_pci_stop_ioeventfd(proxy);
1121         }
1122
1123         virtio_set_status(vdev, val & 0xFF);
1124
1125         if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
1126             virtio_pci_start_ioeventfd(proxy);
1127         }
1128
1129         if (vdev->status == 0) {
1130             virtio_reset(vdev);
1131             msix_unuse_all_vectors(&proxy->pci_dev);
1132         }
1133
1134         break;
1135     case VIRTIO_PCI_COMMON_Q_SELECT:
1136         if (val < VIRTIO_QUEUE_MAX) {
1137             vdev->queue_sel = val;
1138         }
1139         break;
1140     case VIRTIO_PCI_COMMON_Q_SIZE:
1141         proxy->vqs[vdev->queue_sel].num = val;
1142         break;
1143     case VIRTIO_PCI_COMMON_Q_MSIX:
1144         msix_vector_unuse(&proxy->pci_dev,
1145                           virtio_queue_vector(vdev, vdev->queue_sel));
1146         /* Make it possible for guest to discover an error took place. */
1147         if (msix_vector_use(&proxy->pci_dev, val) < 0) {
1148             val = VIRTIO_NO_VECTOR;
1149         }
1150         virtio_queue_set_vector(vdev, vdev->queue_sel, val);
1151         break;
1152     case VIRTIO_PCI_COMMON_Q_ENABLE:
1153         /* TODO: need a way to put num back on reset. */
1154         virtio_queue_set_num(vdev, vdev->queue_sel,
1155                              proxy->vqs[vdev->queue_sel].num);
1156         virtio_queue_set_rings(vdev, vdev->queue_sel,
1157                        ((uint64_t)proxy->vqs[vdev->queue_sel].desc[1]) << 32 |
1158                        proxy->vqs[vdev->queue_sel].desc[0],
1159                        ((uint64_t)proxy->vqs[vdev->queue_sel].avail[1]) << 32 |
1160                        proxy->vqs[vdev->queue_sel].avail[0],
1161                        ((uint64_t)proxy->vqs[vdev->queue_sel].used[1]) << 32 |
1162                        proxy->vqs[vdev->queue_sel].used[0]);
1163         break;
1164     case VIRTIO_PCI_COMMON_Q_DESCLO:
1165         proxy->vqs[vdev->queue_sel].desc[0] = val;
1166         break;
1167     case VIRTIO_PCI_COMMON_Q_DESCHI:
1168         proxy->vqs[vdev->queue_sel].desc[1] = val;
1169         break;
1170     case VIRTIO_PCI_COMMON_Q_AVAILLO:
1171         proxy->vqs[vdev->queue_sel].avail[0] = val;
1172         break;
1173     case VIRTIO_PCI_COMMON_Q_AVAILHI:
1174         proxy->vqs[vdev->queue_sel].avail[1] = val;
1175         break;
1176     case VIRTIO_PCI_COMMON_Q_USEDLO:
1177         proxy->vqs[vdev->queue_sel].used[0] = val;
1178         break;
1179     case VIRTIO_PCI_COMMON_Q_USEDHI:
1180         proxy->vqs[vdev->queue_sel].used[1] = val;
1181         break;
1182     default:
1183         break;
1184     }
1185 }
1186
1187
1188 static uint64_t virtio_pci_notify_read(void *opaque, hwaddr addr,
1189                                        unsigned size)
1190 {
1191     return 0;
1192 }
1193
1194 static void virtio_pci_notify_write(void *opaque, hwaddr addr,
1195                                     uint64_t val, unsigned size)
1196 {
1197     VirtIODevice *vdev = opaque;
1198     unsigned queue = addr / QEMU_VIRTIO_PCI_QUEUE_MEM_MULT;
1199
1200     if (queue < VIRTIO_QUEUE_MAX) {
1201         virtio_queue_notify(vdev, queue);
1202     }
1203 }
1204
1205 static uint64_t virtio_pci_isr_read(void *opaque, hwaddr addr,
1206                                     unsigned size)
1207 {
1208     VirtIOPCIProxy *proxy = opaque;
1209     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1210     uint64_t val = vdev->isr;
1211
1212     vdev->isr = 0;
1213     pci_irq_deassert(&proxy->pci_dev);
1214
1215     return val;
1216 }
1217
1218 static void virtio_pci_isr_write(void *opaque, hwaddr addr,
1219                                  uint64_t val, unsigned size)
1220 {
1221 }
1222
1223 static uint64_t virtio_pci_device_read(void *opaque, hwaddr addr,
1224                                        unsigned size)
1225 {
1226     VirtIODevice *vdev = opaque;
1227     uint64_t val = 0;
1228
1229     switch (size) {
1230     case 1:
1231         val = virtio_config_modern_readb(vdev, addr);
1232         break;
1233     case 2:
1234         val = virtio_config_modern_readw(vdev, addr);
1235         break;
1236     case 4:
1237         val = virtio_config_modern_readl(vdev, addr);
1238         break;
1239     }
1240     return val;
1241 }
1242
1243 static void virtio_pci_device_write(void *opaque, hwaddr addr,
1244                                     uint64_t val, unsigned size)
1245 {
1246     VirtIODevice *vdev = opaque;
1247     switch (size) {
1248     case 1:
1249         virtio_config_modern_writeb(vdev, addr, val);
1250         break;
1251     case 2:
1252         virtio_config_modern_writew(vdev, addr, val);
1253         break;
1254     case 4:
1255         virtio_config_modern_writel(vdev, addr, val);
1256         break;
1257     }
1258 }
1259
1260 static void virtio_pci_modern_regions_init(VirtIOPCIProxy *proxy)
1261 {
1262     static const MemoryRegionOps common_ops = {
1263         .read = virtio_pci_common_read,
1264         .write = virtio_pci_common_write,
1265         .impl = {
1266             .min_access_size = 1,
1267             .max_access_size = 4,
1268         },
1269         .endianness = DEVICE_LITTLE_ENDIAN,
1270     };
1271     static const MemoryRegionOps isr_ops = {
1272         .read = virtio_pci_isr_read,
1273         .write = virtio_pci_isr_write,
1274         .impl = {
1275             .min_access_size = 1,
1276             .max_access_size = 4,
1277         },
1278         .endianness = DEVICE_LITTLE_ENDIAN,
1279     };
1280     static const MemoryRegionOps device_ops = {
1281         .read = virtio_pci_device_read,
1282         .write = virtio_pci_device_write,
1283         .impl = {
1284             .min_access_size = 1,
1285             .max_access_size = 4,
1286         },
1287         .endianness = DEVICE_LITTLE_ENDIAN,
1288     };
1289     static const MemoryRegionOps notify_ops = {
1290         .read = virtio_pci_notify_read,
1291         .write = virtio_pci_notify_write,
1292         .impl = {
1293             .min_access_size = 1,
1294             .max_access_size = 4,
1295         },
1296         .endianness = DEVICE_LITTLE_ENDIAN,
1297     };
1298
1299     memory_region_init_io(&proxy->common.mr, OBJECT(proxy),
1300                           &common_ops,
1301                           proxy,
1302                           "virtio-pci-common",
1303                           proxy->common.size);
1304
1305     memory_region_init_io(&proxy->isr.mr, OBJECT(proxy),
1306                           &isr_ops,
1307                           proxy,
1308                           "virtio-pci-isr",
1309                           proxy->isr.size);
1310
1311     memory_region_init_io(&proxy->device.mr, OBJECT(proxy),
1312                           &device_ops,
1313                           virtio_bus_get_device(&proxy->bus),
1314                           "virtio-pci-device",
1315                           proxy->device.size);
1316
1317     memory_region_init_io(&proxy->notify.mr, OBJECT(proxy),
1318                           &notify_ops,
1319                           virtio_bus_get_device(&proxy->bus),
1320                           "virtio-pci-notify",
1321                           proxy->notify.size);
1322 }
1323
1324 static void virtio_pci_modern_region_map(VirtIOPCIProxy *proxy,
1325                                          VirtIOPCIRegion *region,
1326                                          struct virtio_pci_cap *cap)
1327 {
1328     memory_region_add_subregion(&proxy->modern_bar,
1329                                 region->offset,
1330                                 &region->mr);
1331
1332     cap->cfg_type = region->type;
1333     cap->bar = proxy->modern_mem_bar;
1334     cap->offset = cpu_to_le32(region->offset);
1335     cap->length = cpu_to_le32(region->size);
1336     virtio_pci_add_mem_cap(proxy, cap);
1337 }
1338
1339 /* This is called by virtio-bus just after the device is plugged. */
1340 static void virtio_pci_device_plugged(DeviceState *d, Error **errp)
1341 {
1342     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1343     VirtioBusState *bus = &proxy->bus;
1344     bool legacy = !(proxy->flags & VIRTIO_PCI_FLAG_DISABLE_LEGACY);
1345     bool modern = !(proxy->flags & VIRTIO_PCI_FLAG_DISABLE_MODERN);
1346     uint8_t *config;
1347     uint32_t size;
1348     VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
1349
1350     config = proxy->pci_dev.config;
1351     if (proxy->class_code) {
1352         pci_config_set_class(config, proxy->class_code);
1353     }
1354
1355     if (legacy) {
1356         /* legacy and transitional */
1357         pci_set_word(config + PCI_SUBSYSTEM_VENDOR_ID,
1358                      pci_get_word(config + PCI_VENDOR_ID));
1359         pci_set_word(config + PCI_SUBSYSTEM_ID, virtio_bus_get_vdev_id(bus));
1360     } else {
1361         /* pure virtio-1.0 */
1362         pci_set_word(config + PCI_VENDOR_ID,
1363                      PCI_VENDOR_ID_REDHAT_QUMRANET);
1364         pci_set_word(config + PCI_DEVICE_ID,
1365                      0x1040 + virtio_bus_get_vdev_id(bus));
1366         pci_config_set_revision(config, 1);
1367     }
1368     config[PCI_INTERRUPT_PIN] = 1;
1369
1370
1371     if (modern) {
1372         struct virtio_pci_cap cap = {
1373             .cap_len = sizeof cap,
1374         };
1375         struct virtio_pci_notify_cap notify = {
1376             .cap.cap_len = sizeof notify,
1377             .notify_off_multiplier =
1378                 cpu_to_le32(QEMU_VIRTIO_PCI_QUEUE_MEM_MULT),
1379         };
1380         struct virtio_pci_cfg_cap cfg = {
1381             .cap.cap_len = sizeof cfg,
1382             .cap.cfg_type = VIRTIO_PCI_CAP_PCI_CFG,
1383         };
1384         struct virtio_pci_cfg_cap *cfg_mask;
1385
1386         /* TODO: add io access for speed */
1387
1388         virtio_add_feature(&vdev->host_features, VIRTIO_F_VERSION_1);
1389         virtio_pci_modern_regions_init(proxy);
1390         virtio_pci_modern_region_map(proxy, &proxy->common, &cap);
1391         virtio_pci_modern_region_map(proxy, &proxy->isr, &cap);
1392         virtio_pci_modern_region_map(proxy, &proxy->device, &cap);
1393         virtio_pci_modern_region_map(proxy, &proxy->notify, &notify.cap);
1394
1395         pci_register_bar(&proxy->pci_dev, proxy->modern_mem_bar,
1396                          PCI_BASE_ADDRESS_SPACE_MEMORY |
1397                          PCI_BASE_ADDRESS_MEM_PREFETCH |
1398                          PCI_BASE_ADDRESS_MEM_TYPE_64,
1399                          &proxy->modern_bar);
1400
1401         proxy->config_cap = virtio_pci_add_mem_cap(proxy, &cfg.cap);
1402         cfg_mask = (void *)(proxy->pci_dev.wmask + proxy->config_cap);
1403         pci_set_byte(&cfg_mask->cap.bar, ~0x0);
1404         pci_set_long((uint8_t *)&cfg_mask->cap.offset, ~0x0);
1405         pci_set_long((uint8_t *)&cfg_mask->cap.length, ~0x0);
1406         pci_set_long(cfg_mask->pci_cfg_data, ~0x0);
1407     }
1408
1409     if (proxy->nvectors &&
1410         msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors,
1411                                 proxy->msix_bar)) {
1412         error_report("unable to init msix vectors to %" PRIu32,
1413                      proxy->nvectors);
1414         proxy->nvectors = 0;
1415     }
1416
1417     proxy->pci_dev.config_write = virtio_write_config;
1418     proxy->pci_dev.config_read = virtio_read_config;
1419
1420     if (legacy) {
1421         size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev)
1422             + virtio_bus_get_vdev_config_len(bus);
1423         if (size & (size - 1)) {
1424             size = 1 << qemu_fls(size);
1425         }
1426
1427         memory_region_init_io(&proxy->bar, OBJECT(proxy),
1428                               &virtio_pci_config_ops,
1429                               proxy, "virtio-pci", size);
1430
1431         pci_register_bar(&proxy->pci_dev, proxy->legacy_io_bar,
1432                          PCI_BASE_ADDRESS_SPACE_IO, &proxy->bar);
1433     }
1434
1435     if (!kvm_has_many_ioeventfds()) {
1436         proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
1437     }
1438
1439     virtio_add_feature(&vdev->host_features, VIRTIO_F_BAD_FEATURE);
1440 }
1441
1442 static void virtio_pci_device_unplugged(DeviceState *d)
1443 {
1444     VirtIOPCIProxy *proxy = VIRTIO_PCI(d);
1445
1446     virtio_pci_stop_ioeventfd(proxy);
1447 }
1448
1449 static void virtio_pci_realize(PCIDevice *pci_dev, Error **errp)
1450 {
1451     VirtIOPCIProxy *proxy = VIRTIO_PCI(pci_dev);
1452     VirtioPCIClass *k = VIRTIO_PCI_GET_CLASS(pci_dev);
1453
1454     /*
1455      * virtio pci bar layout used by default.
1456      * subclasses can re-arrange things if needed.
1457      *
1458      *   region 0   --  virtio legacy io bar
1459      *   region 1   --  msi-x bar
1460      *   region 4+5 --  virtio modern memory (64bit) bar
1461      *
1462      */
1463     proxy->legacy_io_bar  = 0;
1464     proxy->msix_bar       = 1;
1465     proxy->modern_mem_bar = 4;
1466
1467     proxy->common.offset = 0x0;
1468     proxy->common.size = 0x1000;
1469     proxy->common.type = VIRTIO_PCI_CAP_COMMON_CFG;
1470
1471     proxy->isr.offset = 0x1000;
1472     proxy->isr.size = 0x1000;
1473     proxy->isr.type = VIRTIO_PCI_CAP_ISR_CFG;
1474
1475     proxy->device.offset = 0x2000;
1476     proxy->device.size = 0x1000;
1477     proxy->device.type = VIRTIO_PCI_CAP_DEVICE_CFG;
1478
1479     proxy->notify.offset = 0x3000;
1480     proxy->notify.size =
1481         QEMU_VIRTIO_PCI_QUEUE_MEM_MULT * VIRTIO_QUEUE_MAX;
1482     proxy->notify.type = VIRTIO_PCI_CAP_NOTIFY_CFG;
1483
1484     /* subclasses can enforce modern, so do this unconditionally */
1485     memory_region_init(&proxy->modern_bar, OBJECT(proxy), "virtio-pci",
1486                        2 * QEMU_VIRTIO_PCI_QUEUE_MEM_MULT *
1487                        VIRTIO_QUEUE_MAX);
1488
1489     memory_region_init_alias(&proxy->modern_cfg,
1490                              OBJECT(proxy),
1491                              "virtio-pci-cfg",
1492                              &proxy->modern_bar,
1493                              0,
1494                              memory_region_size(&proxy->modern_bar));
1495
1496     address_space_init(&proxy->modern_as, &proxy->modern_cfg, "virtio-pci-cfg-as");
1497
1498     virtio_pci_bus_new(&proxy->bus, sizeof(proxy->bus), proxy);
1499     if (k->realize) {
1500         k->realize(proxy, errp);
1501     }
1502 }
1503
1504 static void virtio_pci_exit(PCIDevice *pci_dev)
1505 {
1506     VirtIOPCIProxy *proxy = VIRTIO_PCI(pci_dev);
1507
1508     msix_uninit_exclusive_bar(pci_dev);
1509     address_space_destroy(&proxy->modern_as);
1510 }
1511
1512 static void virtio_pci_reset(DeviceState *qdev)
1513 {
1514     VirtIOPCIProxy *proxy = VIRTIO_PCI(qdev);
1515     VirtioBusState *bus = VIRTIO_BUS(&proxy->bus);
1516     virtio_pci_stop_ioeventfd(proxy);
1517     virtio_bus_reset(bus);
1518     msix_unuse_all_vectors(&proxy->pci_dev);
1519 }
1520
1521 static Property virtio_pci_properties[] = {
1522     DEFINE_PROP_BIT("virtio-pci-bus-master-bug-migration", VirtIOPCIProxy, flags,
1523                     VIRTIO_PCI_FLAG_BUS_MASTER_BUG_MIGRATION_BIT, false),
1524     DEFINE_PROP_BIT("disable-legacy", VirtIOPCIProxy, flags,
1525                     VIRTIO_PCI_FLAG_DISABLE_LEGACY_BIT, false),
1526     DEFINE_PROP_BIT("disable-modern", VirtIOPCIProxy, flags,
1527                     VIRTIO_PCI_FLAG_DISABLE_MODERN_BIT, true),
1528     DEFINE_PROP_END_OF_LIST(),
1529 };
1530
1531 static void virtio_pci_class_init(ObjectClass *klass, void *data)
1532 {
1533     DeviceClass *dc = DEVICE_CLASS(klass);
1534     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1535
1536     dc->props = virtio_pci_properties;
1537     k->realize = virtio_pci_realize;
1538     k->exit = virtio_pci_exit;
1539     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1540     k->revision = VIRTIO_PCI_ABI_VERSION;
1541     k->class_id = PCI_CLASS_OTHERS;
1542     dc->reset = virtio_pci_reset;
1543 }
1544
1545 static const TypeInfo virtio_pci_info = {
1546     .name          = TYPE_VIRTIO_PCI,
1547     .parent        = TYPE_PCI_DEVICE,
1548     .instance_size = sizeof(VirtIOPCIProxy),
1549     .class_init    = virtio_pci_class_init,
1550     .class_size    = sizeof(VirtioPCIClass),
1551     .abstract      = true,
1552 };
1553
1554 /* virtio-blk-pci */
1555
1556 static Property virtio_blk_pci_properties[] = {
1557     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
1558     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1559                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1560     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
1561     DEFINE_PROP_END_OF_LIST(),
1562 };
1563
1564 static void virtio_blk_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1565 {
1566     VirtIOBlkPCI *dev = VIRTIO_BLK_PCI(vpci_dev);
1567     DeviceState *vdev = DEVICE(&dev->vdev);
1568
1569     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1570     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1571 }
1572
1573 static void virtio_blk_pci_class_init(ObjectClass *klass, void *data)
1574 {
1575     DeviceClass *dc = DEVICE_CLASS(klass);
1576     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1577     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1578
1579     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1580     dc->props = virtio_blk_pci_properties;
1581     k->realize = virtio_blk_pci_realize;
1582     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1583     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BLOCK;
1584     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1585     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
1586 }
1587
1588 static void virtio_blk_pci_instance_init(Object *obj)
1589 {
1590     VirtIOBlkPCI *dev = VIRTIO_BLK_PCI(obj);
1591
1592     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1593                                 TYPE_VIRTIO_BLK);
1594     object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev),"iothread",
1595                               &error_abort);
1596     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
1597                               "bootindex", &error_abort);
1598 }
1599
1600 static const TypeInfo virtio_blk_pci_info = {
1601     .name          = TYPE_VIRTIO_BLK_PCI,
1602     .parent        = TYPE_VIRTIO_PCI,
1603     .instance_size = sizeof(VirtIOBlkPCI),
1604     .instance_init = virtio_blk_pci_instance_init,
1605     .class_init    = virtio_blk_pci_class_init,
1606 };
1607
1608 /* virtio-scsi-pci */
1609
1610 static Property virtio_scsi_pci_properties[] = {
1611     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1612                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1613     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
1614                        DEV_NVECTORS_UNSPECIFIED),
1615     DEFINE_PROP_END_OF_LIST(),
1616 };
1617
1618 static void virtio_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1619 {
1620     VirtIOSCSIPCI *dev = VIRTIO_SCSI_PCI(vpci_dev);
1621     DeviceState *vdev = DEVICE(&dev->vdev);
1622     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
1623     DeviceState *proxy = DEVICE(vpci_dev);
1624     char *bus_name;
1625
1626     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
1627         vpci_dev->nvectors = vs->conf.num_queues + 3;
1628     }
1629
1630     /*
1631      * For command line compatibility, this sets the virtio-scsi-device bus
1632      * name as before.
1633      */
1634     if (proxy->id) {
1635         bus_name = g_strdup_printf("%s.0", proxy->id);
1636         virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);
1637         g_free(bus_name);
1638     }
1639
1640     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1641     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1642 }
1643
1644 static void virtio_scsi_pci_class_init(ObjectClass *klass, void *data)
1645 {
1646     DeviceClass *dc = DEVICE_CLASS(klass);
1647     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1648     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1649
1650     k->realize = virtio_scsi_pci_realize;
1651     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1652     dc->props = virtio_scsi_pci_properties;
1653     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1654     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
1655     pcidev_k->revision = 0x00;
1656     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
1657 }
1658
1659 static void virtio_scsi_pci_instance_init(Object *obj)
1660 {
1661     VirtIOSCSIPCI *dev = VIRTIO_SCSI_PCI(obj);
1662
1663     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1664                                 TYPE_VIRTIO_SCSI);
1665     object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev), "iothread",
1666                               &error_abort);
1667 }
1668
1669 static const TypeInfo virtio_scsi_pci_info = {
1670     .name          = TYPE_VIRTIO_SCSI_PCI,
1671     .parent        = TYPE_VIRTIO_PCI,
1672     .instance_size = sizeof(VirtIOSCSIPCI),
1673     .instance_init = virtio_scsi_pci_instance_init,
1674     .class_init    = virtio_scsi_pci_class_init,
1675 };
1676
1677 /* vhost-scsi-pci */
1678
1679 #ifdef CONFIG_VHOST_SCSI
1680 static Property vhost_scsi_pci_properties[] = {
1681     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
1682                        DEV_NVECTORS_UNSPECIFIED),
1683     DEFINE_PROP_END_OF_LIST(),
1684 };
1685
1686 static void vhost_scsi_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1687 {
1688     VHostSCSIPCI *dev = VHOST_SCSI_PCI(vpci_dev);
1689     DeviceState *vdev = DEVICE(&dev->vdev);
1690     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
1691
1692     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
1693         vpci_dev->nvectors = vs->conf.num_queues + 3;
1694     }
1695
1696     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1697     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1698 }
1699
1700 static void vhost_scsi_pci_class_init(ObjectClass *klass, void *data)
1701 {
1702     DeviceClass *dc = DEVICE_CLASS(klass);
1703     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1704     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1705     k->realize = vhost_scsi_pci_realize;
1706     set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
1707     dc->props = vhost_scsi_pci_properties;
1708     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1709     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_SCSI;
1710     pcidev_k->revision = 0x00;
1711     pcidev_k->class_id = PCI_CLASS_STORAGE_SCSI;
1712 }
1713
1714 static void vhost_scsi_pci_instance_init(Object *obj)
1715 {
1716     VHostSCSIPCI *dev = VHOST_SCSI_PCI(obj);
1717
1718     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1719                                 TYPE_VHOST_SCSI);
1720     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
1721                               "bootindex", &error_abort);
1722 }
1723
1724 static const TypeInfo vhost_scsi_pci_info = {
1725     .name          = TYPE_VHOST_SCSI_PCI,
1726     .parent        = TYPE_VIRTIO_PCI,
1727     .instance_size = sizeof(VHostSCSIPCI),
1728     .instance_init = vhost_scsi_pci_instance_init,
1729     .class_init    = vhost_scsi_pci_class_init,
1730 };
1731 #endif
1732
1733 /* virtio-balloon-pci */
1734
1735 static Property virtio_balloon_pci_properties[] = {
1736     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
1737     DEFINE_PROP_END_OF_LIST(),
1738 };
1739
1740 static void virtio_balloon_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1741 {
1742     VirtIOBalloonPCI *dev = VIRTIO_BALLOON_PCI(vpci_dev);
1743     DeviceState *vdev = DEVICE(&dev->vdev);
1744
1745     if (vpci_dev->class_code != PCI_CLASS_OTHERS &&
1746         vpci_dev->class_code != PCI_CLASS_MEMORY_RAM) { /* qemu < 1.1 */
1747         vpci_dev->class_code = PCI_CLASS_OTHERS;
1748     }
1749
1750     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1751     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1752 }
1753
1754 static void virtio_balloon_pci_class_init(ObjectClass *klass, void *data)
1755 {
1756     DeviceClass *dc = DEVICE_CLASS(klass);
1757     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1758     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1759     k->realize = virtio_balloon_pci_realize;
1760     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
1761     dc->props = virtio_balloon_pci_properties;
1762     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1763     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_BALLOON;
1764     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1765     pcidev_k->class_id = PCI_CLASS_OTHERS;
1766 }
1767
1768 static void virtio_balloon_pci_instance_init(Object *obj)
1769 {
1770     VirtIOBalloonPCI *dev = VIRTIO_BALLOON_PCI(obj);
1771
1772     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1773                                 TYPE_VIRTIO_BALLOON);
1774     object_property_add_alias(obj, "guest-stats", OBJECT(&dev->vdev),
1775                                   "guest-stats", &error_abort);
1776     object_property_add_alias(obj, "guest-stats-polling-interval",
1777                               OBJECT(&dev->vdev),
1778                               "guest-stats-polling-interval", &error_abort);
1779 }
1780
1781 static const TypeInfo virtio_balloon_pci_info = {
1782     .name          = TYPE_VIRTIO_BALLOON_PCI,
1783     .parent        = TYPE_VIRTIO_PCI,
1784     .instance_size = sizeof(VirtIOBalloonPCI),
1785     .instance_init = virtio_balloon_pci_instance_init,
1786     .class_init    = virtio_balloon_pci_class_init,
1787 };
1788
1789 /* virtio-serial-pci */
1790
1791 static void virtio_serial_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1792 {
1793     VirtIOSerialPCI *dev = VIRTIO_SERIAL_PCI(vpci_dev);
1794     DeviceState *vdev = DEVICE(&dev->vdev);
1795     DeviceState *proxy = DEVICE(vpci_dev);
1796     char *bus_name;
1797
1798     if (vpci_dev->class_code != PCI_CLASS_COMMUNICATION_OTHER &&
1799         vpci_dev->class_code != PCI_CLASS_DISPLAY_OTHER && /* qemu 0.10 */
1800         vpci_dev->class_code != PCI_CLASS_OTHERS) {        /* qemu-kvm  */
1801             vpci_dev->class_code = PCI_CLASS_COMMUNICATION_OTHER;
1802     }
1803
1804     /* backwards-compatibility with machines that were created with
1805        DEV_NVECTORS_UNSPECIFIED */
1806     if (vpci_dev->nvectors == DEV_NVECTORS_UNSPECIFIED) {
1807         vpci_dev->nvectors = dev->vdev.serial.max_virtserial_ports + 1;
1808     }
1809
1810     /*
1811      * For command line compatibility, this sets the virtio-serial-device bus
1812      * name as before.
1813      */
1814     if (proxy->id) {
1815         bus_name = g_strdup_printf("%s.0", proxy->id);
1816         virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name);
1817         g_free(bus_name);
1818     }
1819
1820     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1821     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1822 }
1823
1824 static Property virtio_serial_pci_properties[] = {
1825     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1826                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
1827     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
1828     DEFINE_PROP_UINT32("class", VirtIOPCIProxy, class_code, 0),
1829     DEFINE_PROP_END_OF_LIST(),
1830 };
1831
1832 static void virtio_serial_pci_class_init(ObjectClass *klass, void *data)
1833 {
1834     DeviceClass *dc = DEVICE_CLASS(klass);
1835     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1836     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1837     k->realize = virtio_serial_pci_realize;
1838     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
1839     dc->props = virtio_serial_pci_properties;
1840     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1841     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE;
1842     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1843     pcidev_k->class_id = PCI_CLASS_COMMUNICATION_OTHER;
1844 }
1845
1846 static void virtio_serial_pci_instance_init(Object *obj)
1847 {
1848     VirtIOSerialPCI *dev = VIRTIO_SERIAL_PCI(obj);
1849
1850     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1851                                 TYPE_VIRTIO_SERIAL);
1852 }
1853
1854 static const TypeInfo virtio_serial_pci_info = {
1855     .name          = TYPE_VIRTIO_SERIAL_PCI,
1856     .parent        = TYPE_VIRTIO_PCI,
1857     .instance_size = sizeof(VirtIOSerialPCI),
1858     .instance_init = virtio_serial_pci_instance_init,
1859     .class_init    = virtio_serial_pci_class_init,
1860 };
1861
1862 /* virtio-net-pci */
1863
1864 static Property virtio_net_properties[] = {
1865     DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
1866                     VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
1867     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
1868     DEFINE_PROP_END_OF_LIST(),
1869 };
1870
1871 static void virtio_net_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1872 {
1873     DeviceState *qdev = DEVICE(vpci_dev);
1874     VirtIONetPCI *dev = VIRTIO_NET_PCI(vpci_dev);
1875     DeviceState *vdev = DEVICE(&dev->vdev);
1876
1877     virtio_net_set_netclient_name(&dev->vdev, qdev->id,
1878                                   object_get_typename(OBJECT(qdev)));
1879     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1880     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1881 }
1882
1883 static void virtio_net_pci_class_init(ObjectClass *klass, void *data)
1884 {
1885     DeviceClass *dc = DEVICE_CLASS(klass);
1886     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
1887     VirtioPCIClass *vpciklass = VIRTIO_PCI_CLASS(klass);
1888
1889     k->romfile = "efi-virtio.rom";
1890     k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1891     k->device_id = PCI_DEVICE_ID_VIRTIO_NET;
1892     k->revision = VIRTIO_PCI_ABI_VERSION;
1893     k->class_id = PCI_CLASS_NETWORK_ETHERNET;
1894     set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
1895     dc->props = virtio_net_properties;
1896     vpciklass->realize = virtio_net_pci_realize;
1897 }
1898
1899 static void virtio_net_pci_instance_init(Object *obj)
1900 {
1901     VirtIONetPCI *dev = VIRTIO_NET_PCI(obj);
1902
1903     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1904                                 TYPE_VIRTIO_NET);
1905     object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev),
1906                               "bootindex", &error_abort);
1907 }
1908
1909 static const TypeInfo virtio_net_pci_info = {
1910     .name          = TYPE_VIRTIO_NET_PCI,
1911     .parent        = TYPE_VIRTIO_PCI,
1912     .instance_size = sizeof(VirtIONetPCI),
1913     .instance_init = virtio_net_pci_instance_init,
1914     .class_init    = virtio_net_pci_class_init,
1915 };
1916
1917 /* virtio-rng-pci */
1918
1919 static Property virtio_rng_pci_properties[] = {
1920     DEFINE_PROP_END_OF_LIST(),
1921 };
1922
1923 static void virtio_rng_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1924 {
1925     VirtIORngPCI *vrng = VIRTIO_RNG_PCI(vpci_dev);
1926     DeviceState *vdev = DEVICE(&vrng->vdev);
1927     Error *err = NULL;
1928
1929     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1930     object_property_set_bool(OBJECT(vdev), true, "realized", &err);
1931     if (err) {
1932         error_propagate(errp, err);
1933         return;
1934     }
1935
1936     object_property_set_link(OBJECT(vrng),
1937                              OBJECT(vrng->vdev.conf.rng), "rng",
1938                              NULL);
1939 }
1940
1941 static void virtio_rng_pci_class_init(ObjectClass *klass, void *data)
1942 {
1943     DeviceClass *dc = DEVICE_CLASS(klass);
1944     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1945     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1946
1947     k->realize = virtio_rng_pci_realize;
1948     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
1949     dc->props = virtio_rng_pci_properties;
1950
1951     pcidev_k->vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET;
1952     pcidev_k->device_id = PCI_DEVICE_ID_VIRTIO_RNG;
1953     pcidev_k->revision = VIRTIO_PCI_ABI_VERSION;
1954     pcidev_k->class_id = PCI_CLASS_OTHERS;
1955 }
1956
1957 static void virtio_rng_initfn(Object *obj)
1958 {
1959     VirtIORngPCI *dev = VIRTIO_RNG_PCI(obj);
1960
1961     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
1962                                 TYPE_VIRTIO_RNG);
1963     object_property_add_alias(obj, "rng", OBJECT(&dev->vdev), "rng",
1964                               &error_abort);
1965 }
1966
1967 static const TypeInfo virtio_rng_pci_info = {
1968     .name          = TYPE_VIRTIO_RNG_PCI,
1969     .parent        = TYPE_VIRTIO_PCI,
1970     .instance_size = sizeof(VirtIORngPCI),
1971     .instance_init = virtio_rng_initfn,
1972     .class_init    = virtio_rng_pci_class_init,
1973 };
1974
1975 /* virtio-input-pci */
1976
1977 static Property virtio_input_pci_properties[] = {
1978     DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
1979     DEFINE_PROP_END_OF_LIST(),
1980 };
1981
1982 static void virtio_input_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp)
1983 {
1984     VirtIOInputPCI *vinput = VIRTIO_INPUT_PCI(vpci_dev);
1985     DeviceState *vdev = DEVICE(&vinput->vdev);
1986
1987     qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
1988     /* force virtio-1.0 */
1989     vpci_dev->flags &= ~VIRTIO_PCI_FLAG_DISABLE_MODERN;
1990     vpci_dev->flags |= VIRTIO_PCI_FLAG_DISABLE_LEGACY;
1991     object_property_set_bool(OBJECT(vdev), true, "realized", errp);
1992 }
1993
1994 static void virtio_input_pci_class_init(ObjectClass *klass, void *data)
1995 {
1996     DeviceClass *dc = DEVICE_CLASS(klass);
1997     VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass);
1998     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
1999
2000     dc->props = virtio_input_pci_properties;
2001     k->realize = virtio_input_pci_realize;
2002     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
2003
2004     pcidev_k->class_id = PCI_CLASS_INPUT_OTHER;
2005 }
2006
2007 static void virtio_input_hid_kbd_pci_class_init(ObjectClass *klass, void *data)
2008 {
2009     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2010
2011     pcidev_k->class_id = PCI_CLASS_INPUT_KEYBOARD;
2012 }
2013
2014 static void virtio_input_hid_mouse_pci_class_init(ObjectClass *klass,
2015                                                   void *data)
2016 {
2017     PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass);
2018
2019     pcidev_k->class_id = PCI_CLASS_INPUT_MOUSE;
2020 }
2021
2022 static void virtio_keyboard_initfn(Object *obj)
2023 {
2024     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2025
2026     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2027                                 TYPE_VIRTIO_KEYBOARD);
2028 }
2029
2030 static void virtio_mouse_initfn(Object *obj)
2031 {
2032     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2033
2034     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2035                                 TYPE_VIRTIO_MOUSE);
2036 }
2037
2038 static void virtio_tablet_initfn(Object *obj)
2039 {
2040     VirtIOInputHIDPCI *dev = VIRTIO_INPUT_HID_PCI(obj);
2041
2042     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2043                                 TYPE_VIRTIO_TABLET);
2044 }
2045
2046 static void virtio_host_initfn(Object *obj)
2047 {
2048     VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(obj);
2049
2050     virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
2051                                 TYPE_VIRTIO_INPUT_HOST);
2052 }
2053
2054 static const TypeInfo virtio_input_pci_info = {
2055     .name          = TYPE_VIRTIO_INPUT_PCI,
2056     .parent        = TYPE_VIRTIO_PCI,
2057     .instance_size = sizeof(VirtIOInputPCI),
2058     .class_init    = virtio_input_pci_class_init,
2059     .abstract      = true,
2060 };
2061
2062 static const TypeInfo virtio_input_hid_pci_info = {
2063     .name          = TYPE_VIRTIO_INPUT_HID_PCI,
2064     .parent        = TYPE_VIRTIO_INPUT_PCI,
2065     .instance_size = sizeof(VirtIOInputHIDPCI),
2066     .abstract      = true,
2067 };
2068
2069 static const TypeInfo virtio_keyboard_pci_info = {
2070     .name          = TYPE_VIRTIO_KEYBOARD_PCI,
2071     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2072     .class_init    = virtio_input_hid_kbd_pci_class_init,
2073     .instance_size = sizeof(VirtIOInputHIDPCI),
2074     .instance_init = virtio_keyboard_initfn,
2075 };
2076
2077 static const TypeInfo virtio_mouse_pci_info = {
2078     .name          = TYPE_VIRTIO_MOUSE_PCI,
2079     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2080     .class_init    = virtio_input_hid_mouse_pci_class_init,
2081     .instance_size = sizeof(VirtIOInputHIDPCI),
2082     .instance_init = virtio_mouse_initfn,
2083 };
2084
2085 static const TypeInfo virtio_tablet_pci_info = {
2086     .name          = TYPE_VIRTIO_TABLET_PCI,
2087     .parent        = TYPE_VIRTIO_INPUT_HID_PCI,
2088     .instance_size = sizeof(VirtIOInputHIDPCI),
2089     .instance_init = virtio_tablet_initfn,
2090 };
2091
2092 static const TypeInfo virtio_host_pci_info = {
2093     .name          = TYPE_VIRTIO_INPUT_HOST_PCI,
2094     .parent        = TYPE_VIRTIO_INPUT_PCI,
2095     .instance_size = sizeof(VirtIOInputHostPCI),
2096     .instance_init = virtio_host_initfn,
2097 };
2098
2099 /* virtio-pci-bus */
2100
2101 static void virtio_pci_bus_new(VirtioBusState *bus, size_t bus_size,
2102                                VirtIOPCIProxy *dev)
2103 {
2104     DeviceState *qdev = DEVICE(dev);
2105     char virtio_bus_name[] = "virtio-bus";
2106
2107     qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_PCI_BUS, qdev,
2108                         virtio_bus_name);
2109 }
2110
2111 static void virtio_pci_bus_class_init(ObjectClass *klass, void *data)
2112 {
2113     BusClass *bus_class = BUS_CLASS(klass);
2114     VirtioBusClass *k = VIRTIO_BUS_CLASS(klass);
2115     bus_class->max_dev = 1;
2116     k->notify = virtio_pci_notify;
2117     k->save_config = virtio_pci_save_config;
2118     k->load_config = virtio_pci_load_config;
2119     k->save_queue = virtio_pci_save_queue;
2120     k->load_queue = virtio_pci_load_queue;
2121     k->query_guest_notifiers = virtio_pci_query_guest_notifiers;
2122     k->set_host_notifier = virtio_pci_set_host_notifier;
2123     k->set_guest_notifiers = virtio_pci_set_guest_notifiers;
2124     k->vmstate_change = virtio_pci_vmstate_change;
2125     k->device_plugged = virtio_pci_device_plugged;
2126     k->device_unplugged = virtio_pci_device_unplugged;
2127     k->query_nvectors = virtio_pci_query_nvectors;
2128 }
2129
2130 static const TypeInfo virtio_pci_bus_info = {
2131     .name          = TYPE_VIRTIO_PCI_BUS,
2132     .parent        = TYPE_VIRTIO_BUS,
2133     .instance_size = sizeof(VirtioPCIBusState),
2134     .class_init    = virtio_pci_bus_class_init,
2135 };
2136
2137 static void virtio_pci_register_types(void)
2138 {
2139     type_register_static(&virtio_rng_pci_info);
2140     type_register_static(&virtio_input_pci_info);
2141     type_register_static(&virtio_input_hid_pci_info);
2142     type_register_static(&virtio_keyboard_pci_info);
2143     type_register_static(&virtio_mouse_pci_info);
2144     type_register_static(&virtio_tablet_pci_info);
2145     type_register_static(&virtio_host_pci_info);
2146     type_register_static(&virtio_pci_bus_info);
2147     type_register_static(&virtio_pci_info);
2148 #ifdef CONFIG_VIRTFS
2149     type_register_static(&virtio_9p_pci_info);
2150 #endif
2151     type_register_static(&virtio_blk_pci_info);
2152     type_register_static(&virtio_scsi_pci_info);
2153     type_register_static(&virtio_balloon_pci_info);
2154     type_register_static(&virtio_serial_pci_info);
2155     type_register_static(&virtio_net_pci_info);
2156 #ifdef CONFIG_VHOST_SCSI
2157     type_register_static(&vhost_scsi_pci_info);
2158 #endif
2159 }
2160
2161 type_init(virtio_pci_register_types)