hw/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  */
  15
  16 #include <inttypes.h>
  17
  18 #include "virtio.h"
  19 #include "virtio-blk.h"
  20 #include "virtio-net.h"
  21 #include "virtio-serial.h"
  22 #include "pci.h"
  23 #include "qemu-error.h"
  24 #include "msix.h"
  25 #include "net.h"
  26 #include "loader.h"
  27 #include "kvm.h"
  28 #include "blockdev.h"
  29 #include "virtio-pci.h"
  30 #include "range.h"
  31
  32 /* from Linux's linux/virtio_pci.h */
  33
  34 /* A 32-bit r/o bitmask of the features supported by the host */
  35 #define VIRTIO_PCI_HOST_FEATURES        0
  36
  37 /* A 32-bit r/w bitmask of features activated by the guest */
  38 #define VIRTIO_PCI_GUEST_FEATURES       4
  39
  40 /* A 32-bit r/w PFN for the currently selected queue */
  41 #define VIRTIO_PCI_QUEUE_PFN            8
  42
  43 /* A 16-bit r/o queue size for the currently selected queue */
  44 #define VIRTIO_PCI_QUEUE_NUM            12
  45
  46 /* A 16-bit r/w queue selector */
  47 #define VIRTIO_PCI_QUEUE_SEL            14
  48
  49 /* A 16-bit r/w queue notifier */
  50 #define VIRTIO_PCI_QUEUE_NOTIFY         16
  51
  52 /* An 8-bit device status register.  */
  53 #define VIRTIO_PCI_STATUS               18
  54
  55 /* An 8-bit r/o interrupt status register.  Reading the value will return the
  56  * current contents of the ISR and will also clear it.  This is effectively
  57  * a read-and-acknowledge. */
  58 #define VIRTIO_PCI_ISR                  19
  59
  60 /* MSI-X registers: only enabled if MSI-X is enabled. */
  61 /* A 16-bit vector for configuration changes. */
  62 #define VIRTIO_MSI_CONFIG_VECTOR        20
  63 /* A 16-bit vector for selected queue notifications. */
  64 #define VIRTIO_MSI_QUEUE_VECTOR         22
  65
  66 /* Config space size */
  67 #define VIRTIO_PCI_CONFIG_NOMSI         20
  68 #define VIRTIO_PCI_CONFIG_MSI           24
  69 #define VIRTIO_PCI_REGION_SIZE(dev)     (msix_present(dev) ? \
  70                                          VIRTIO_PCI_CONFIG_MSI : \
  71                                          VIRTIO_PCI_CONFIG_NOMSI)
  72
  73 /* The remaining space is defined by each driver as the per-driver
  74  * configuration space */
  75 #define VIRTIO_PCI_CONFIG(dev)          (msix_enabled(dev) ? \
  76                                          VIRTIO_PCI_CONFIG_MSI : \
  77                                          VIRTIO_PCI_CONFIG_NOMSI)
  78
  79 /* How many bits to shift physical queue address written to QUEUE_PFN.
  80  * 12 is historical, and due to x86 page size. */
  81 #define VIRTIO_PCI_QUEUE_ADDR_SHIFT    12
  82
  83 /* Flags track per-device state like workarounds for quirks in older guests. */
  84 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG  (1 << 0)
  85
  86 /* QEMU doesn't strictly need write barriers since everything runs in
  87  * lock-step.  We'll leave the calls to wmb() in though to make it obvious for
  88  * KVM or if kqemu gets SMP support.
  89  */
  90 #define wmb() do { } while (0)
  91
  92 /* virtio device */
  93
  94 static void virtio_pci_notify(void *opaque, uint16_t vector)
  95 {
  96     VirtIOPCIProxy *proxy = opaque;
  97     if (msix_enabled(&proxy->pci_dev))
  98         msix_notify(&proxy->pci_dev, vector);
  99     else
 100         qemu_set_irq(proxy->pci_dev.irq[0], proxy->vdev->isr & 1);
 101 }
 102
 103 static void virtio_pci_save_config(void * opaque, QEMUFile *f)
 104 {
 105     VirtIOPCIProxy *proxy = opaque;
 106     pci_device_save(&proxy->pci_dev, f);
 107     msix_save(&proxy->pci_dev, f);
 108     if (msix_present(&proxy->pci_dev))
 109         qemu_put_be16(f, proxy->vdev->config_vector);
 110 }
 111
 112 static void virtio_pci_save_queue(void * opaque, int n, QEMUFile *f)
 113 {
 114     VirtIOPCIProxy *proxy = opaque;
 115     if (msix_present(&proxy->pci_dev))
 116         qemu_put_be16(f, virtio_queue_vector(proxy->vdev, n));
 117 }
 118
 119 static int virtio_pci_load_config(void * opaque, QEMUFile *f)
 120 {
 121     VirtIOPCIProxy *proxy = opaque;
 122     int ret;
 123     ret = pci_device_load(&proxy->pci_dev, f);
 124     if (ret) {
 125         return ret;
 126     }
 127     msix_load(&proxy->pci_dev, f);
 128     if (msix_present(&proxy->pci_dev)) {
 129         qemu_get_be16s(f, &proxy->vdev->config_vector);
 130     } else {
 131         proxy->vdev->config_vector = VIRTIO_NO_VECTOR;
 132     }
 133     if (proxy->vdev->config_vector != VIRTIO_NO_VECTOR) {
 134         return msix_vector_use(&proxy->pci_dev, proxy->vdev->config_vector);
 135     }
 136     return 0;
 137 }
 138
 139 static int virtio_pci_load_queue(void * opaque, int n, QEMUFile *f)
 140 {
 141     VirtIOPCIProxy *proxy = opaque;
 142     uint16_t vector;
 143     if (msix_present(&proxy->pci_dev)) {
 144         qemu_get_be16s(f, &vector);
 145     } else {
 146         vector = VIRTIO_NO_VECTOR;
 147     }
 148     virtio_queue_set_vector(proxy->vdev, n, vector);
 149     if (vector != VIRTIO_NO_VECTOR) {
 150         return msix_vector_use(&proxy->pci_dev, vector);
 151     }
 152     return 0;
 153 }
 154
 155 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy,
 156                                                  int n, bool assign)
 157 {
 158     VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
 159     EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
 160     int r = 0;
 161
 162     if (assign) {
 163         r = event_notifier_init(notifier, 1);
 164         if (r < 0) {
 165             error_report("%s: unable to init event notifier: %d",
 166                          __func__, r);
 167             return r;
 168         }
 169         memory_region_add_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
 170                                   true, n, event_notifier_get_fd(notifier));
 171     } else {
 172         memory_region_del_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
 173                                   true, n, event_notifier_get_fd(notifier));
 174         /* Handle the race condition where the guest kicked and we deassigned
 175          * before we got around to handling the kick.
 176          */
 177         if (event_notifier_test_and_clear(notifier)) {
 178             virtio_queue_notify_vq(vq);
 179         }
 180
 181         event_notifier_cleanup(notifier);
 182     }
 183     return r;
 184 }
 185
 186 static void virtio_pci_host_notifier_read(void *opaque)
 187 {
 188     VirtQueue *vq = opaque;
 189     EventNotifier *n = virtio_queue_get_host_notifier(vq);
 190     if (event_notifier_test_and_clear(n)) {
 191         virtio_queue_notify_vq(vq);
 192     }
 193 }
 194
 195 static void virtio_pci_set_host_notifier_fd_handler(VirtIOPCIProxy *proxy,
 196                                                     int n, bool assign)
 197 {
 198     VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
 199     EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
 200     if (assign) {
 201         qemu_set_fd_handler(event_notifier_get_fd(notifier),
 202                             virtio_pci_host_notifier_read, NULL, vq);
 203     } else {
 204         qemu_set_fd_handler(event_notifier_get_fd(notifier),
 205                             NULL, NULL, NULL);
 206     }
 207 }
 208
 209 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy)
 210 {
 211     int n, r;
 212
 213     if (!(proxy->flags & VIRTIO_PCI_FLAG_USE_IOEVENTFD) ||
 214         proxy->ioeventfd_disabled ||
 215         proxy->ioeventfd_started) {
 216         return;
 217     }
 218
 219     for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
 220         if (!virtio_queue_get_num(proxy->vdev, n)) {
 221             continue;
 222         }
 223
 224         r = virtio_pci_set_host_notifier_internal(proxy, n, true);
 225         if (r < 0) {
 226             goto assign_error;
 227         }
 228
 229         virtio_pci_set_host_notifier_fd_handler(proxy, n, true);
 230     }
 231     proxy->ioeventfd_started = true;
 232     return;
 233
 234 assign_error:
 235     while (--n >= 0) {
 236         if (!virtio_queue_get_num(proxy->vdev, n)) {
 237             continue;
 238         }
 239
 240         virtio_pci_set_host_notifier_fd_handler(proxy, n, false);
 241         r = virtio_pci_set_host_notifier_internal(proxy, n, false);
 242         assert(r >= 0);
 243     }
 244     proxy->ioeventfd_started = false;
 245     error_report("%s: failed. Fallback to a userspace (slower).", __func__);
 246 }
 247
 248 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy)
 249 {
 250     int r;
 251     int n;
 252
 253     if (!proxy->ioeventfd_started) {
 254         return;
 255     }
 256
 257     for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
 258         if (!virtio_queue_get_num(proxy->vdev, n)) {
 259             continue;
 260         }
 261
 262         virtio_pci_set_host_notifier_fd_handler(proxy, n, false);
 263         r = virtio_pci_set_host_notifier_internal(proxy, n, false);
 264         assert(r >= 0);
 265     }
 266     proxy->ioeventfd_started = false;
 267 }
 268
 269 void virtio_pci_reset(DeviceState *d)
 270 {
 271     VirtIOPCIProxy *proxy = container_of(d, VirtIOPCIProxy, pci_dev.qdev);
 272     virtio_pci_stop_ioeventfd(proxy);
 273     virtio_reset(proxy->vdev);
 274     msix_reset(&proxy->pci_dev);
 275     proxy->flags &= ~VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
 276 }
 277
 278 static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 279 {
 280     VirtIOPCIProxy *proxy = opaque;
 281     VirtIODevice *vdev = proxy->vdev;
 282     target_phys_addr_t pa;
 283
 284     switch (addr) {
 285     case VIRTIO_PCI_GUEST_FEATURES:
 286         /* Guest does not negotiate properly?  We have to assume nothing. */
 287         if (val & (1 << VIRTIO_F_BAD_FEATURE)) {
 288             val = vdev->bad_features ? vdev->bad_features(vdev) : 0;
 289         }
 290         virtio_set_features(vdev, val);
 291         break;
 292     case VIRTIO_PCI_QUEUE_PFN:
 293         pa = (target_phys_addr_t)val << VIRTIO_PCI_QUEUE_ADDR_SHIFT;
 294         if (pa == 0) {
 295             virtio_pci_stop_ioeventfd(proxy);
 296             virtio_reset(proxy->vdev);
 297             msix_unuse_all_vectors(&proxy->pci_dev);
 298         }
 299         else
 300             virtio_queue_set_addr(vdev, vdev->queue_sel, pa);
 301         break;
 302     case VIRTIO_PCI_QUEUE_SEL:
 303         if (val < VIRTIO_PCI_QUEUE_MAX)
 304             vdev->queue_sel = val;
 305         break;
 306     case VIRTIO_PCI_QUEUE_NOTIFY:
 307         if (val < VIRTIO_PCI_QUEUE_MAX) {
 308             virtio_queue_notify(vdev, val);
 309         }
 310         break;
 311     case VIRTIO_PCI_STATUS:
 312         if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) {
 313             virtio_pci_stop_ioeventfd(proxy);
 314         }
 315
 316         virtio_set_status(vdev, val & 0xFF);
 317
 318         if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
 319             virtio_pci_start_ioeventfd(proxy);
 320         }
 321
 322         if (vdev->status == 0) {
 323             virtio_reset(proxy->vdev);
 324             msix_unuse_all_vectors(&proxy->pci_dev);
 325         }
 326
 327         /* Linux before 2.6.34 sets the device as OK without enabling
 328            the PCI device bus master bit. In this case we need to disable
 329            some safety checks. */
 330         if ((val & VIRTIO_CONFIG_S_DRIVER_OK) &&
 331             !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
 332             proxy->flags |= VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
 333         }
 334         break;
 335     case VIRTIO_MSI_CONFIG_VECTOR:
 336         msix_vector_unuse(&proxy->pci_dev, vdev->config_vector);
 337         /* Make it possible for guest to discover an error took place. */
 338         if (msix_vector_use(&proxy->pci_dev, val) < 0)
 339             val = VIRTIO_NO_VECTOR;
 340         vdev->config_vector = val;
 341         break;
 342     case VIRTIO_MSI_QUEUE_VECTOR:
 343         msix_vector_unuse(&proxy->pci_dev,
 344                           virtio_queue_vector(vdev, vdev->queue_sel));
 345         /* Make it possible for guest to discover an error took place. */
 346         if (msix_vector_use(&proxy->pci_dev, val) < 0)
 347             val = VIRTIO_NO_VECTOR;
 348         virtio_queue_set_vector(vdev, vdev->queue_sel, val);
 349         break;
 350     default:
 351         error_report("%s: unexpected address 0x%x value 0x%x",
 352                      __func__, addr, val);
 353         break;
 354     }
 355 }
 356
 357 static uint32_t virtio_ioport_read(VirtIOPCIProxy *proxy, uint32_t addr)
 358 {
 359     VirtIODevice *vdev = proxy->vdev;
 360     uint32_t ret = 0xFFFFFFFF;
 361
 362     switch (addr) {
 363     case VIRTIO_PCI_HOST_FEATURES:
 364         ret = proxy->host_features;
 365         break;
 366     case VIRTIO_PCI_GUEST_FEATURES:
 367         ret = vdev->guest_features;
 368         break;
 369     case VIRTIO_PCI_QUEUE_PFN:
 370         ret = virtio_queue_get_addr(vdev, vdev->queue_sel)
 371               >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
 372         break;
 373     case VIRTIO_PCI_QUEUE_NUM:
 374         ret = virtio_queue_get_num(vdev, vdev->queue_sel);
 375         break;
 376     case VIRTIO_PCI_QUEUE_SEL:
 377         ret = vdev->queue_sel;
 378         break;
 379     case VIRTIO_PCI_STATUS:
 380         ret = vdev->status;
 381         break;
 382     case VIRTIO_PCI_ISR:
 383         /* reading from the ISR also clears it. */
 384         ret = vdev->isr;
 385         vdev->isr = 0;
 386         qemu_set_irq(proxy->pci_dev.irq[0], 0);
 387         break;
 388     case VIRTIO_MSI_CONFIG_VECTOR:
 389         ret = vdev->config_vector;
 390         break;
 391     case VIRTIO_MSI_QUEUE_VECTOR:
 392         ret = virtio_queue_vector(vdev, vdev->queue_sel);
 393         break;
 394     default:
 395         break;
 396     }
 397
 398     return ret;
 399 }
 400
 401 static uint32_t virtio_pci_config_readb(void *opaque, uint32_t addr)
 402 {
 403     VirtIOPCIProxy *proxy = opaque;
 404     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
 405     if (addr < config)
 406         return virtio_ioport_read(proxy, addr);
 407     addr -= config;
 408     return virtio_config_readb(proxy->vdev, addr);
 409 }
 410
 411 static uint32_t virtio_pci_config_readw(void *opaque, uint32_t addr)
 412 {
 413     VirtIOPCIProxy *proxy = opaque;
 414     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
 415     if (addr < config)
 416         return virtio_ioport_read(proxy, addr);
 417     addr -= config;
 418     return virtio_config_readw(proxy->vdev, addr);
 419 }
 420
 421 static uint32_t virtio_pci_config_readl(void *opaque, uint32_t addr)
 422 {
 423     VirtIOPCIProxy *proxy = opaque;
 424     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
 425     if (addr < config)
 426         return virtio_ioport_read(proxy, addr);
 427     addr -= config;
 428     return virtio_config_readl(proxy->vdev, addr);
 429 }
 430
 431 static void virtio_pci_config_writeb(void *opaque, uint32_t addr, uint32_t val)
 432 {
 433     VirtIOPCIProxy *proxy = opaque;
 434     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
 435     if (addr < config) {
 436         virtio_ioport_write(proxy, addr, val);
 437         return;
 438     }
 439     addr -= config;
 440     virtio_config_writeb(proxy->vdev, addr, val);
 441 }
 442
 443 static void virtio_pci_config_writew(void *opaque, uint32_t addr, uint32_t val)
 444 {
 445     VirtIOPCIProxy *proxy = opaque;
 446     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
 447     if (addr < config) {
 448         virtio_ioport_write(proxy, addr, val);
 449         return;
 450     }
 451     addr -= config;
 452     virtio_config_writew(proxy->vdev, addr, val);
 453 }
 454
 455 static void virtio_pci_config_writel(void *opaque, uint32_t addr, uint32_t val)
 456 {
 457     VirtIOPCIProxy *proxy = opaque;
 458     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
 459     if (addr < config) {
 460         virtio_ioport_write(proxy, addr, val);
 461         return;
 462     }
 463     addr -= config;
 464     virtio_config_writel(proxy->vdev, addr, val);
 465 }
 466
 467 const MemoryRegionPortio virtio_portio[] = {
 468     { 0, 0x10000, 1, .write = virtio_pci_config_writeb, },
 469     { 0, 0x10000, 2, .write = virtio_pci_config_writew, },
 470     { 0, 0x10000, 4, .write = virtio_pci_config_writel, },
 471     { 0, 0x10000, 1, .read = virtio_pci_config_readb, },
 472     { 0, 0x10000, 2, .read = virtio_pci_config_readw, },
 473     { 0, 0x10000, 4, .read = virtio_pci_config_readl, },
 474     PORTIO_END_OF_LIST()
 475 };
 476
 477 static const MemoryRegionOps virtio_pci_config_ops = {
 478     .old_portio = virtio_portio,
 479     .endianness = DEVICE_LITTLE_ENDIAN,
 480 };
 481
 482 static void virtio_write_config(PCIDevice *pci_dev, uint32_t address,
 483                                 uint32_t val, int len)
 484 {
 485     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 486
 487     pci_default_write_config(pci_dev, address, val, len);
 488
 489     if (range_covers_byte(address, len, PCI_COMMAND) &&
 490         !(pci_dev->config[PCI_COMMAND] & PCI_COMMAND_MASTER) &&
 491         !(proxy->flags & VIRTIO_PCI_FLAG_BUS_MASTER_BUG)) {
 492         virtio_pci_stop_ioeventfd(proxy);
 493         virtio_set_status(proxy->vdev,
 494                           proxy->vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK);
 495     }
 496
 497     msix_write_config(pci_dev, address, val, len);
 498 }
 499
 500 static unsigned virtio_pci_get_features(void *opaque)
 501 {
 502     VirtIOPCIProxy *proxy = opaque;
 503     return proxy->host_features;
 504 }
 505
 506 static void virtio_pci_guest_notifier_read(void *opaque)
 507 {
 508     VirtQueue *vq = opaque;
 509     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
 510     if (event_notifier_test_and_clear(n)) {
 511         virtio_irq(vq);
 512     }
 513 }
 514
 515 static int virtio_pci_set_guest_notifier(void *opaque, int n, bool assign)
 516 {
 517     VirtIOPCIProxy *proxy = opaque;
 518     VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
 519     EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
 520
 521     if (assign) {
 522         int r = event_notifier_init(notifier, 0);
 523         if (r < 0) {
 524             return r;
 525         }
 526         qemu_set_fd_handler(event_notifier_get_fd(notifier),
 527                             virtio_pci_guest_notifier_read, NULL, vq);
 528     } else {
 529         qemu_set_fd_handler(event_notifier_get_fd(notifier),
 530                             NULL, NULL, NULL);
 531         event_notifier_cleanup(notifier);
 532     }
 533
 534     return 0;
 535 }
 536
 537 static bool virtio_pci_query_guest_notifiers(void *opaque)
 538 {
 539     VirtIOPCIProxy *proxy = opaque;
 540     return msix_enabled(&proxy->pci_dev);
 541 }
 542
 543 static int virtio_pci_set_guest_notifiers(void *opaque, bool assign)
 544 {
 545     VirtIOPCIProxy *proxy = opaque;
 546     VirtIODevice *vdev = proxy->vdev;
 547     int r, n;
 548
 549     for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
 550         if (!virtio_queue_get_num(vdev, n)) {
 551             break;
 552         }
 553
 554         r = virtio_pci_set_guest_notifier(opaque, n, assign);
 555         if (r < 0) {
 556             goto assign_error;
 557         }
 558     }
 559
 560     return 0;
 561
 562 assign_error:
 563     /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
 564     while (--n >= 0) {
 565         virtio_pci_set_guest_notifier(opaque, n, !assign);
 566     }
 567     return r;
 568 }
 569
 570 static int virtio_pci_set_host_notifier(void *opaque, int n, bool assign)
 571 {
 572     VirtIOPCIProxy *proxy = opaque;
 573
 574     /* Stop using ioeventfd for virtqueue kick if the device starts using host
 575      * notifiers.  This makes it easy to avoid stepping on each others' toes.
 576      */
 577     proxy->ioeventfd_disabled = assign;
 578     if (assign) {
 579         virtio_pci_stop_ioeventfd(proxy);
 580     }
 581     /* We don't need to start here: it's not needed because backend
 582      * currently only stops on status change away from ok,
 583      * reset, vmstop and such. If we do add code to start here,
 584      * need to check vmstate, device state etc. */
 585     return virtio_pci_set_host_notifier_internal(proxy, n, assign);
 586 }
 587
 588 static void virtio_pci_vmstate_change(void *opaque, bool running)
 589 {
 590     VirtIOPCIProxy *proxy = opaque;
 591
 592     if (running) {
 593         /* Try to find out if the guest has bus master disabled, but is
 594            in ready state. Then we have a buggy guest OS. */
 595         if ((proxy->vdev->status & VIRTIO_CONFIG_S_DRIVER_OK) &&
 596             !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
 597             proxy->flags |= VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
 598         }
 599         virtio_pci_start_ioeventfd(proxy);
 600     } else {
 601         virtio_pci_stop_ioeventfd(proxy);
 602     }
 603 }
 604
 605 static const VirtIOBindings virtio_pci_bindings = {
 606     .notify = virtio_pci_notify,
 607     .save_config = virtio_pci_save_config,
 608     .load_config = virtio_pci_load_config,
 609     .save_queue = virtio_pci_save_queue,
 610     .load_queue = virtio_pci_load_queue,
 611     .get_features = virtio_pci_get_features,
 612     .query_guest_notifiers = virtio_pci_query_guest_notifiers,
 613     .set_host_notifier = virtio_pci_set_host_notifier,
 614     .set_guest_notifiers = virtio_pci_set_guest_notifiers,
 615     .vmstate_change = virtio_pci_vmstate_change,
 616 };
 617
 618 void virtio_init_pci(VirtIOPCIProxy *proxy, VirtIODevice *vdev)
 619 {
 620     uint8_t *config;
 621     uint32_t size;
 622
 623     proxy->vdev = vdev;
 624
 625     config = proxy->pci_dev.config;
 626
 627     if (proxy->class_code) {
 628         pci_config_set_class(config, proxy->class_code);
 629     }
 630     pci_set_word(config + PCI_SUBSYSTEM_VENDOR_ID,
 631                  pci_get_word(config + PCI_VENDOR_ID));
 632     pci_set_word(config + PCI_SUBSYSTEM_ID, vdev->device_id);
 633     config[PCI_INTERRUPT_PIN] = 1;
 634
 635     memory_region_init(&proxy->msix_bar, "virtio-msix", 4096);
 636     if (vdev->nvectors && !msix_init(&proxy->pci_dev, vdev->nvectors,
 637                                      &proxy->msix_bar, 1, 0)) {
 638         pci_register_bar(&proxy->pci_dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY,
 639                          &proxy->msix_bar);
 640     } else
 641         vdev->nvectors = 0;
 642
 643     proxy->pci_dev.config_write = virtio_write_config;
 644
 645     size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev) + vdev->config_len;
 646     if (size & (size-1))
 647         size = 1 << qemu_fls(size);
 648
 649     memory_region_init_io(&proxy->bar, &virtio_pci_config_ops, proxy,
 650                           "virtio-pci", size);
 651     pci_register_bar(&proxy->pci_dev, 0, PCI_BASE_ADDRESS_SPACE_IO,
 652                      &proxy->bar);
 653
 654     if (!kvm_has_many_ioeventfds()) {
 655         proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
 656     }
 657
 658     virtio_bind_device(vdev, &virtio_pci_bindings, proxy);
 659     proxy->host_features |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;
 660     proxy->host_features |= 0x1 << VIRTIO_F_BAD_FEATURE;
 661     proxy->host_features = vdev->get_features(vdev, proxy->host_features);
 662 }
 663
 664 static int virtio_blk_init_pci(PCIDevice *pci_dev)
 665 {
 666     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 667     VirtIODevice *vdev;
 668
 669     if (proxy->class_code != PCI_CLASS_STORAGE_SCSI &&
 670         proxy->class_code != PCI_CLASS_STORAGE_OTHER)
 671         proxy->class_code = PCI_CLASS_STORAGE_SCSI;
 672
 673     vdev = virtio_blk_init(&pci_dev->qdev, &proxy->block,
 674                            &proxy->block_serial);
 675     if (!vdev) {
 676         return -1;
 677     }
 678     vdev->nvectors = proxy->nvectors;
 679     virtio_init_pci(proxy, vdev);
 680     /* make the actual value visible */
 681     proxy->nvectors = vdev->nvectors;
 682     return 0;
 683 }
 684
 685 static int virtio_exit_pci(PCIDevice *pci_dev)
 686 {
 687     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 688     int r;
 689
 690     memory_region_destroy(&proxy->bar);
 691     r = msix_uninit(pci_dev, &proxy->msix_bar);
 692     memory_region_destroy(&proxy->msix_bar);
 693     return r;
 694 }
 695
 696 static int virtio_blk_exit_pci(PCIDevice *pci_dev)
 697 {
 698     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 699
 700     virtio_pci_stop_ioeventfd(proxy);
 701     virtio_blk_exit(proxy->vdev);
 702     blockdev_mark_auto_del(proxy->block.bs);
 703     return virtio_exit_pci(pci_dev);
 704 }
 705
 706 static int virtio_serial_init_pci(PCIDevice *pci_dev)
 707 {
 708     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 709     VirtIODevice *vdev;
 710
 711     if (proxy->class_code != PCI_CLASS_COMMUNICATION_OTHER &&
 712         proxy->class_code != PCI_CLASS_DISPLAY_OTHER && /* qemu 0.10 */
 713         proxy->class_code != PCI_CLASS_OTHERS)          /* qemu-kvm  */
 714         proxy->class_code = PCI_CLASS_COMMUNICATION_OTHER;
 715
 716     vdev = virtio_serial_init(&pci_dev->qdev, &proxy->serial);
 717     if (!vdev) {
 718         return -1;
 719     }
 720     vdev->nvectors = proxy->nvectors == DEV_NVECTORS_UNSPECIFIED
 721                                         ? proxy->serial.max_virtserial_ports + 1
 722                                         : proxy->nvectors;
 723     virtio_init_pci(proxy, vdev);
 724     proxy->nvectors = vdev->nvectors;
 725     return 0;
 726 }
 727
 728 static int virtio_serial_exit_pci(PCIDevice *pci_dev)
 729 {
 730     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 731
 732     virtio_pci_stop_ioeventfd(proxy);
 733     virtio_serial_exit(proxy->vdev);
 734     return virtio_exit_pci(pci_dev);
 735 }
 736
 737 static int virtio_net_init_pci(PCIDevice *pci_dev)
 738 {
 739     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 740     VirtIODevice *vdev;
 741
 742     vdev = virtio_net_init(&pci_dev->qdev, &proxy->nic, &proxy->net);
 743
 744     vdev->nvectors = proxy->nvectors;
 745     virtio_init_pci(proxy, vdev);
 746
 747     /* make the actual value visible */
 748     proxy->nvectors = vdev->nvectors;
 749     return 0;
 750 }
 751
 752 static int virtio_net_exit_pci(PCIDevice *pci_dev)
 753 {
 754     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 755
 756     virtio_pci_stop_ioeventfd(proxy);
 757     virtio_net_exit(proxy->vdev);
 758     return virtio_exit_pci(pci_dev);
 759 }
 760
 761 static int virtio_balloon_init_pci(PCIDevice *pci_dev)
 762 {
 763     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 764     VirtIODevice *vdev;
 765
 766     vdev = virtio_balloon_init(&pci_dev->qdev);
 767     if (!vdev) {
 768         return -1;
 769     }
 770     virtio_init_pci(proxy, vdev);
 771     return 0;
 772 }
 773
 774 static int virtio_balloon_exit_pci(PCIDevice *pci_dev)
 775 {
 776     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
 777
 778     virtio_pci_stop_ioeventfd(proxy);
 779     virtio_balloon_exit(proxy->vdev);
 780     return virtio_exit_pci(pci_dev);
 781 }
 782
 783 static PCIDeviceInfo virtio_info[] = {
 784     {
 785         .qdev.name = "virtio-blk-pci",
 786         .qdev.alias = "virtio-blk",
 787         .qdev.size = sizeof(VirtIOPCIProxy),
 788         .init      = virtio_blk_init_pci,
 789         .exit      = virtio_blk_exit_pci,
 790         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
 791         .device_id = PCI_DEVICE_ID_VIRTIO_BLOCK,
 792         .revision  = VIRTIO_PCI_ABI_VERSION,
 793         .class_id  = PCI_CLASS_STORAGE_SCSI,
 794         .qdev.props = (Property[]) {
 795             DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
 796             DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy, block),
 797             DEFINE_PROP_STRING("serial", VirtIOPCIProxy, block_serial),
 798             DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
 799                             VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
 800             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
 801             DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features),
 802             DEFINE_PROP_END_OF_LIST(),
 803         },
 804         .qdev.reset = virtio_pci_reset,
 805     },{
 806         .qdev.name  = "virtio-net-pci",
 807         .qdev.alias = "virtio-net",
 808         .qdev.size  = sizeof(VirtIOPCIProxy),
 809         .init       = virtio_net_init_pci,
 810         .exit       = virtio_net_exit_pci,
 811         .romfile    = "pxe-virtio.rom",
 812         .vendor_id  = PCI_VENDOR_ID_REDHAT_QUMRANET,
 813         .device_id  = PCI_DEVICE_ID_VIRTIO_NET,
 814         .revision   = VIRTIO_PCI_ABI_VERSION,
 815         .class_id   = PCI_CLASS_NETWORK_ETHERNET,
 816         .qdev.props = (Property[]) {
 817             DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
 818                             VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
 819             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
 820             DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy, host_features),
 821             DEFINE_NIC_PROPERTIES(VirtIOPCIProxy, nic),
 822             DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy,
 823                                net.txtimer, TX_TIMER_INTERVAL),
 824             DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy,
 825                               net.txburst, TX_BURST),
 826             DEFINE_PROP_STRING("tx", VirtIOPCIProxy, net.tx),
 827             DEFINE_PROP_END_OF_LIST(),
 828         },
 829         .qdev.reset = virtio_pci_reset,
 830     },{
 831         .qdev.name = "virtio-serial-pci",
 832         .qdev.alias = "virtio-serial",
 833         .qdev.size = sizeof(VirtIOPCIProxy),
 834         .init      = virtio_serial_init_pci,
 835         .exit      = virtio_serial_exit_pci,
 836         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
 837         .device_id = PCI_DEVICE_ID_VIRTIO_CONSOLE,
 838         .revision  = VIRTIO_PCI_ABI_VERSION,
 839         .class_id  = PCI_CLASS_COMMUNICATION_OTHER,
 840         .qdev.props = (Property[]) {
 841             DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
 842                             VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
 843             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
 844                                DEV_NVECTORS_UNSPECIFIED),
 845             DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
 846             DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
 847             DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy,
 848                                serial.max_virtserial_ports, 31),
 849             DEFINE_PROP_END_OF_LIST(),
 850         },
 851         .qdev.reset = virtio_pci_reset,
 852     },{
 853         .qdev.name = "virtio-balloon-pci",
 854         .qdev.alias = "virtio-balloon",
 855         .qdev.size = sizeof(VirtIOPCIProxy),
 856         .init      = virtio_balloon_init_pci,
 857         .exit      = virtio_balloon_exit_pci,
 858         .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET,
 859         .device_id = PCI_DEVICE_ID_VIRTIO_BALLOON,
 860         .revision  = VIRTIO_PCI_ABI_VERSION,
 861         .class_id  = PCI_CLASS_MEMORY_RAM,
 862         .qdev.props = (Property[]) {
 863             DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
 864             DEFINE_PROP_END_OF_LIST(),
 865         },
 866         .qdev.reset = virtio_pci_reset,
 867     },{
 868         /* end of list */
 869     }
 870 };
 871
 872 static void virtio_pci_register_devices(void)
 873 {
 874     pci_qdev_register_many(virtio_info);
 875 }
 876
 877 device_init(virtio_pci_register_devices)