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