accel/kvm/kvm-all.c

   1 /*
   2  * QEMU KVM support
   3  *
   4  * Copyright IBM, Corp. 2008
   5  *           Red Hat, Inc. 2008
   6  *
   7  * Authors:
   8  *  Anthony Liguori   <aliguori@us.ibm.com>
   9  *  Glauber Costa     <gcosta@redhat.com>
  10  *
  11  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  12  * See the COPYING file in the top-level directory.
  13  *
  14  */
  15
  16 #include "qemu/osdep.h"
  17 #include <sys/ioctl.h>
  18 #include <poll.h>
  19
  20 #include <linux/kvm.h>
  21
  22 #include "qemu/atomic.h"
  23 #include "qemu/option.h"
  24 #include "qemu/config-file.h"
  25 #include "qemu/error-report.h"
  26 #include "qapi/error.h"
  27 #include "hw/pci/msi.h"
  28 #include "hw/pci/msix.h"
  29 #include "hw/s390x/adapter.h"
  30 #include "exec/gdbstub.h"
  31 #include "sysemu/kvm_int.h"
  32 #include "sysemu/runstate.h"
  33 #include "sysemu/cpus.h"
  34 #include "sysemu/accel-blocker.h"
  35 #include "qemu/bswap.h"
  36 #include "exec/memory.h"
  37 #include "exec/ram_addr.h"
  38 #include "qemu/event_notifier.h"
  39 #include "qemu/main-loop.h"
  40 #include "trace.h"
  41 #include "hw/irq.h"
  42 #include "qapi/visitor.h"
  43 #include "qapi/qapi-types-common.h"
  44 #include "qapi/qapi-visit-common.h"
  45 #include "sysemu/reset.h"
  46 #include "qemu/guest-random.h"
  47 #include "sysemu/hw_accel.h"
  48 #include "kvm-cpus.h"
  49 #include "sysemu/dirtylimit.h"
  50 #include "qemu/range.h"
  51
  52 #include "hw/boards.h"
  53 #include "sysemu/stats.h"
  54
  55 /* This check must be after config-host.h is included */
  56 #ifdef CONFIG_EVENTFD
  57 #include <sys/eventfd.h>
  58 #endif
  59
  60 /* KVM uses PAGE_SIZE in its definition of KVM_COALESCED_MMIO_MAX. We
  61  * need to use the real host PAGE_SIZE, as that's what KVM will use.
  62  */
  63 #ifdef PAGE_SIZE
  64 #undef PAGE_SIZE
  65 #endif
  66 #define PAGE_SIZE qemu_real_host_page_size()
  67
  68 #ifndef KVM_GUESTDBG_BLOCKIRQ
  69 #define KVM_GUESTDBG_BLOCKIRQ 0
  70 #endif
  71
  72 //#define DEBUG_KVM
  73
  74 #ifdef DEBUG_KVM
  75 #define DPRINTF(fmt, ...) \
  76     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
  77 #else
  78 #define DPRINTF(fmt, ...) \
  79     do { } while (0)
  80 #endif
  81
  82 struct KVMParkedVcpu {
  83     unsigned long vcpu_id;
  84     int kvm_fd;
  85     QLIST_ENTRY(KVMParkedVcpu) node;
  86 };
  87
  88 KVMState *kvm_state;
  89 bool kvm_kernel_irqchip;
  90 bool kvm_split_irqchip;
  91 bool kvm_async_interrupts_allowed;
  92 bool kvm_halt_in_kernel_allowed;
  93 bool kvm_eventfds_allowed;
  94 bool kvm_irqfds_allowed;
  95 bool kvm_resamplefds_allowed;
  96 bool kvm_msi_via_irqfd_allowed;
  97 bool kvm_gsi_routing_allowed;
  98 bool kvm_gsi_direct_mapping;
  99 bool kvm_allowed;
 100 bool kvm_readonly_mem_allowed;
 101 bool kvm_vm_attributes_allowed;
 102 bool kvm_direct_msi_allowed;
 103 bool kvm_ioeventfd_any_length_allowed;
 104 bool kvm_msi_use_devid;
 105 bool kvm_has_guest_debug;
 106 static int kvm_sstep_flags;
 107 static bool kvm_immediate_exit;
 108 static hwaddr kvm_max_slot_size = ~0;
 109
 110 static const KVMCapabilityInfo kvm_required_capabilites[] = {
 111     KVM_CAP_INFO(USER_MEMORY),
 112     KVM_CAP_INFO(DESTROY_MEMORY_REGION_WORKS),
 113     KVM_CAP_INFO(JOIN_MEMORY_REGIONS_WORKS),
 114     KVM_CAP_LAST_INFO
 115 };
 116
 117 static NotifierList kvm_irqchip_change_notifiers =
 118     NOTIFIER_LIST_INITIALIZER(kvm_irqchip_change_notifiers);
 119
 120 struct KVMResampleFd {
 121     int gsi;
 122     EventNotifier *resample_event;
 123     QLIST_ENTRY(KVMResampleFd) node;
 124 };
 125 typedef struct KVMResampleFd KVMResampleFd;
 126
 127 /*
 128  * Only used with split irqchip where we need to do the resample fd
 129  * kick for the kernel from userspace.
 130  */
 131 static QLIST_HEAD(, KVMResampleFd) kvm_resample_fd_list =
 132     QLIST_HEAD_INITIALIZER(kvm_resample_fd_list);
 133
 134 static QemuMutex kml_slots_lock;
 135
 136 #define kvm_slots_lock()    qemu_mutex_lock(&kml_slots_lock)
 137 #define kvm_slots_unlock()  qemu_mutex_unlock(&kml_slots_lock)
 138
 139 static void kvm_slot_init_dirty_bitmap(KVMSlot *mem);
 140
 141 static inline void kvm_resample_fd_remove(int gsi)
 142 {
 143     KVMResampleFd *rfd;
 144
 145     QLIST_FOREACH(rfd, &kvm_resample_fd_list, node) {
 146         if (rfd->gsi == gsi) {
 147             QLIST_REMOVE(rfd, node);
 148             g_free(rfd);
 149             break;
 150         }
 151     }
 152 }
 153
 154 static inline void kvm_resample_fd_insert(int gsi, EventNotifier *event)
 155 {
 156     KVMResampleFd *rfd = g_new0(KVMResampleFd, 1);
 157
 158     rfd->gsi = gsi;
 159     rfd->resample_event = event;
 160
 161     QLIST_INSERT_HEAD(&kvm_resample_fd_list, rfd, node);
 162 }
 163
 164 void kvm_resample_fd_notify(int gsi)
 165 {
 166     KVMResampleFd *rfd;
 167
 168     QLIST_FOREACH(rfd, &kvm_resample_fd_list, node) {
 169         if (rfd->gsi == gsi) {
 170             event_notifier_set(rfd->resample_event);
 171             trace_kvm_resample_fd_notify(gsi);
 172             return;
 173         }
 174     }
 175 }
 176
 177 int kvm_get_max_memslots(void)
 178 {
 179     KVMState *s = KVM_STATE(current_accel());
 180
 181     return s->nr_slots;
 182 }
 183
 184 /* Called with KVMMemoryListener.slots_lock held */
 185 static KVMSlot *kvm_get_free_slot(KVMMemoryListener *kml)
 186 {
 187     KVMState *s = kvm_state;
 188     int i;
 189
 190     for (i = 0; i < s->nr_slots; i++) {
 191         if (kml->slots[i].memory_size == 0) {
 192             return &kml->slots[i];
 193         }
 194     }
 195
 196     return NULL;
 197 }
 198
 199 bool kvm_has_free_slot(MachineState *ms)
 200 {
 201     KVMState *s = KVM_STATE(ms->accelerator);
 202     bool result;
 203     KVMMemoryListener *kml = &s->memory_listener;
 204
 205     kvm_slots_lock();
 206     result = !!kvm_get_free_slot(kml);
 207     kvm_slots_unlock();
 208
 209     return result;
 210 }
 211
 212 /* Called with KVMMemoryListener.slots_lock held */
 213 static KVMSlot *kvm_alloc_slot(KVMMemoryListener *kml)
 214 {
 215     KVMSlot *slot = kvm_get_free_slot(kml);
 216
 217     if (slot) {
 218         return slot;
 219     }
 220
 221     fprintf(stderr, "%s: no free slot available\n", __func__);
 222     abort();
 223 }
 224
 225 static KVMSlot *kvm_lookup_matching_slot(KVMMemoryListener *kml,
 226                                          hwaddr start_addr,
 227                                          hwaddr size)
 228 {
 229     KVMState *s = kvm_state;
 230     int i;
 231
 232     for (i = 0; i < s->nr_slots; i++) {
 233         KVMSlot *mem = &kml->slots[i];
 234
 235         if (start_addr == mem->start_addr && size == mem->memory_size) {
 236             return mem;
 237         }
 238     }
 239
 240     return NULL;
 241 }
 242
 243 /*
 244  * Calculate and align the start address and the size of the section.
 245  * Return the size. If the size is 0, the aligned section is empty.
 246  */
 247 static hwaddr kvm_align_section(MemoryRegionSection *section,
 248                                 hwaddr *start)
 249 {
 250     hwaddr size = int128_get64(section->size);
 251     hwaddr delta, aligned;
 252
 253     /* kvm works in page size chunks, but the function may be called
 254        with sub-page size and unaligned start address. Pad the start
 255        address to next and truncate size to previous page boundary. */
 256     aligned = ROUND_UP(section->offset_within_address_space,
 257                        qemu_real_host_page_size());
 258     delta = aligned - section->offset_within_address_space;
 259     *start = aligned;
 260     if (delta > size) {
 261         return 0;
 262     }
 263
 264     return (size - delta) & qemu_real_host_page_mask();
 265 }
 266
 267 int kvm_physical_memory_addr_from_host(KVMState *s, void *ram,
 268                                        hwaddr *phys_addr)
 269 {
 270     KVMMemoryListener *kml = &s->memory_listener;
 271     int i, ret = 0;
 272
 273     kvm_slots_lock();
 274     for (i = 0; i < s->nr_slots; i++) {
 275         KVMSlot *mem = &kml->slots[i];
 276
 277         if (ram >= mem->ram && ram < mem->ram + mem->memory_size) {
 278             *phys_addr = mem->start_addr + (ram - mem->ram);
 279             ret = 1;
 280             break;
 281         }
 282     }
 283     kvm_slots_unlock();
 284
 285     return ret;
 286 }
 287
 288 static int kvm_set_user_memory_region(KVMMemoryListener *kml, KVMSlot *slot, bool new)
 289 {
 290     KVMState *s = kvm_state;
 291     struct kvm_userspace_memory_region mem;
 292     int ret;
 293
 294     mem.slot = slot->slot | (kml->as_id << 16);
 295     mem.guest_phys_addr = slot->start_addr;
 296     mem.userspace_addr = (unsigned long)slot->ram;
 297     mem.flags = slot->flags;
 298
 299     if (slot->memory_size && !new && (mem.flags ^ slot->old_flags) & KVM_MEM_READONLY) {
 300         /* Set the slot size to 0 before setting the slot to the desired
 301          * value. This is needed based on KVM commit 75d61fbc. */
 302         mem.memory_size = 0;
 303         ret = kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 304         if (ret < 0) {
 305             goto err;
 306         }
 307     }
 308     mem.memory_size = slot->memory_size;
 309     ret = kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 310     slot->old_flags = mem.flags;
 311 err:
 312     trace_kvm_set_user_memory(mem.slot, mem.flags, mem.guest_phys_addr,
 313                               mem.memory_size, mem.userspace_addr, ret);
 314     if (ret < 0) {
 315         error_report("%s: KVM_SET_USER_MEMORY_REGION failed, slot=%d,"
 316                      " start=0x%" PRIx64 ", size=0x%" PRIx64 ": %s",
 317                      __func__, mem.slot, slot->start_addr,
 318                      (uint64_t)mem.memory_size, strerror(errno));
 319     }
 320     return ret;
 321 }
 322
 323 static int do_kvm_destroy_vcpu(CPUState *cpu)
 324 {
 325     KVMState *s = kvm_state;
 326     long mmap_size;
 327     struct KVMParkedVcpu *vcpu = NULL;
 328     int ret = 0;
 329
 330     DPRINTF("kvm_destroy_vcpu\n");
 331
 332     ret = kvm_arch_destroy_vcpu(cpu);
 333     if (ret < 0) {
 334         goto err;
 335     }
 336
 337     mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
 338     if (mmap_size < 0) {
 339         ret = mmap_size;
 340         DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
 341         goto err;
 342     }
 343
 344     ret = munmap(cpu->kvm_run, mmap_size);
 345     if (ret < 0) {
 346         goto err;
 347     }
 348
 349     if (cpu->kvm_dirty_gfns) {
 350         ret = munmap(cpu->kvm_dirty_gfns, s->kvm_dirty_ring_bytes);
 351         if (ret < 0) {
 352             goto err;
 353         }
 354     }
 355
 356     vcpu = g_malloc0(sizeof(*vcpu));
 357     vcpu->vcpu_id = kvm_arch_vcpu_id(cpu);
 358     vcpu->kvm_fd = cpu->kvm_fd;
 359     QLIST_INSERT_HEAD(&kvm_state->kvm_parked_vcpus, vcpu, node);
 360 err:
 361     return ret;
 362 }
 363
 364 void kvm_destroy_vcpu(CPUState *cpu)
 365 {
 366     if (do_kvm_destroy_vcpu(cpu) < 0) {
 367         error_report("kvm_destroy_vcpu failed");
 368         exit(EXIT_FAILURE);
 369     }
 370 }
 371
 372 static int kvm_get_vcpu(KVMState *s, unsigned long vcpu_id)
 373 {
 374     struct KVMParkedVcpu *cpu;
 375
 376     QLIST_FOREACH(cpu, &s->kvm_parked_vcpus, node) {
 377         if (cpu->vcpu_id == vcpu_id) {
 378             int kvm_fd;
 379
 380             QLIST_REMOVE(cpu, node);
 381             kvm_fd = cpu->kvm_fd;
 382             g_free(cpu);
 383             return kvm_fd;
 384         }
 385     }
 386
 387     return kvm_vm_ioctl(s, KVM_CREATE_VCPU, (void *)vcpu_id);
 388 }
 389
 390 int kvm_init_vcpu(CPUState *cpu, Error **errp)
 391 {
 392     KVMState *s = kvm_state;
 393     long mmap_size;
 394     int ret;
 395
 396     trace_kvm_init_vcpu(cpu->cpu_index, kvm_arch_vcpu_id(cpu));
 397
 398     ret = kvm_get_vcpu(s, kvm_arch_vcpu_id(cpu));
 399     if (ret < 0) {
 400         error_setg_errno(errp, -ret, "kvm_init_vcpu: kvm_get_vcpu failed (%lu)",
 401                          kvm_arch_vcpu_id(cpu));
 402         goto err;
 403     }
 404
 405     cpu->kvm_fd = ret;
 406     cpu->kvm_state = s;
 407     cpu->vcpu_dirty = true;
 408     cpu->dirty_pages = 0;
 409     cpu->throttle_us_per_full = 0;
 410
 411     mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
 412     if (mmap_size < 0) {
 413         ret = mmap_size;
 414         error_setg_errno(errp, -mmap_size,
 415                          "kvm_init_vcpu: KVM_GET_VCPU_MMAP_SIZE failed");
 416         goto err;
 417     }
 418
 419     cpu->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
 420                         cpu->kvm_fd, 0);
 421     if (cpu->kvm_run == MAP_FAILED) {
 422         ret = -errno;
 423         error_setg_errno(errp, ret,
 424                          "kvm_init_vcpu: mmap'ing vcpu state failed (%lu)",
 425                          kvm_arch_vcpu_id(cpu));
 426         goto err;
 427     }
 428
 429     if (s->coalesced_mmio && !s->coalesced_mmio_ring) {
 430         s->coalesced_mmio_ring =
 431             (void *)cpu->kvm_run + s->coalesced_mmio * PAGE_SIZE;
 432     }
 433
 434     if (s->kvm_dirty_ring_size) {
 435         /* Use MAP_SHARED to share pages with the kernel */
 436         cpu->kvm_dirty_gfns = mmap(NULL, s->kvm_dirty_ring_bytes,
 437                                    PROT_READ | PROT_WRITE, MAP_SHARED,
 438                                    cpu->kvm_fd,
 439                                    PAGE_SIZE * KVM_DIRTY_LOG_PAGE_OFFSET);
 440         if (cpu->kvm_dirty_gfns == MAP_FAILED) {
 441             ret = -errno;
 442             DPRINTF("mmap'ing vcpu dirty gfns failed: %d\n", ret);
 443             goto err;
 444         }
 445     }
 446
 447     ret = kvm_arch_init_vcpu(cpu);
 448     if (ret < 0) {
 449         error_setg_errno(errp, -ret,
 450                          "kvm_init_vcpu: kvm_arch_init_vcpu failed (%lu)",
 451                          kvm_arch_vcpu_id(cpu));
 452     }
 453     cpu->kvm_vcpu_stats_fd = kvm_vcpu_ioctl(cpu, KVM_GET_STATS_FD, NULL);
 454
 455 err:
 456     return ret;
 457 }
 458
 459 /*
 460  * dirty pages logging control
 461  */
 462
 463 static int kvm_mem_flags(MemoryRegion *mr)
 464 {
 465     bool readonly = mr->readonly || memory_region_is_romd(mr);
 466     int flags = 0;
 467
 468     if (memory_region_get_dirty_log_mask(mr) != 0) {
 469         flags |= KVM_MEM_LOG_DIRTY_PAGES;
 470     }
 471     if (readonly && kvm_readonly_mem_allowed) {
 472         flags |= KVM_MEM_READONLY;
 473     }
 474     return flags;
 475 }
 476
 477 /* Called with KVMMemoryListener.slots_lock held */
 478 static int kvm_slot_update_flags(KVMMemoryListener *kml, KVMSlot *mem,
 479                                  MemoryRegion *mr)
 480 {
 481     mem->flags = kvm_mem_flags(mr);
 482
 483     /* If nothing changed effectively, no need to issue ioctl */
 484     if (mem->flags == mem->old_flags) {
 485         return 0;
 486     }
 487
 488     kvm_slot_init_dirty_bitmap(mem);
 489     return kvm_set_user_memory_region(kml, mem, false);
 490 }
 491
 492 static int kvm_section_update_flags(KVMMemoryListener *kml,
 493                                     MemoryRegionSection *section)
 494 {
 495     hwaddr start_addr, size, slot_size;
 496     KVMSlot *mem;
 497     int ret = 0;
 498
 499     size = kvm_align_section(section, &start_addr);
 500     if (!size) {
 501         return 0;
 502     }
 503
 504     kvm_slots_lock();
 505
 506     while (size && !ret) {
 507         slot_size = MIN(kvm_max_slot_size, size);
 508         mem = kvm_lookup_matching_slot(kml, start_addr, slot_size);
 509         if (!mem) {
 510             /* We don't have a slot if we want to trap every access. */
 511             goto out;
 512         }
 513
 514         ret = kvm_slot_update_flags(kml, mem, section->mr);
 515         start_addr += slot_size;
 516         size -= slot_size;
 517     }
 518
 519 out:
 520     kvm_slots_unlock();
 521     return ret;
 522 }
 523
 524 static void kvm_log_start(MemoryListener *listener,
 525                           MemoryRegionSection *section,
 526                           int old, int new)
 527 {
 528     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
 529     int r;
 530
 531     if (old != 0) {
 532         return;
 533     }
 534
 535     r = kvm_section_update_flags(kml, section);
 536     if (r < 0) {
 537         abort();
 538     }
 539 }
 540
 541 static void kvm_log_stop(MemoryListener *listener,
 542                           MemoryRegionSection *section,
 543                           int old, int new)
 544 {
 545     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
 546     int r;
 547
 548     if (new != 0) {
 549         return;
 550     }
 551
 552     r = kvm_section_update_flags(kml, section);
 553     if (r < 0) {
 554         abort();
 555     }
 556 }
 557
 558 /* get kvm's dirty pages bitmap and update qemu's */
 559 static void kvm_slot_sync_dirty_pages(KVMSlot *slot)
 560 {
 561     ram_addr_t start = slot->ram_start_offset;
 562     ram_addr_t pages = slot->memory_size / qemu_real_host_page_size();
 563
 564     cpu_physical_memory_set_dirty_lebitmap(slot->dirty_bmap, start, pages);
 565 }
 566
 567 static void kvm_slot_reset_dirty_pages(KVMSlot *slot)
 568 {
 569     memset(slot->dirty_bmap, 0, slot->dirty_bmap_size);
 570 }
 571
 572 #define ALIGN(x, y)  (((x)+(y)-1) & ~((y)-1))
 573
 574 /* Allocate the dirty bitmap for a slot  */
 575 static void kvm_slot_init_dirty_bitmap(KVMSlot *mem)
 576 {
 577     if (!(mem->flags & KVM_MEM_LOG_DIRTY_PAGES) || mem->dirty_bmap) {
 578         return;
 579     }
 580
 581     /*
 582      * XXX bad kernel interface alert
 583      * For dirty bitmap, kernel allocates array of size aligned to
 584      * bits-per-long.  But for case when the kernel is 64bits and
 585      * the userspace is 32bits, userspace can't align to the same
 586      * bits-per-long, since sizeof(long) is different between kernel
 587      * and user space.  This way, userspace will provide buffer which
 588      * may be 4 bytes less than the kernel will use, resulting in
 589      * userspace memory corruption (which is not detectable by valgrind
 590      * too, in most cases).
 591      * So for now, let's align to 64 instead of HOST_LONG_BITS here, in
 592      * a hope that sizeof(long) won't become >8 any time soon.
 593      *
 594      * Note: the granule of kvm dirty log is qemu_real_host_page_size.
 595      * And mem->memory_size is aligned to it (otherwise this mem can't
 596      * be registered to KVM).
 597      */
 598     hwaddr bitmap_size = ALIGN(mem->memory_size / qemu_real_host_page_size(),
 599                                         /*HOST_LONG_BITS*/ 64) / 8;
 600     mem->dirty_bmap = g_malloc0(bitmap_size);
 601     mem->dirty_bmap_size = bitmap_size;
 602 }
 603
 604 /*
 605  * Sync dirty bitmap from kernel to KVMSlot.dirty_bmap, return true if
 606  * succeeded, false otherwise
 607  */
 608 static bool kvm_slot_get_dirty_log(KVMState *s, KVMSlot *slot)
 609 {
 610     struct kvm_dirty_log d = {};
 611     int ret;
 612
 613     d.dirty_bitmap = slot->dirty_bmap;
 614     d.slot = slot->slot | (slot->as_id << 16);
 615     ret = kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d);
 616
 617     if (ret == -ENOENT) {
 618         /* kernel does not have dirty bitmap in this slot */
 619         ret = 0;
 620     }
 621     if (ret) {
 622         error_report_once("%s: KVM_GET_DIRTY_LOG failed with %d",
 623                           __func__, ret);
 624     }
 625     return ret == 0;
 626 }
 627
 628 /* Should be with all slots_lock held for the address spaces. */
 629 static void kvm_dirty_ring_mark_page(KVMState *s, uint32_t as_id,
 630                                      uint32_t slot_id, uint64_t offset)
 631 {
 632     KVMMemoryListener *kml;
 633     KVMSlot *mem;
 634
 635     if (as_id >= s->nr_as) {
 636         return;
 637     }
 638
 639     kml = s->as[as_id].ml;
 640     mem = &kml->slots[slot_id];
 641
 642     if (!mem->memory_size || offset >=
 643         (mem->memory_size / qemu_real_host_page_size())) {
 644         return;
 645     }
 646
 647     set_bit(offset, mem->dirty_bmap);
 648 }
 649
 650 static bool dirty_gfn_is_dirtied(struct kvm_dirty_gfn *gfn)
 651 {
 652     /*
 653      * Read the flags before the value.  Pairs with barrier in
 654      * KVM's kvm_dirty_ring_push() function.
 655      */
 656     return qatomic_load_acquire(&gfn->flags) == KVM_DIRTY_GFN_F_DIRTY;
 657 }
 658
 659 static void dirty_gfn_set_collected(struct kvm_dirty_gfn *gfn)
 660 {
 661     /*
 662      * Use a store-release so that the CPU that executes KVM_RESET_DIRTY_RINGS
 663      * sees the full content of the ring:
 664      *
 665      * CPU0                     CPU1                         CPU2
 666      * ------------------------------------------------------------------------------
 667      *                                                       fill gfn0
 668      *                                                       store-rel flags for gfn0
 669      * load-acq flags for gfn0
 670      * store-rel RESET for gfn0
 671      *                          ioctl(RESET_RINGS)
 672      *                            load-acq flags for gfn0
 673      *                            check if flags have RESET
 674      *
 675      * The synchronization goes from CPU2 to CPU0 to CPU1.
 676      */
 677     qatomic_store_release(&gfn->flags, KVM_DIRTY_GFN_F_RESET);
 678 }
 679
 680 /*
 681  * Should be with all slots_lock held for the address spaces.  It returns the
 682  * dirty page we've collected on this dirty ring.
 683  */
 684 static uint32_t kvm_dirty_ring_reap_one(KVMState *s, CPUState *cpu)
 685 {
 686     struct kvm_dirty_gfn *dirty_gfns = cpu->kvm_dirty_gfns, *cur;
 687     uint32_t ring_size = s->kvm_dirty_ring_size;
 688     uint32_t count = 0, fetch = cpu->kvm_fetch_index;
 689
 690     /*
 691      * It's possible that we race with vcpu creation code where the vcpu is
 692      * put onto the vcpus list but not yet initialized the dirty ring
 693      * structures.  If so, skip it.
 694      */
 695     if (!cpu->created) {
 696         return 0;
 697     }
 698
 699     assert(dirty_gfns && ring_size);
 700     trace_kvm_dirty_ring_reap_vcpu(cpu->cpu_index);
 701
 702     while (true) {
 703         cur = &dirty_gfns[fetch % ring_size];
 704         if (!dirty_gfn_is_dirtied(cur)) {
 705             break;
 706         }
 707         kvm_dirty_ring_mark_page(s, cur->slot >> 16, cur->slot & 0xffff,
 708                                  cur->offset);
 709         dirty_gfn_set_collected(cur);
 710         trace_kvm_dirty_ring_page(cpu->cpu_index, fetch, cur->offset);
 711         fetch++;
 712         count++;
 713     }
 714     cpu->kvm_fetch_index = fetch;
 715     cpu->dirty_pages += count;
 716
 717     return count;
 718 }
 719
 720 /* Must be with slots_lock held */
 721 static uint64_t kvm_dirty_ring_reap_locked(KVMState *s, CPUState* cpu)
 722 {
 723     int ret;
 724     uint64_t total = 0;
 725     int64_t stamp;
 726
 727     stamp = get_clock();
 728
 729     if (cpu) {
 730         total = kvm_dirty_ring_reap_one(s, cpu);
 731     } else {
 732         CPU_FOREACH(cpu) {
 733             total += kvm_dirty_ring_reap_one(s, cpu);
 734         }
 735     }
 736
 737     if (total) {
 738         ret = kvm_vm_ioctl(s, KVM_RESET_DIRTY_RINGS);
 739         assert(ret == total);
 740     }
 741
 742     stamp = get_clock() - stamp;
 743
 744     if (total) {
 745         trace_kvm_dirty_ring_reap(total, stamp / 1000);
 746     }
 747
 748     return total;
 749 }
 750
 751 /*
 752  * Currently for simplicity, we must hold BQL before calling this.  We can
 753  * consider to drop the BQL if we're clear with all the race conditions.
 754  */
 755 static uint64_t kvm_dirty_ring_reap(KVMState *s, CPUState *cpu)
 756 {
 757     uint64_t total;
 758
 759     /*
 760      * We need to lock all kvm slots for all address spaces here,
 761      * because:
 762      *
 763      * (1) We need to mark dirty for dirty bitmaps in multiple slots
 764      *     and for tons of pages, so it's better to take the lock here
 765      *     once rather than once per page.  And more importantly,
 766      *
 767      * (2) We must _NOT_ publish dirty bits to the other threads
 768      *     (e.g., the migration thread) via the kvm memory slot dirty
 769      *     bitmaps before correctly re-protect those dirtied pages.
 770      *     Otherwise we can have potential risk of data corruption if
 771      *     the page data is read in the other thread before we do
 772      *     reset below.
 773      */
 774     kvm_slots_lock();
 775     total = kvm_dirty_ring_reap_locked(s, cpu);
 776     kvm_slots_unlock();
 777
 778     return total;
 779 }
 780
 781 static void do_kvm_cpu_synchronize_kick(CPUState *cpu, run_on_cpu_data arg)
 782 {
 783     /* No need to do anything */
 784 }
 785
 786 /*
 787  * Kick all vcpus out in a synchronized way.  When returned, we
 788  * guarantee that every vcpu has been kicked and at least returned to
 789  * userspace once.
 790  */
 791 static void kvm_cpu_synchronize_kick_all(void)
 792 {
 793     CPUState *cpu;
 794
 795     CPU_FOREACH(cpu) {
 796         run_on_cpu(cpu, do_kvm_cpu_synchronize_kick, RUN_ON_CPU_NULL);
 797     }
 798 }
 799
 800 /*
 801  * Flush all the existing dirty pages to the KVM slot buffers.  When
 802  * this call returns, we guarantee that all the touched dirty pages
 803  * before calling this function have been put into the per-kvmslot
 804  * dirty bitmap.
 805  *
 806  * This function must be called with BQL held.
 807  */
 808 static void kvm_dirty_ring_flush(void)
 809 {
 810     trace_kvm_dirty_ring_flush(0);
 811     /*
 812      * The function needs to be serialized.  Since this function
 813      * should always be with BQL held, serialization is guaranteed.
 814      * However, let's be sure of it.
 815      */
 816     assert(qemu_mutex_iothread_locked());
 817     /*
 818      * First make sure to flush the hardware buffers by kicking all
 819      * vcpus out in a synchronous way.
 820      */
 821     kvm_cpu_synchronize_kick_all();
 822     kvm_dirty_ring_reap(kvm_state, NULL);
 823     trace_kvm_dirty_ring_flush(1);
 824 }
 825
 826 /**
 827  * kvm_physical_sync_dirty_bitmap - Sync dirty bitmap from kernel space
 828  *
 829  * This function will first try to fetch dirty bitmap from the kernel,
 830  * and then updates qemu's dirty bitmap.
 831  *
 832  * NOTE: caller must be with kml->slots_lock held.
 833  *
 834  * @kml: the KVM memory listener object
 835  * @section: the memory section to sync the dirty bitmap with
 836  */
 837 static void kvm_physical_sync_dirty_bitmap(KVMMemoryListener *kml,
 838                                            MemoryRegionSection *section)
 839 {
 840     KVMState *s = kvm_state;
 841     KVMSlot *mem;
 842     hwaddr start_addr, size;
 843     hwaddr slot_size;
 844
 845     size = kvm_align_section(section, &start_addr);
 846     while (size) {
 847         slot_size = MIN(kvm_max_slot_size, size);
 848         mem = kvm_lookup_matching_slot(kml, start_addr, slot_size);
 849         if (!mem) {
 850             /* We don't have a slot if we want to trap every access. */
 851             return;
 852         }
 853         if (kvm_slot_get_dirty_log(s, mem)) {
 854             kvm_slot_sync_dirty_pages(mem);
 855         }
 856         start_addr += slot_size;
 857         size -= slot_size;
 858     }
 859 }
 860
 861 /* Alignment requirement for KVM_CLEAR_DIRTY_LOG - 64 pages */
 862 #define KVM_CLEAR_LOG_SHIFT  6
 863 #define KVM_CLEAR_LOG_ALIGN  (qemu_real_host_page_size() << KVM_CLEAR_LOG_SHIFT)
 864 #define KVM_CLEAR_LOG_MASK   (-KVM_CLEAR_LOG_ALIGN)
 865
 866 static int kvm_log_clear_one_slot(KVMSlot *mem, int as_id, uint64_t start,
 867                                   uint64_t size)
 868 {
 869     KVMState *s = kvm_state;
 870     uint64_t end, bmap_start, start_delta, bmap_npages;
 871     struct kvm_clear_dirty_log d;
 872     unsigned long *bmap_clear = NULL, psize = qemu_real_host_page_size();
 873     int ret;
 874
 875     /*
 876      * We need to extend either the start or the size or both to
 877      * satisfy the KVM interface requirement.  Firstly, do the start
 878      * page alignment on 64 host pages
 879      */
 880     bmap_start = start & KVM_CLEAR_LOG_MASK;
 881     start_delta = start - bmap_start;
 882     bmap_start /= psize;
 883
 884     /*
 885      * The kernel interface has restriction on the size too, that either:
 886      *
 887      * (1) the size is 64 host pages aligned (just like the start), or
 888      * (2) the size fills up until the end of the KVM memslot.
 889      */
 890     bmap_npages = DIV_ROUND_UP(size + start_delta, KVM_CLEAR_LOG_ALIGN)
 891         << KVM_CLEAR_LOG_SHIFT;
 892     end = mem->memory_size / psize;
 893     if (bmap_npages > end - bmap_start) {
 894         bmap_npages = end - bmap_start;
 895     }
 896     start_delta /= psize;
 897
 898     /*
 899      * Prepare the bitmap to clear dirty bits.  Here we must guarantee
 900      * that we won't clear any unknown dirty bits otherwise we might
 901      * accidentally clear some set bits which are not yet synced from
 902      * the kernel into QEMU's bitmap, then we'll lose track of the
 903      * guest modifications upon those pages (which can directly lead
 904      * to guest data loss or panic after migration).
 905      *
 906      * Layout of the KVMSlot.dirty_bmap:
 907      *
 908      *                   |<-------- bmap_npages -----------..>|
 909      *                                                     [1]
 910      *                     start_delta         size
 911      *  |----------------|-------------|------------------|------------|
 912      *  ^                ^             ^                               ^
 913      *  |                |             |                               |
 914      * start          bmap_start     (start)                         end
 915      * of memslot                                             of memslot
 916      *
 917      * [1] bmap_npages can be aligned to either 64 pages or the end of slot
 918      */
 919
 920     assert(bmap_start % BITS_PER_LONG == 0);
 921     /* We should never do log_clear before log_sync */
 922     assert(mem->dirty_bmap);
 923     if (start_delta || bmap_npages - size / psize) {
 924         /* Slow path - we need to manipulate a temp bitmap */
 925         bmap_clear = bitmap_new(bmap_npages);
 926         bitmap_copy_with_src_offset(bmap_clear, mem->dirty_bmap,
 927                                     bmap_start, start_delta + size / psize);
 928         /*
 929          * We need to fill the holes at start because that was not
 930          * specified by the caller and we extended the bitmap only for
 931          * 64 pages alignment
 932          */
 933         bitmap_clear(bmap_clear, 0, start_delta);
 934         d.dirty_bitmap = bmap_clear;
 935     } else {
 936         /*
 937          * Fast path - both start and size align well with BITS_PER_LONG
 938          * (or the end of memory slot)
 939          */
 940         d.dirty_bitmap = mem->dirty_bmap + BIT_WORD(bmap_start);
 941     }
 942
 943     d.first_page = bmap_start;
 944     /* It should never overflow.  If it happens, say something */
 945     assert(bmap_npages <= UINT32_MAX);
 946     d.num_pages = bmap_npages;
 947     d.slot = mem->slot | (as_id << 16);
 948
 949     ret = kvm_vm_ioctl(s, KVM_CLEAR_DIRTY_LOG, &d);
 950     if (ret < 0 && ret != -ENOENT) {
 951         error_report("%s: KVM_CLEAR_DIRTY_LOG failed, slot=%d, "
 952                      "start=0x%"PRIx64", size=0x%"PRIx32", errno=%d",
 953                      __func__, d.slot, (uint64_t)d.first_page,
 954                      (uint32_t)d.num_pages, ret);
 955     } else {
 956         ret = 0;
 957         trace_kvm_clear_dirty_log(d.slot, d.first_page, d.num_pages);
 958     }
 959
 960     /*
 961      * After we have updated the remote dirty bitmap, we update the
 962      * cached bitmap as well for the memslot, then if another user
 963      * clears the same region we know we shouldn't clear it again on
 964      * the remote otherwise it's data loss as well.
 965      */
 966     bitmap_clear(mem->dirty_bmap, bmap_start + start_delta,
 967                  size / psize);
 968     /* This handles the NULL case well */
 969     g_free(bmap_clear);
 970     return ret;
 971 }
 972
 973
 974 /**
 975  * kvm_physical_log_clear - Clear the kernel's dirty bitmap for range
 976  *
 977  * NOTE: this will be a no-op if we haven't enabled manual dirty log
 978  * protection in the host kernel because in that case this operation
 979  * will be done within log_sync().
 980  *
 981  * @kml:     the kvm memory listener
 982  * @section: the memory range to clear dirty bitmap
 983  */
 984 static int kvm_physical_log_clear(KVMMemoryListener *kml,
 985                                   MemoryRegionSection *section)
 986 {
 987     KVMState *s = kvm_state;
 988     uint64_t start, size, offset, count;
 989     KVMSlot *mem;
 990     int ret = 0, i;
 991
 992     if (!s->manual_dirty_log_protect) {
 993         /* No need to do explicit clear */
 994         return ret;
 995     }
 996
 997     start = section->offset_within_address_space;
 998     size = int128_get64(section->size);
 999
1000     if (!size) {
1001         /* Nothing more we can do... */
1002         return ret;
1003     }
1004
1005     kvm_slots_lock();
1006
1007     for (i = 0; i < s->nr_slots; i++) {
1008         mem = &kml->slots[i];
1009         /* Discard slots that are empty or do not overlap the section */
1010         if (!mem->memory_size ||
1011             mem->start_addr > start + size - 1 ||
1012             start > mem->start_addr + mem->memory_size - 1) {
1013             continue;
1014         }
1015
1016         if (start >= mem->start_addr) {
1017             /* The slot starts before section or is aligned to it.  */
1018             offset = start - mem->start_addr;
1019             count = MIN(mem->memory_size - offset, size);
1020         } else {
1021             /* The slot starts after section.  */
1022             offset = 0;
1023             count = MIN(mem->memory_size, size - (mem->start_addr - start));
1024         }
1025         ret = kvm_log_clear_one_slot(mem, kml->as_id, offset, count);
1026         if (ret < 0) {
1027             break;
1028         }
1029     }
1030
1031     kvm_slots_unlock();
1032
1033     return ret;
1034 }
1035
1036 static void kvm_coalesce_mmio_region(MemoryListener *listener,
1037                                      MemoryRegionSection *secion,
1038                                      hwaddr start, hwaddr size)
1039 {
1040     KVMState *s = kvm_state;
1041
1042     if (s->coalesced_mmio) {
1043         struct kvm_coalesced_mmio_zone zone;
1044
1045         zone.addr = start;
1046         zone.size = size;
1047         zone.pad = 0;
1048
1049         (void)kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
1050     }
1051 }
1052
1053 static void kvm_uncoalesce_mmio_region(MemoryListener *listener,
1054                                        MemoryRegionSection *secion,
1055                                        hwaddr start, hwaddr size)
1056 {
1057     KVMState *s = kvm_state;
1058
1059     if (s->coalesced_mmio) {
1060         struct kvm_coalesced_mmio_zone zone;
1061
1062         zone.addr = start;
1063         zone.size = size;
1064         zone.pad = 0;
1065
1066         (void)kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
1067     }
1068 }
1069
1070 static void kvm_coalesce_pio_add(MemoryListener *listener,
1071                                 MemoryRegionSection *section,
1072                                 hwaddr start, hwaddr size)
1073 {
1074     KVMState *s = kvm_state;
1075
1076     if (s->coalesced_pio) {
1077         struct kvm_coalesced_mmio_zone zone;
1078
1079         zone.addr = start;
1080         zone.size = size;
1081         zone.pio = 1;
1082
1083         (void)kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
1084     }
1085 }
1086
1087 static void kvm_coalesce_pio_del(MemoryListener *listener,
1088                                 MemoryRegionSection *section,
1089                                 hwaddr start, hwaddr size)
1090 {
1091     KVMState *s = kvm_state;
1092
1093     if (s->coalesced_pio) {
1094         struct kvm_coalesced_mmio_zone zone;
1095
1096         zone.addr = start;
1097         zone.size = size;
1098         zone.pio = 1;
1099
1100         (void)kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
1101      }
1102 }
1103
1104 static MemoryListener kvm_coalesced_pio_listener = {
1105     .name = "kvm-coalesced-pio",
1106     .coalesced_io_add = kvm_coalesce_pio_add,
1107     .coalesced_io_del = kvm_coalesce_pio_del,
1108     .priority = MEMORY_LISTENER_PRIORITY_MIN,
1109 };
1110
1111 int kvm_check_extension(KVMState *s, unsigned int extension)
1112 {
1113     int ret;
1114
1115     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
1116     if (ret < 0) {
1117         ret = 0;
1118     }
1119
1120     return ret;
1121 }
1122
1123 int kvm_vm_check_extension(KVMState *s, unsigned int extension)
1124 {
1125     int ret;
1126
1127     ret = kvm_vm_ioctl(s, KVM_CHECK_EXTENSION, extension);
1128     if (ret < 0) {
1129         /* VM wide version not implemented, use global one instead */
1130         ret = kvm_check_extension(s, extension);
1131     }
1132
1133     return ret;
1134 }
1135
1136 typedef struct HWPoisonPage {
1137     ram_addr_t ram_addr;
1138     QLIST_ENTRY(HWPoisonPage) list;
1139 } HWPoisonPage;
1140
1141 static QLIST_HEAD(, HWPoisonPage) hwpoison_page_list =
1142     QLIST_HEAD_INITIALIZER(hwpoison_page_list);
1143
1144 static void kvm_unpoison_all(void *param)
1145 {
1146     HWPoisonPage *page, *next_page;
1147
1148     QLIST_FOREACH_SAFE(page, &hwpoison_page_list, list, next_page) {
1149         QLIST_REMOVE(page, list);
1150         qemu_ram_remap(page->ram_addr, TARGET_PAGE_SIZE);
1151         g_free(page);
1152     }
1153 }
1154
1155 void kvm_hwpoison_page_add(ram_addr_t ram_addr)
1156 {
1157     HWPoisonPage *page;
1158
1159     QLIST_FOREACH(page, &hwpoison_page_list, list) {
1160         if (page->ram_addr == ram_addr) {
1161             return;
1162         }
1163     }
1164     page = g_new(HWPoisonPage, 1);
1165     page->ram_addr = ram_addr;
1166     QLIST_INSERT_HEAD(&hwpoison_page_list, page, list);
1167 }
1168
1169 static uint32_t adjust_ioeventfd_endianness(uint32_t val, uint32_t size)
1170 {
1171 #if HOST_BIG_ENDIAN != TARGET_BIG_ENDIAN
1172     /* The kernel expects ioeventfd values in HOST_BIG_ENDIAN
1173      * endianness, but the memory core hands them in target endianness.
1174      * For example, PPC is always treated as big-endian even if running
1175      * on KVM and on PPC64LE.  Correct here.
1176      */
1177     switch (size) {
1178     case 2:
1179         val = bswap16(val);
1180         break;
1181     case 4:
1182         val = bswap32(val);
1183         break;
1184     }
1185 #endif
1186     return val;
1187 }
1188
1189 static int kvm_set_ioeventfd_mmio(int fd, hwaddr addr, uint32_t val,
1190                                   bool assign, uint32_t size, bool datamatch)
1191 {
1192     int ret;
1193     struct kvm_ioeventfd iofd = {
1194         .datamatch = datamatch ? adjust_ioeventfd_endianness(val, size) : 0,
1195         .addr = addr,
1196         .len = size,
1197         .flags = 0,
1198         .fd = fd,
1199     };
1200
1201     trace_kvm_set_ioeventfd_mmio(fd, (uint64_t)addr, val, assign, size,
1202                                  datamatch);
1203     if (!kvm_enabled()) {
1204         return -ENOSYS;
1205     }
1206
1207     if (datamatch) {
1208         iofd.flags |= KVM_IOEVENTFD_FLAG_DATAMATCH;
1209     }
1210     if (!assign) {
1211         iofd.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
1212     }
1213
1214     ret = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &iofd);
1215
1216     if (ret < 0) {
1217         return -errno;
1218     }
1219
1220     return 0;
1221 }
1222
1223 static int kvm_set_ioeventfd_pio(int fd, uint16_t addr, uint16_t val,
1224                                  bool assign, uint32_t size, bool datamatch)
1225 {
1226     struct kvm_ioeventfd kick = {
1227         .datamatch = datamatch ? adjust_ioeventfd_endianness(val, size) : 0,
1228         .addr = addr,
1229         .flags = KVM_IOEVENTFD_FLAG_PIO,
1230         .len = size,
1231         .fd = fd,
1232     };
1233     int r;
1234     trace_kvm_set_ioeventfd_pio(fd, addr, val, assign, size, datamatch);
1235     if (!kvm_enabled()) {
1236         return -ENOSYS;
1237     }
1238     if (datamatch) {
1239         kick.flags |= KVM_IOEVENTFD_FLAG_DATAMATCH;
1240     }
1241     if (!assign) {
1242         kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
1243     }
1244     r = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
1245     if (r < 0) {
1246         return r;
1247     }
1248     return 0;
1249 }
1250
1251
1252 static int kvm_check_many_ioeventfds(void)
1253 {
1254     /* Userspace can use ioeventfd for io notification.  This requires a host
1255      * that supports eventfd(2) and an I/O thread; since eventfd does not
1256      * support SIGIO it cannot interrupt the vcpu.
1257      *
1258      * Older kernels have a 6 device limit on the KVM io bus.  Find out so we
1259      * can avoid creating too many ioeventfds.
1260      */
1261 #if defined(CONFIG_EVENTFD)
1262     int ioeventfds[7];
1263     int i, ret = 0;
1264     for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
1265         ioeventfds[i] = eventfd(0, EFD_CLOEXEC);
1266         if (ioeventfds[i] < 0) {
1267             break;
1268         }
1269         ret = kvm_set_ioeventfd_pio(ioeventfds[i], 0, i, true, 2, true);
1270         if (ret < 0) {
1271             close(ioeventfds[i]);
1272             break;
1273         }
1274     }
1275
1276     /* Decide whether many devices are supported or not */
1277     ret = i == ARRAY_SIZE(ioeventfds);
1278
1279     while (i-- > 0) {
1280         kvm_set_ioeventfd_pio(ioeventfds[i], 0, i, false, 2, true);
1281         close(ioeventfds[i]);
1282     }
1283     return ret;
1284 #else
1285     return 0;
1286 #endif
1287 }
1288
1289 static const KVMCapabilityInfo *
1290 kvm_check_extension_list(KVMState *s, const KVMCapabilityInfo *list)
1291 {
1292     while (list->name) {
1293         if (!kvm_check_extension(s, list->value)) {
1294             return list;
1295         }
1296         list++;
1297     }
1298     return NULL;
1299 }
1300
1301 void kvm_set_max_memslot_size(hwaddr max_slot_size)
1302 {
1303     g_assert(
1304         ROUND_UP(max_slot_size, qemu_real_host_page_size()) == max_slot_size
1305     );
1306     kvm_max_slot_size = max_slot_size;
1307 }
1308
1309 /* Called with KVMMemoryListener.slots_lock held */
1310 static void kvm_set_phys_mem(KVMMemoryListener *kml,
1311                              MemoryRegionSection *section, bool add)
1312 {
1313     KVMSlot *mem;
1314     int err;
1315     MemoryRegion *mr = section->mr;
1316     bool writable = !mr->readonly && !mr->rom_device;
1317     hwaddr start_addr, size, slot_size, mr_offset;
1318     ram_addr_t ram_start_offset;
1319     void *ram;
1320
1321     if (!memory_region_is_ram(mr)) {
1322         if (writable || !kvm_readonly_mem_allowed) {
1323             return;
1324         } else if (!mr->romd_mode) {
1325             /* If the memory device is not in romd_mode, then we actually want
1326              * to remove the kvm memory slot so all accesses will trap. */
1327             add = false;
1328         }
1329     }
1330
1331     size = kvm_align_section(section, &start_addr);
1332     if (!size) {
1333         return;
1334     }
1335
1336     /* The offset of the kvmslot within the memory region */
1337     mr_offset = section->offset_within_region + start_addr -
1338         section->offset_within_address_space;
1339
1340     /* use aligned delta to align the ram address and offset */
1341     ram = memory_region_get_ram_ptr(mr) + mr_offset;
1342     ram_start_offset = memory_region_get_ram_addr(mr) + mr_offset;
1343
1344     if (!add) {
1345         do {
1346             slot_size = MIN(kvm_max_slot_size, size);
1347             mem = kvm_lookup_matching_slot(kml, start_addr, slot_size);
1348             if (!mem) {
1349                 return;
1350             }
1351             if (mem->flags & KVM_MEM_LOG_DIRTY_PAGES) {
1352                 /*
1353                  * NOTE: We should be aware of the fact that here we're only
1354                  * doing a best effort to sync dirty bits.  No matter whether
1355                  * we're using dirty log or dirty ring, we ignored two facts:
1356                  *
1357                  * (1) dirty bits can reside in hardware buffers (PML)
1358                  *
1359                  * (2) after we collected dirty bits here, pages can be dirtied
1360                  * again before we do the final KVM_SET_USER_MEMORY_REGION to
1361                  * remove the slot.
1362                  *
1363                  * Not easy.  Let's cross the fingers until it's fixed.
1364                  */
1365                 if (kvm_state->kvm_dirty_ring_size) {
1366                     kvm_dirty_ring_reap_locked(kvm_state, NULL);
1367                     if (kvm_state->kvm_dirty_ring_with_bitmap) {
1368                         kvm_slot_sync_dirty_pages(mem);
1369                         kvm_slot_get_dirty_log(kvm_state, mem);
1370                     }
1371                 } else {
1372                     kvm_slot_get_dirty_log(kvm_state, mem);
1373                 }
1374                 kvm_slot_sync_dirty_pages(mem);
1375             }
1376
1377             /* unregister the slot */
1378             g_free(mem->dirty_bmap);
1379             mem->dirty_bmap = NULL;
1380             mem->memory_size = 0;
1381             mem->flags = 0;
1382             err = kvm_set_user_memory_region(kml, mem, false);
1383             if (err) {
1384                 fprintf(stderr, "%s: error unregistering slot: %s\n",
1385                         __func__, strerror(-err));
1386                 abort();
1387             }
1388             start_addr += slot_size;
1389             size -= slot_size;
1390         } while (size);
1391         return;
1392     }
1393
1394     /* register the new slot */
1395     do {
1396         slot_size = MIN(kvm_max_slot_size, size);
1397         mem = kvm_alloc_slot(kml);
1398         mem->as_id = kml->as_id;
1399         mem->memory_size = slot_size;
1400         mem->start_addr = start_addr;
1401         mem->ram_start_offset = ram_start_offset;
1402         mem->ram = ram;
1403         mem->flags = kvm_mem_flags(mr);
1404         kvm_slot_init_dirty_bitmap(mem);
1405         err = kvm_set_user_memory_region(kml, mem, true);
1406         if (err) {
1407             fprintf(stderr, "%s: error registering slot: %s\n", __func__,
1408                     strerror(-err));
1409             abort();
1410         }
1411         start_addr += slot_size;
1412         ram_start_offset += slot_size;
1413         ram += slot_size;
1414         size -= slot_size;
1415     } while (size);
1416 }
1417
1418 static void *kvm_dirty_ring_reaper_thread(void *data)
1419 {
1420     KVMState *s = data;
1421     struct KVMDirtyRingReaper *r = &s->reaper;
1422
1423     rcu_register_thread();
1424
1425     trace_kvm_dirty_ring_reaper("init");
1426
1427     while (true) {
1428         r->reaper_state = KVM_DIRTY_RING_REAPER_WAIT;
1429         trace_kvm_dirty_ring_reaper("wait");
1430         /*
1431          * TODO: provide a smarter timeout rather than a constant?
1432          */
1433         sleep(1);
1434
1435         /* keep sleeping so that dirtylimit not be interfered by reaper */
1436         if (dirtylimit_in_service()) {
1437             continue;
1438         }
1439
1440         trace_kvm_dirty_ring_reaper("wakeup");
1441         r->reaper_state = KVM_DIRTY_RING_REAPER_REAPING;
1442
1443         qemu_mutex_lock_iothread();
1444         kvm_dirty_ring_reap(s, NULL);
1445         qemu_mutex_unlock_iothread();
1446
1447         r->reaper_iteration++;
1448     }
1449
1450     trace_kvm_dirty_ring_reaper("exit");
1451
1452     rcu_unregister_thread();
1453
1454     return NULL;
1455 }
1456
1457 static int kvm_dirty_ring_reaper_init(KVMState *s)
1458 {
1459     struct KVMDirtyRingReaper *r = &s->reaper;
1460
1461     qemu_thread_create(&r->reaper_thr, "kvm-reaper",
1462                        kvm_dirty_ring_reaper_thread,
1463                        s, QEMU_THREAD_JOINABLE);
1464
1465     return 0;
1466 }
1467
1468 static int kvm_dirty_ring_init(KVMState *s)
1469 {
1470     uint32_t ring_size = s->kvm_dirty_ring_size;
1471     uint64_t ring_bytes = ring_size * sizeof(struct kvm_dirty_gfn);
1472     unsigned int capability = KVM_CAP_DIRTY_LOG_RING;
1473     int ret;
1474
1475     s->kvm_dirty_ring_size = 0;
1476     s->kvm_dirty_ring_bytes = 0;
1477
1478     /* Bail if the dirty ring size isn't specified */
1479     if (!ring_size) {
1480         return 0;
1481     }
1482
1483     /*
1484      * Read the max supported pages. Fall back to dirty logging mode
1485      * if the dirty ring isn't supported.
1486      */
1487     ret = kvm_vm_check_extension(s, capability);
1488     if (ret <= 0) {
1489         capability = KVM_CAP_DIRTY_LOG_RING_ACQ_REL;
1490         ret = kvm_vm_check_extension(s, capability);
1491     }
1492
1493     if (ret <= 0) {
1494         warn_report("KVM dirty ring not available, using bitmap method");
1495         return 0;
1496     }
1497
1498     if (ring_bytes > ret) {
1499         error_report("KVM dirty ring size %" PRIu32 " too big "
1500                      "(maximum is %ld).  Please use a smaller value.",
1501                      ring_size, (long)ret / sizeof(struct kvm_dirty_gfn));
1502         return -EINVAL;
1503     }
1504
1505     ret = kvm_vm_enable_cap(s, capability, 0, ring_bytes);
1506     if (ret) {
1507         error_report("Enabling of KVM dirty ring failed: %s. "
1508                      "Suggested minimum value is 1024.", strerror(-ret));
1509         return -EIO;
1510     }
1511
1512     /* Enable the backup bitmap if it is supported */
1513     ret = kvm_vm_check_extension(s, KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP);
1514     if (ret > 0) {
1515         ret = kvm_vm_enable_cap(s, KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP, 0);
1516         if (ret) {
1517             error_report("Enabling of KVM dirty ring's backup bitmap failed: "
1518                          "%s. ", strerror(-ret));
1519             return -EIO;
1520         }
1521
1522         s->kvm_dirty_ring_with_bitmap = true;
1523     }
1524
1525     s->kvm_dirty_ring_size = ring_size;
1526     s->kvm_dirty_ring_bytes = ring_bytes;
1527
1528     return 0;
1529 }
1530
1531 static void kvm_region_add(MemoryListener *listener,
1532                            MemoryRegionSection *section)
1533 {
1534     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
1535     KVMMemoryUpdate *update;
1536
1537     update = g_new0(KVMMemoryUpdate, 1);
1538     update->section = *section;
1539
1540     QSIMPLEQ_INSERT_TAIL(&kml->transaction_add, update, next);
1541 }
1542
1543 static void kvm_region_del(MemoryListener *listener,
1544                            MemoryRegionSection *section)
1545 {
1546     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
1547     KVMMemoryUpdate *update;
1548
1549     update = g_new0(KVMMemoryUpdate, 1);
1550     update->section = *section;
1551
1552     QSIMPLEQ_INSERT_TAIL(&kml->transaction_del, update, next);
1553 }
1554
1555 static void kvm_region_commit(MemoryListener *listener)
1556 {
1557     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener,
1558                                           listener);
1559     KVMMemoryUpdate *u1, *u2;
1560     bool need_inhibit = false;
1561
1562     if (QSIMPLEQ_EMPTY(&kml->transaction_add) &&
1563         QSIMPLEQ_EMPTY(&kml->transaction_del)) {
1564         return;
1565     }
1566
1567     /*
1568      * We have to be careful when regions to add overlap with ranges to remove.
1569      * We have to simulate atomic KVM memslot updates by making sure no ioctl()
1570      * is currently active.
1571      *
1572      * The lists are order by addresses, so it's easy to find overlaps.
1573      */
1574     u1 = QSIMPLEQ_FIRST(&kml->transaction_del);
1575     u2 = QSIMPLEQ_FIRST(&kml->transaction_add);
1576     while (u1 && u2) {
1577         Range r1, r2;
1578
1579         range_init_nofail(&r1, u1->section.offset_within_address_space,
1580                           int128_get64(u1->section.size));
1581         range_init_nofail(&r2, u2->section.offset_within_address_space,
1582                           int128_get64(u2->section.size));
1583
1584         if (range_overlaps_range(&r1, &r2)) {
1585             need_inhibit = true;
1586             break;
1587         }
1588         if (range_lob(&r1) < range_lob(&r2)) {
1589             u1 = QSIMPLEQ_NEXT(u1, next);
1590         } else {
1591             u2 = QSIMPLEQ_NEXT(u2, next);
1592         }
1593     }
1594
1595     kvm_slots_lock();
1596     if (need_inhibit) {
1597         accel_ioctl_inhibit_begin();
1598     }
1599
1600     /* Remove all memslots before adding the new ones. */
1601     while (!QSIMPLEQ_EMPTY(&kml->transaction_del)) {
1602         u1 = QSIMPLEQ_FIRST(&kml->transaction_del);
1603         QSIMPLEQ_REMOVE_HEAD(&kml->transaction_del, next);
1604
1605         kvm_set_phys_mem(kml, &u1->section, false);
1606         memory_region_unref(u1->section.mr);
1607
1608         g_free(u1);
1609     }
1610     while (!QSIMPLEQ_EMPTY(&kml->transaction_add)) {
1611         u1 = QSIMPLEQ_FIRST(&kml->transaction_add);
1612         QSIMPLEQ_REMOVE_HEAD(&kml->transaction_add, next);
1613
1614         memory_region_ref(u1->section.mr);
1615         kvm_set_phys_mem(kml, &u1->section, true);
1616
1617         g_free(u1);
1618     }
1619
1620     if (need_inhibit) {
1621         accel_ioctl_inhibit_end();
1622     }
1623     kvm_slots_unlock();
1624 }
1625
1626 static void kvm_log_sync(MemoryListener *listener,
1627                          MemoryRegionSection *section)
1628 {
1629     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
1630
1631     kvm_slots_lock();
1632     kvm_physical_sync_dirty_bitmap(kml, section);
1633     kvm_slots_unlock();
1634 }
1635
1636 static void kvm_log_sync_global(MemoryListener *l, bool last_stage)
1637 {
1638     KVMMemoryListener *kml = container_of(l, KVMMemoryListener, listener);
1639     KVMState *s = kvm_state;
1640     KVMSlot *mem;
1641     int i;
1642
1643     /* Flush all kernel dirty addresses into KVMSlot dirty bitmap */
1644     kvm_dirty_ring_flush();
1645
1646     /*
1647      * TODO: make this faster when nr_slots is big while there are
1648      * only a few used slots (small VMs).
1649      */
1650     kvm_slots_lock();
1651     for (i = 0; i < s->nr_slots; i++) {
1652         mem = &kml->slots[i];
1653         if (mem->memory_size && mem->flags & KVM_MEM_LOG_DIRTY_PAGES) {
1654             kvm_slot_sync_dirty_pages(mem);
1655
1656             if (s->kvm_dirty_ring_with_bitmap && last_stage &&
1657                 kvm_slot_get_dirty_log(s, mem)) {
1658                 kvm_slot_sync_dirty_pages(mem);
1659             }
1660
1661             /*
1662              * This is not needed by KVM_GET_DIRTY_LOG because the
1663              * ioctl will unconditionally overwrite the whole region.
1664              * However kvm dirty ring has no such side effect.
1665              */
1666             kvm_slot_reset_dirty_pages(mem);
1667         }
1668     }
1669     kvm_slots_unlock();
1670 }
1671
1672 static void kvm_log_clear(MemoryListener *listener,
1673                           MemoryRegionSection *section)
1674 {
1675     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
1676     int r;
1677
1678     r = kvm_physical_log_clear(kml, section);
1679     if (r < 0) {
1680         error_report_once("%s: kvm log clear failed: mr=%s "
1681                           "offset=%"HWADDR_PRIx" size=%"PRIx64, __func__,
1682                           section->mr->name, section->offset_within_region,
1683                           int128_get64(section->size));
1684         abort();
1685     }
1686 }
1687
1688 static void kvm_mem_ioeventfd_add(MemoryListener *listener,
1689                                   MemoryRegionSection *section,
1690                                   bool match_data, uint64_t data,
1691                                   EventNotifier *e)
1692 {
1693     int fd = event_notifier_get_fd(e);
1694     int r;
1695
1696     r = kvm_set_ioeventfd_mmio(fd, section->offset_within_address_space,
1697                                data, true, int128_get64(section->size),
1698                                match_data);
1699     if (r < 0) {
1700         fprintf(stderr, "%s: error adding ioeventfd: %s (%d)\n",
1701                 __func__, strerror(-r), -r);
1702         abort();
1703     }
1704 }
1705
1706 static void kvm_mem_ioeventfd_del(MemoryListener *listener,
1707                                   MemoryRegionSection *section,
1708                                   bool match_data, uint64_t data,
1709                                   EventNotifier *e)
1710 {
1711     int fd = event_notifier_get_fd(e);
1712     int r;
1713
1714     r = kvm_set_ioeventfd_mmio(fd, section->offset_within_address_space,
1715                                data, false, int128_get64(section->size),
1716                                match_data);
1717     if (r < 0) {
1718         fprintf(stderr, "%s: error deleting ioeventfd: %s (%d)\n",
1719                 __func__, strerror(-r), -r);
1720         abort();
1721     }
1722 }
1723
1724 static void kvm_io_ioeventfd_add(MemoryListener *listener,
1725                                  MemoryRegionSection *section,
1726                                  bool match_data, uint64_t data,
1727                                  EventNotifier *e)
1728 {
1729     int fd = event_notifier_get_fd(e);
1730     int r;
1731
1732     r = kvm_set_ioeventfd_pio(fd, section->offset_within_address_space,
1733                               data, true, int128_get64(section->size),
1734                               match_data);
1735     if (r < 0) {
1736         fprintf(stderr, "%s: error adding ioeventfd: %s (%d)\n",
1737                 __func__, strerror(-r), -r);
1738         abort();
1739     }
1740 }
1741
1742 static void kvm_io_ioeventfd_del(MemoryListener *listener,
1743                                  MemoryRegionSection *section,
1744                                  bool match_data, uint64_t data,
1745                                  EventNotifier *e)
1746
1747 {
1748     int fd = event_notifier_get_fd(e);
1749     int r;
1750
1751     r = kvm_set_ioeventfd_pio(fd, section->offset_within_address_space,
1752                               data, false, int128_get64(section->size),
1753                               match_data);
1754     if (r < 0) {
1755         fprintf(stderr, "%s: error deleting ioeventfd: %s (%d)\n",
1756                 __func__, strerror(-r), -r);
1757         abort();
1758     }
1759 }
1760
1761 void kvm_memory_listener_register(KVMState *s, KVMMemoryListener *kml,
1762                                   AddressSpace *as, int as_id, const char *name)
1763 {
1764     int i;
1765
1766     kml->slots = g_new0(KVMSlot, s->nr_slots);
1767     kml->as_id = as_id;
1768
1769     for (i = 0; i < s->nr_slots; i++) {
1770         kml->slots[i].slot = i;
1771     }
1772
1773     QSIMPLEQ_INIT(&kml->transaction_add);
1774     QSIMPLEQ_INIT(&kml->transaction_del);
1775
1776     kml->listener.region_add = kvm_region_add;
1777     kml->listener.region_del = kvm_region_del;
1778     kml->listener.commit = kvm_region_commit;
1779     kml->listener.log_start = kvm_log_start;
1780     kml->listener.log_stop = kvm_log_stop;
1781     kml->listener.priority = MEMORY_LISTENER_PRIORITY_ACCEL;
1782     kml->listener.name = name;
1783
1784     if (s->kvm_dirty_ring_size) {
1785         kml->listener.log_sync_global = kvm_log_sync_global;
1786     } else {
1787         kml->listener.log_sync = kvm_log_sync;
1788         kml->listener.log_clear = kvm_log_clear;
1789     }
1790
1791     memory_listener_register(&kml->listener, as);
1792
1793     for (i = 0; i < s->nr_as; ++i) {
1794         if (!s->as[i].as) {
1795             s->as[i].as = as;
1796             s->as[i].ml = kml;
1797             break;
1798         }
1799     }
1800 }
1801
1802 static MemoryListener kvm_io_listener = {
1803     .name = "kvm-io",
1804     .eventfd_add = kvm_io_ioeventfd_add,
1805     .eventfd_del = kvm_io_ioeventfd_del,
1806     .priority = MEMORY_LISTENER_PRIORITY_DEV_BACKEND,
1807 };
1808
1809 int kvm_set_irq(KVMState *s, int irq, int level)
1810 {
1811     struct kvm_irq_level event;
1812     int ret;
1813
1814     assert(kvm_async_interrupts_enabled());
1815
1816     event.level = level;
1817     event.irq = irq;
1818     ret = kvm_vm_ioctl(s, s->irq_set_ioctl, &event);
1819     if (ret < 0) {
1820         perror("kvm_set_irq");
1821         abort();
1822     }
1823
1824     return (s->irq_set_ioctl == KVM_IRQ_LINE) ? 1 : event.status;
1825 }
1826
1827 #ifdef KVM_CAP_IRQ_ROUTING
1828 typedef struct KVMMSIRoute {
1829     struct kvm_irq_routing_entry kroute;
1830     QTAILQ_ENTRY(KVMMSIRoute) entry;
1831 } KVMMSIRoute;
1832
1833 static void set_gsi(KVMState *s, unsigned int gsi)
1834 {
1835     set_bit(gsi, s->used_gsi_bitmap);
1836 }
1837
1838 static void clear_gsi(KVMState *s, unsigned int gsi)
1839 {
1840     clear_bit(gsi, s->used_gsi_bitmap);
1841 }
1842
1843 void kvm_init_irq_routing(KVMState *s)
1844 {
1845     int gsi_count, i;
1846
1847     gsi_count = kvm_check_extension(s, KVM_CAP_IRQ_ROUTING) - 1;
1848     if (gsi_count > 0) {
1849         /* Round up so we can search ints using ffs */
1850         s->used_gsi_bitmap = bitmap_new(gsi_count);
1851         s->gsi_count = gsi_count;
1852     }
1853
1854     s->irq_routes = g_malloc0(sizeof(*s->irq_routes));
1855     s->nr_allocated_irq_routes = 0;
1856
1857     if (!kvm_direct_msi_allowed) {
1858         for (i = 0; i < KVM_MSI_HASHTAB_SIZE; i++) {
1859             QTAILQ_INIT(&s->msi_hashtab[i]);
1860         }
1861     }
1862
1863     kvm_arch_init_irq_routing(s);
1864 }
1865
1866 void kvm_irqchip_commit_routes(KVMState *s)
1867 {
1868     int ret;
1869
1870     if (kvm_gsi_direct_mapping()) {
1871         return;
1872     }
1873
1874     if (!kvm_gsi_routing_enabled()) {
1875         return;
1876     }
1877
1878     s->irq_routes->flags = 0;
1879     trace_kvm_irqchip_commit_routes();
1880     ret = kvm_vm_ioctl(s, KVM_SET_GSI_ROUTING, s->irq_routes);
1881     assert(ret == 0);
1882 }
1883
1884 static void kvm_add_routing_entry(KVMState *s,
1885                                   struct kvm_irq_routing_entry *entry)
1886 {
1887     struct kvm_irq_routing_entry *new;
1888     int n, size;
1889
1890     if (s->irq_routes->nr == s->nr_allocated_irq_routes) {
1891         n = s->nr_allocated_irq_routes * 2;
1892         if (n < 64) {
1893             n = 64;
1894         }
1895         size = sizeof(struct kvm_irq_routing);
1896         size += n * sizeof(*new);
1897         s->irq_routes = g_realloc(s->irq_routes, size);
1898         s->nr_allocated_irq_routes = n;
1899     }
1900     n = s->irq_routes->nr++;
1901     new = &s->irq_routes->entries[n];
1902
1903     *new = *entry;
1904
1905     set_gsi(s, entry->gsi);
1906 }
1907
1908 static int kvm_update_routing_entry(KVMState *s,
1909                                     struct kvm_irq_routing_entry *new_entry)
1910 {
1911     struct kvm_irq_routing_entry *entry;
1912     int n;
1913
1914     for (n = 0; n < s->irq_routes->nr; n++) {
1915         entry = &s->irq_routes->entries[n];
1916         if (entry->gsi != new_entry->gsi) {
1917             continue;
1918         }
1919
1920         if(!memcmp(entry, new_entry, sizeof *entry)) {
1921             return 0;
1922         }
1923
1924         *entry = *new_entry;
1925
1926         return 0;
1927     }
1928
1929     return -ESRCH;
1930 }
1931
1932 void kvm_irqchip_add_irq_route(KVMState *s, int irq, int irqchip, int pin)
1933 {
1934     struct kvm_irq_routing_entry e = {};
1935
1936     assert(pin < s->gsi_count);
1937
1938     e.gsi = irq;
1939     e.type = KVM_IRQ_ROUTING_IRQCHIP;
1940     e.flags = 0;
1941     e.u.irqchip.irqchip = irqchip;
1942     e.u.irqchip.pin = pin;
1943     kvm_add_routing_entry(s, &e);
1944 }
1945
1946 void kvm_irqchip_release_virq(KVMState *s, int virq)
1947 {
1948     struct kvm_irq_routing_entry *e;
1949     int i;
1950
1951     if (kvm_gsi_direct_mapping()) {
1952         return;
1953     }
1954
1955     for (i = 0; i < s->irq_routes->nr; i++) {
1956         e = &s->irq_routes->entries[i];
1957         if (e->gsi == virq) {
1958             s->irq_routes->nr--;
1959             *e = s->irq_routes->entries[s->irq_routes->nr];
1960         }
1961     }
1962     clear_gsi(s, virq);
1963     kvm_arch_release_virq_post(virq);
1964     trace_kvm_irqchip_release_virq(virq);
1965 }
1966
1967 void kvm_irqchip_add_change_notifier(Notifier *n)
1968 {
1969     notifier_list_add(&kvm_irqchip_change_notifiers, n);
1970 }
1971
1972 void kvm_irqchip_remove_change_notifier(Notifier *n)
1973 {
1974     notifier_remove(n);
1975 }
1976
1977 void kvm_irqchip_change_notify(void)
1978 {
1979     notifier_list_notify(&kvm_irqchip_change_notifiers, NULL);
1980 }
1981
1982 static unsigned int kvm_hash_msi(uint32_t data)
1983 {
1984     /* This is optimized for IA32 MSI layout. However, no other arch shall
1985      * repeat the mistake of not providing a direct MSI injection API. */
1986     return data & 0xff;
1987 }
1988
1989 static void kvm_flush_dynamic_msi_routes(KVMState *s)
1990 {
1991     KVMMSIRoute *route, *next;
1992     unsigned int hash;
1993
1994     for (hash = 0; hash < KVM_MSI_HASHTAB_SIZE; hash++) {
1995         QTAILQ_FOREACH_SAFE(route, &s->msi_hashtab[hash], entry, next) {
1996             kvm_irqchip_release_virq(s, route->kroute.gsi);
1997             QTAILQ_REMOVE(&s->msi_hashtab[hash], route, entry);
1998             g_free(route);
1999         }
2000     }
2001 }
2002
2003 static int kvm_irqchip_get_virq(KVMState *s)
2004 {
2005     int next_virq;
2006
2007     /*
2008      * PIC and IOAPIC share the first 16 GSI numbers, thus the available
2009      * GSI numbers are more than the number of IRQ route. Allocating a GSI
2010      * number can succeed even though a new route entry cannot be added.
2011      * When this happens, flush dynamic MSI entries to free IRQ route entries.
2012      */
2013     if (!kvm_direct_msi_allowed && s->irq_routes->nr == s->gsi_count) {
2014         kvm_flush_dynamic_msi_routes(s);
2015     }
2016
2017     /* Return the lowest unused GSI in the bitmap */
2018     next_virq = find_first_zero_bit(s->used_gsi_bitmap, s->gsi_count);
2019     if (next_virq >= s->gsi_count) {
2020         return -ENOSPC;
2021     } else {
2022         return next_virq;
2023     }
2024 }
2025
2026 static KVMMSIRoute *kvm_lookup_msi_route(KVMState *s, MSIMessage msg)
2027 {
2028     unsigned int hash = kvm_hash_msi(msg.data);
2029     KVMMSIRoute *route;
2030
2031     QTAILQ_FOREACH(route, &s->msi_hashtab[hash], entry) {
2032         if (route->kroute.u.msi.address_lo == (uint32_t)msg.address &&
2033             route->kroute.u.msi.address_hi == (msg.address >> 32) &&
2034             route->kroute.u.msi.data == le32_to_cpu(msg.data)) {
2035             return route;
2036         }
2037     }
2038     return NULL;
2039 }
2040
2041 int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg)
2042 {
2043     struct kvm_msi msi;
2044     KVMMSIRoute *route;
2045
2046     if (kvm_direct_msi_allowed) {
2047         msi.address_lo = (uint32_t)msg.address;
2048         msi.address_hi = msg.address >> 32;
2049         msi.data = le32_to_cpu(msg.data);
2050         msi.flags = 0;
2051         memset(msi.pad, 0, sizeof(msi.pad));
2052
2053         return kvm_vm_ioctl(s, KVM_SIGNAL_MSI, &msi);
2054     }
2055
2056     route = kvm_lookup_msi_route(s, msg);
2057     if (!route) {
2058         int virq;
2059
2060         virq = kvm_irqchip_get_virq(s);
2061         if (virq < 0) {
2062             return virq;
2063         }
2064
2065         route = g_new0(KVMMSIRoute, 1);
2066         route->kroute.gsi = virq;
2067         route->kroute.type = KVM_IRQ_ROUTING_MSI;
2068         route->kroute.flags = 0;
2069         route->kroute.u.msi.address_lo = (uint32_t)msg.address;
2070         route->kroute.u.msi.address_hi = msg.address >> 32;
2071         route->kroute.u.msi.data = le32_to_cpu(msg.data);
2072
2073         kvm_add_routing_entry(s, &route->kroute);
2074         kvm_irqchip_commit_routes(s);
2075
2076         QTAILQ_INSERT_TAIL(&s->msi_hashtab[kvm_hash_msi(msg.data)], route,
2077                            entry);
2078     }
2079
2080     assert(route->kroute.type == KVM_IRQ_ROUTING_MSI);
2081
2082     return kvm_set_irq(s, route->kroute.gsi, 1);
2083 }
2084
2085 int kvm_irqchip_add_msi_route(KVMRouteChange *c, int vector, PCIDevice *dev)
2086 {
2087     struct kvm_irq_routing_entry kroute = {};
2088     int virq;
2089     KVMState *s = c->s;
2090     MSIMessage msg = {0, 0};
2091
2092     if (pci_available && dev) {
2093         msg = pci_get_msi_message(dev, vector);
2094     }
2095
2096     if (kvm_gsi_direct_mapping()) {
2097         return kvm_arch_msi_data_to_gsi(msg.data);
2098     }
2099
2100     if (!kvm_gsi_routing_enabled()) {
2101         return -ENOSYS;
2102     }
2103
2104     virq = kvm_irqchip_get_virq(s);
2105     if (virq < 0) {
2106         return virq;
2107     }
2108
2109     kroute.gsi = virq;
2110     kroute.type = KVM_IRQ_ROUTING_MSI;
2111     kroute.flags = 0;
2112     kroute.u.msi.address_lo = (uint32_t)msg.address;
2113     kroute.u.msi.address_hi = msg.address >> 32;
2114     kroute.u.msi.data = le32_to_cpu(msg.data);
2115     if (pci_available && kvm_msi_devid_required()) {
2116         kroute.flags = KVM_MSI_VALID_DEVID;
2117         kroute.u.msi.devid = pci_requester_id(dev);
2118     }
2119     if (kvm_arch_fixup_msi_route(&kroute, msg.address, msg.data, dev)) {
2120         kvm_irqchip_release_virq(s, virq);
2121         return -EINVAL;
2122     }
2123
2124     trace_kvm_irqchip_add_msi_route(dev ? dev->name : (char *)"N/A",
2125                                     vector, virq);
2126
2127     kvm_add_routing_entry(s, &kroute);
2128     kvm_arch_add_msi_route_post(&kroute, vector, dev);
2129     c->changes++;
2130
2131     return virq;
2132 }
2133
2134 int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg,
2135                                  PCIDevice *dev)
2136 {
2137     struct kvm_irq_routing_entry kroute = {};
2138
2139     if (kvm_gsi_direct_mapping()) {
2140         return 0;
2141     }
2142
2143     if (!kvm_irqchip_in_kernel()) {
2144         return -ENOSYS;
2145     }
2146
2147     kroute.gsi = virq;
2148     kroute.type = KVM_IRQ_ROUTING_MSI;
2149     kroute.flags = 0;
2150     kroute.u.msi.address_lo = (uint32_t)msg.address;
2151     kroute.u.msi.address_hi = msg.address >> 32;
2152     kroute.u.msi.data = le32_to_cpu(msg.data);
2153     if (pci_available && kvm_msi_devid_required()) {
2154         kroute.flags = KVM_MSI_VALID_DEVID;
2155         kroute.u.msi.devid = pci_requester_id(dev);
2156     }
2157     if (kvm_arch_fixup_msi_route(&kroute, msg.address, msg.data, dev)) {
2158         return -EINVAL;
2159     }
2160
2161     trace_kvm_irqchip_update_msi_route(virq);
2162
2163     return kvm_update_routing_entry(s, &kroute);
2164 }
2165
2166 static int kvm_irqchip_assign_irqfd(KVMState *s, EventNotifier *event,
2167                                     EventNotifier *resample, int virq,
2168                                     bool assign)
2169 {
2170     int fd = event_notifier_get_fd(event);
2171     int rfd = resample ? event_notifier_get_fd(resample) : -1;
2172
2173     struct kvm_irqfd irqfd = {
2174         .fd = fd,
2175         .gsi = virq,
2176         .flags = assign ? 0 : KVM_IRQFD_FLAG_DEASSIGN,
2177     };
2178
2179     if (rfd != -1) {
2180         assert(assign);
2181         if (kvm_irqchip_is_split()) {
2182             /*
2183              * When the slow irqchip (e.g. IOAPIC) is in the
2184              * userspace, KVM kernel resamplefd will not work because
2185              * the EOI of the interrupt will be delivered to userspace
2186              * instead, so the KVM kernel resamplefd kick will be
2187              * skipped.  The userspace here mimics what the kernel
2188              * provides with resamplefd, remember the resamplefd and
2189              * kick it when we receive EOI of this IRQ.
2190              *
2191              * This is hackery because IOAPIC is mostly bypassed
2192              * (except EOI broadcasts) when irqfd is used.  However
2193              * this can bring much performance back for split irqchip
2194              * with INTx IRQs (for VFIO, this gives 93% perf of the
2195              * full fast path, which is 46% perf boost comparing to
2196              * the INTx slow path).
2197              */
2198             kvm_resample_fd_insert(virq, resample);
2199         } else {
2200             irqfd.flags |= KVM_IRQFD_FLAG_RESAMPLE;
2201             irqfd.resamplefd = rfd;
2202         }
2203     } else if (!assign) {
2204         if (kvm_irqchip_is_split()) {
2205             kvm_resample_fd_remove(virq);
2206         }
2207     }
2208
2209     if (!kvm_irqfds_enabled()) {
2210         return -ENOSYS;
2211     }
2212
2213     return kvm_vm_ioctl(s, KVM_IRQFD, &irqfd);
2214 }
2215
2216 int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter)
2217 {
2218     struct kvm_irq_routing_entry kroute = {};
2219     int virq;
2220
2221     if (!kvm_gsi_routing_enabled()) {
2222         return -ENOSYS;
2223     }
2224
2225     virq = kvm_irqchip_get_virq(s);
2226     if (virq < 0) {
2227         return virq;
2228     }
2229
2230     kroute.gsi = virq;
2231     kroute.type = KVM_IRQ_ROUTING_S390_ADAPTER;
2232     kroute.flags = 0;
2233     kroute.u.adapter.summary_addr = adapter->summary_addr;
2234     kroute.u.adapter.ind_addr = adapter->ind_addr;
2235     kroute.u.adapter.summary_offset = adapter->summary_offset;
2236     kroute.u.adapter.ind_offset = adapter->ind_offset;
2237     kroute.u.adapter.adapter_id = adapter->adapter_id;
2238
2239     kvm_add_routing_entry(s, &kroute);
2240
2241     return virq;
2242 }
2243
2244 int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint)
2245 {
2246     struct kvm_irq_routing_entry kroute = {};
2247     int virq;
2248
2249     if (!kvm_gsi_routing_enabled()) {
2250         return -ENOSYS;
2251     }
2252     if (!kvm_check_extension(s, KVM_CAP_HYPERV_SYNIC)) {
2253         return -ENOSYS;
2254     }
2255     virq = kvm_irqchip_get_virq(s);
2256     if (virq < 0) {
2257         return virq;
2258     }
2259
2260     kroute.gsi = virq;
2261     kroute.type = KVM_IRQ_ROUTING_HV_SINT;
2262     kroute.flags = 0;
2263     kroute.u.hv_sint.vcpu = vcpu;
2264     kroute.u.hv_sint.sint = sint;
2265
2266     kvm_add_routing_entry(s, &kroute);
2267     kvm_irqchip_commit_routes(s);
2268
2269     return virq;
2270 }
2271
2272 #else /* !KVM_CAP_IRQ_ROUTING */
2273
2274 void kvm_init_irq_routing(KVMState *s)
2275 {
2276 }
2277
2278 void kvm_irqchip_release_virq(KVMState *s, int virq)
2279 {
2280 }
2281
2282 int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg)
2283 {
2284     abort();
2285 }
2286
2287 int kvm_irqchip_add_msi_route(KVMRouteChange *c, int vector, PCIDevice *dev)
2288 {
2289     return -ENOSYS;
2290 }
2291
2292 int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter)
2293 {
2294     return -ENOSYS;
2295 }
2296
2297 int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint)
2298 {
2299     return -ENOSYS;
2300 }
2301
2302 static int kvm_irqchip_assign_irqfd(KVMState *s, EventNotifier *event,
2303                                     EventNotifier *resample, int virq,
2304                                     bool assign)
2305 {
2306     abort();
2307 }
2308
2309 int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg)
2310 {
2311     return -ENOSYS;
2312 }
2313 #endif /* !KVM_CAP_IRQ_ROUTING */
2314
2315 int kvm_irqchip_add_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
2316                                        EventNotifier *rn, int virq)
2317 {
2318     return kvm_irqchip_assign_irqfd(s, n, rn, virq, true);
2319 }
2320
2321 int kvm_irqchip_remove_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
2322                                           int virq)
2323 {
2324     return kvm_irqchip_assign_irqfd(s, n, NULL, virq, false);
2325 }
2326
2327 int kvm_irqchip_add_irqfd_notifier(KVMState *s, EventNotifier *n,
2328                                    EventNotifier *rn, qemu_irq irq)
2329 {
2330     gpointer key, gsi;
2331     gboolean found = g_hash_table_lookup_extended(s->gsimap, irq, &key, &gsi);
2332
2333     if (!found) {
2334         return -ENXIO;
2335     }
2336     return kvm_irqchip_add_irqfd_notifier_gsi(s, n, rn, GPOINTER_TO_INT(gsi));
2337 }
2338
2339 int kvm_irqchip_remove_irqfd_notifier(KVMState *s, EventNotifier *n,
2340                                       qemu_irq irq)
2341 {
2342     gpointer key, gsi;
2343     gboolean found = g_hash_table_lookup_extended(s->gsimap, irq, &key, &gsi);
2344
2345     if (!found) {
2346         return -ENXIO;
2347     }
2348     return kvm_irqchip_remove_irqfd_notifier_gsi(s, n, GPOINTER_TO_INT(gsi));
2349 }
2350
2351 void kvm_irqchip_set_qemuirq_gsi(KVMState *s, qemu_irq irq, int gsi)
2352 {
2353     g_hash_table_insert(s->gsimap, irq, GINT_TO_POINTER(gsi));
2354 }
2355
2356 static void kvm_irqchip_create(KVMState *s)
2357 {
2358     int ret;
2359
2360     assert(s->kernel_irqchip_split != ON_OFF_AUTO_AUTO);
2361     if (kvm_check_extension(s, KVM_CAP_IRQCHIP)) {
2362         ;
2363     } else if (kvm_check_extension(s, KVM_CAP_S390_IRQCHIP)) {
2364         ret = kvm_vm_enable_cap(s, KVM_CAP_S390_IRQCHIP, 0);
2365         if (ret < 0) {
2366             fprintf(stderr, "Enable kernel irqchip failed: %s\n", strerror(-ret));
2367             exit(1);
2368         }
2369     } else {
2370         return;
2371     }
2372
2373     /* First probe and see if there's a arch-specific hook to create the
2374      * in-kernel irqchip for us */
2375     ret = kvm_arch_irqchip_create(s);
2376     if (ret == 0) {
2377         if (s->kernel_irqchip_split == ON_OFF_AUTO_ON) {
2378             error_report("Split IRQ chip mode not supported.");
2379             exit(1);
2380         } else {
2381             ret = kvm_vm_ioctl(s, KVM_CREATE_IRQCHIP);
2382         }
2383     }
2384     if (ret < 0) {
2385         fprintf(stderr, "Create kernel irqchip failed: %s\n", strerror(-ret));
2386         exit(1);
2387     }
2388
2389     kvm_kernel_irqchip = true;
2390     /* If we have an in-kernel IRQ chip then we must have asynchronous
2391      * interrupt delivery (though the reverse is not necessarily true)
2392      */
2393     kvm_async_interrupts_allowed = true;
2394     kvm_halt_in_kernel_allowed = true;
2395
2396     kvm_init_irq_routing(s);
2397
2398     s->gsimap = g_hash_table_new(g_direct_hash, g_direct_equal);
2399 }
2400
2401 /* Find number of supported CPUs using the recommended
2402  * procedure from the kernel API documentation to cope with
2403  * older kernels that may be missing capabilities.
2404  */
2405 static int kvm_recommended_vcpus(KVMState *s)
2406 {
2407     int ret = kvm_vm_check_extension(s, KVM_CAP_NR_VCPUS);
2408     return (ret) ? ret : 4;
2409 }
2410
2411 static int kvm_max_vcpus(KVMState *s)
2412 {
2413     int ret = kvm_check_extension(s, KVM_CAP_MAX_VCPUS);
2414     return (ret) ? ret : kvm_recommended_vcpus(s);
2415 }
2416
2417 static int kvm_max_vcpu_id(KVMState *s)
2418 {
2419     int ret = kvm_check_extension(s, KVM_CAP_MAX_VCPU_ID);
2420     return (ret) ? ret : kvm_max_vcpus(s);
2421 }
2422
2423 bool kvm_vcpu_id_is_valid(int vcpu_id)
2424 {
2425     KVMState *s = KVM_STATE(current_accel());
2426     return vcpu_id >= 0 && vcpu_id < kvm_max_vcpu_id(s);
2427 }
2428
2429 bool kvm_dirty_ring_enabled(void)
2430 {
2431     return kvm_state->kvm_dirty_ring_size ? true : false;
2432 }
2433
2434 static void query_stats_cb(StatsResultList **result, StatsTarget target,
2435                            strList *names, strList *targets, Error **errp);
2436 static void query_stats_schemas_cb(StatsSchemaList **result, Error **errp);
2437
2438 uint32_t kvm_dirty_ring_size(void)
2439 {
2440     return kvm_state->kvm_dirty_ring_size;
2441 }
2442
2443 static int kvm_init(MachineState *ms)
2444 {
2445     MachineClass *mc = MACHINE_GET_CLASS(ms);
2446     static const char upgrade_note[] =
2447         "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
2448         "(see http://sourceforge.net/projects/kvm).\n";
2449     const struct {
2450         const char *name;
2451         int num;
2452     } num_cpus[] = {
2453         { "SMP",          ms->smp.cpus },
2454         { "hotpluggable", ms->smp.max_cpus },
2455         { /* end of list */ }
2456     }, *nc = num_cpus;
2457     int soft_vcpus_limit, hard_vcpus_limit;
2458     KVMState *s;
2459     const KVMCapabilityInfo *missing_cap;
2460     int ret;
2461     int type;
2462     uint64_t dirty_log_manual_caps;
2463
2464     qemu_mutex_init(&kml_slots_lock);
2465
2466     s = KVM_STATE(ms->accelerator);
2467
2468     /*
2469      * On systems where the kernel can support different base page
2470      * sizes, host page size may be different from TARGET_PAGE_SIZE,
2471      * even with KVM.  TARGET_PAGE_SIZE is assumed to be the minimum
2472      * page size for the system though.
2473      */
2474     assert(TARGET_PAGE_SIZE <= qemu_real_host_page_size());
2475
2476     s->sigmask_len = 8;
2477     accel_blocker_init();
2478
2479 #ifdef KVM_CAP_SET_GUEST_DEBUG
2480     QTAILQ_INIT(&s->kvm_sw_breakpoints);
2481 #endif
2482     QLIST_INIT(&s->kvm_parked_vcpus);
2483     s->fd = qemu_open_old("/dev/kvm", O_RDWR);
2484     if (s->fd == -1) {
2485         fprintf(stderr, "Could not access KVM kernel module: %m\n");
2486         ret = -errno;
2487         goto err;
2488     }
2489
2490     ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
2491     if (ret < KVM_API_VERSION) {
2492         if (ret >= 0) {
2493             ret = -EINVAL;
2494         }
2495         fprintf(stderr, "kvm version too old\n");
2496         goto err;
2497     }
2498
2499     if (ret > KVM_API_VERSION) {
2500         ret = -EINVAL;
2501         fprintf(stderr, "kvm version not supported\n");
2502         goto err;
2503     }
2504
2505     kvm_immediate_exit = kvm_check_extension(s, KVM_CAP_IMMEDIATE_EXIT);
2506     s->nr_slots = kvm_check_extension(s, KVM_CAP_NR_MEMSLOTS);
2507
2508     /* If unspecified, use the default value */
2509     if (!s->nr_slots) {
2510         s->nr_slots = 32;
2511     }
2512
2513     s->nr_as = kvm_check_extension(s, KVM_CAP_MULTI_ADDRESS_SPACE);
2514     if (s->nr_as <= 1) {
2515         s->nr_as = 1;
2516     }
2517     s->as = g_new0(struct KVMAs, s->nr_as);
2518
2519     if (object_property_find(OBJECT(current_machine), "kvm-type")) {
2520         g_autofree char *kvm_type = object_property_get_str(OBJECT(current_machine),
2521                                                             "kvm-type",
2522                                                             &error_abort);
2523         type = mc->kvm_type(ms, kvm_type);
2524     } else if (mc->kvm_type) {
2525         type = mc->kvm_type(ms, NULL);
2526     } else {
2527         type = kvm_arch_get_default_type(ms);
2528     }
2529
2530     do {
2531         ret = kvm_ioctl(s, KVM_CREATE_VM, type);
2532     } while (ret == -EINTR);
2533
2534     if (ret < 0) {
2535         fprintf(stderr, "ioctl(KVM_CREATE_VM) failed: %d %s\n", -ret,
2536                 strerror(-ret));
2537
2538 #ifdef TARGET_S390X
2539         if (ret == -EINVAL) {
2540             fprintf(stderr,
2541                     "Host kernel setup problem detected. Please verify:\n");
2542             fprintf(stderr, "- for kernels supporting the switch_amode or"
2543                     " user_mode parameters, whether\n");
2544             fprintf(stderr,
2545                     "  user space is running in primary address space\n");
2546             fprintf(stderr,
2547                     "- for kernels supporting the vm.allocate_pgste sysctl, "
2548                     "whether it is enabled\n");
2549         }
2550 #elif defined(TARGET_PPC)
2551         if (ret == -EINVAL) {
2552             fprintf(stderr,
2553                     "PPC KVM module is not loaded. Try modprobe kvm_%s.\n",
2554                     (type == 2) ? "pr" : "hv");
2555         }
2556 #endif
2557         goto err;
2558     }
2559
2560     s->vmfd = ret;
2561
2562     /* check the vcpu limits */
2563     soft_vcpus_limit = kvm_recommended_vcpus(s);
2564     hard_vcpus_limit = kvm_max_vcpus(s);
2565
2566     while (nc->name) {
2567         if (nc->num > soft_vcpus_limit) {
2568             warn_report("Number of %s cpus requested (%d) exceeds "
2569                         "the recommended cpus supported by KVM (%d)",
2570                         nc->name, nc->num, soft_vcpus_limit);
2571
2572             if (nc->num > hard_vcpus_limit) {
2573                 fprintf(stderr, "Number of %s cpus requested (%d) exceeds "
2574                         "the maximum cpus supported by KVM (%d)\n",
2575                         nc->name, nc->num, hard_vcpus_limit);
2576                 exit(1);
2577             }
2578         }
2579         nc++;
2580     }
2581
2582     missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
2583     if (!missing_cap) {
2584         missing_cap =
2585             kvm_check_extension_list(s, kvm_arch_required_capabilities);
2586     }
2587     if (missing_cap) {
2588         ret = -EINVAL;
2589         fprintf(stderr, "kvm does not support %s\n%s",
2590                 missing_cap->name, upgrade_note);
2591         goto err;
2592     }
2593
2594     s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
2595     s->coalesced_pio = s->coalesced_mmio &&
2596                        kvm_check_extension(s, KVM_CAP_COALESCED_PIO);
2597
2598     /*
2599      * Enable KVM dirty ring if supported, otherwise fall back to
2600      * dirty logging mode
2601      */
2602     ret = kvm_dirty_ring_init(s);
2603     if (ret < 0) {
2604         goto err;
2605     }
2606
2607     /*
2608      * KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2 is not needed when dirty ring is
2609      * enabled.  More importantly, KVM_DIRTY_LOG_INITIALLY_SET will assume no
2610      * page is wr-protected initially, which is against how kvm dirty ring is
2611      * usage - kvm dirty ring requires all pages are wr-protected at the very
2612      * beginning.  Enabling this feature for dirty ring causes data corruption.
2613      *
2614      * TODO: Without KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2 and kvm clear dirty log,
2615      * we may expect a higher stall time when starting the migration.  In the
2616      * future we can enable KVM_CLEAR_DIRTY_LOG to work with dirty ring too:
2617      * instead of clearing dirty bit, it can be a way to explicitly wr-protect
2618      * guest pages.
2619      */
2620     if (!s->kvm_dirty_ring_size) {
2621         dirty_log_manual_caps =
2622             kvm_check_extension(s, KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2);
2623         dirty_log_manual_caps &= (KVM_DIRTY_LOG_MANUAL_PROTECT_ENABLE |
2624                                   KVM_DIRTY_LOG_INITIALLY_SET);
2625         s->manual_dirty_log_protect = dirty_log_manual_caps;
2626         if (dirty_log_manual_caps) {
2627             ret = kvm_vm_enable_cap(s, KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2, 0,
2628                                     dirty_log_manual_caps);
2629             if (ret) {
2630                 warn_report("Trying to enable capability %"PRIu64" of "
2631                             "KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2 but failed. "
2632                             "Falling back to the legacy mode. ",
2633                             dirty_log_manual_caps);
2634                 s->manual_dirty_log_protect = 0;
2635             }
2636         }
2637     }
2638
2639 #ifdef KVM_CAP_VCPU_EVENTS
2640     s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
2641 #endif
2642
2643     s->robust_singlestep =
2644         kvm_check_extension(s, KVM_CAP_X86_ROBUST_SINGLESTEP);
2645
2646 #ifdef KVM_CAP_DEBUGREGS
2647     s->debugregs = kvm_check_extension(s, KVM_CAP_DEBUGREGS);
2648 #endif
2649
2650     s->max_nested_state_len = kvm_check_extension(s, KVM_CAP_NESTED_STATE);
2651
2652 #ifdef KVM_CAP_IRQ_ROUTING
2653     kvm_direct_msi_allowed = (kvm_check_extension(s, KVM_CAP_SIGNAL_MSI) > 0);
2654 #endif
2655
2656     s->intx_set_mask = kvm_check_extension(s, KVM_CAP_PCI_2_3);
2657
2658     s->irq_set_ioctl = KVM_IRQ_LINE;
2659     if (kvm_check_extension(s, KVM_CAP_IRQ_INJECT_STATUS)) {
2660         s->irq_set_ioctl = KVM_IRQ_LINE_STATUS;
2661     }
2662
2663     kvm_readonly_mem_allowed =
2664         (kvm_check_extension(s, KVM_CAP_READONLY_MEM) > 0);
2665
2666     kvm_eventfds_allowed =
2667         (kvm_check_extension(s, KVM_CAP_IOEVENTFD) > 0);
2668
2669     kvm_irqfds_allowed =
2670         (kvm_check_extension(s, KVM_CAP_IRQFD) > 0);
2671
2672     kvm_resamplefds_allowed =
2673         (kvm_check_extension(s, KVM_CAP_IRQFD_RESAMPLE) > 0);
2674
2675     kvm_vm_attributes_allowed =
2676         (kvm_check_extension(s, KVM_CAP_VM_ATTRIBUTES) > 0);
2677
2678     kvm_ioeventfd_any_length_allowed =
2679         (kvm_check_extension(s, KVM_CAP_IOEVENTFD_ANY_LENGTH) > 0);
2680
2681 #ifdef KVM_CAP_SET_GUEST_DEBUG
2682     kvm_has_guest_debug =
2683         (kvm_check_extension(s, KVM_CAP_SET_GUEST_DEBUG) > 0);
2684 #endif
2685
2686     kvm_sstep_flags = 0;
2687     if (kvm_has_guest_debug) {
2688         kvm_sstep_flags = SSTEP_ENABLE;
2689
2690 #if defined KVM_CAP_SET_GUEST_DEBUG2
2691         int guest_debug_flags =
2692             kvm_check_extension(s, KVM_CAP_SET_GUEST_DEBUG2);
2693
2694         if (guest_debug_flags & KVM_GUESTDBG_BLOCKIRQ) {
2695             kvm_sstep_flags |= SSTEP_NOIRQ;
2696         }
2697 #endif
2698     }
2699
2700     kvm_state = s;
2701
2702     ret = kvm_arch_init(ms, s);
2703     if (ret < 0) {
2704         goto err;
2705     }
2706
2707     if (s->kernel_irqchip_split == ON_OFF_AUTO_AUTO) {
2708         s->kernel_irqchip_split = mc->default_kernel_irqchip_split ? ON_OFF_AUTO_ON : ON_OFF_AUTO_OFF;
2709     }
2710
2711     qemu_register_reset(kvm_unpoison_all, NULL);
2712
2713     if (s->kernel_irqchip_allowed) {
2714         kvm_irqchip_create(s);
2715     }
2716
2717     if (kvm_eventfds_allowed) {
2718         s->memory_listener.listener.eventfd_add = kvm_mem_ioeventfd_add;
2719         s->memory_listener.listener.eventfd_del = kvm_mem_ioeventfd_del;
2720     }
2721     s->memory_listener.listener.coalesced_io_add = kvm_coalesce_mmio_region;
2722     s->memory_listener.listener.coalesced_io_del = kvm_uncoalesce_mmio_region;
2723
2724     kvm_memory_listener_register(s, &s->memory_listener,
2725                                  &address_space_memory, 0, "kvm-memory");
2726     if (kvm_eventfds_allowed) {
2727         memory_listener_register(&kvm_io_listener,
2728                                  &address_space_io);
2729     }
2730     memory_listener_register(&kvm_coalesced_pio_listener,
2731                              &address_space_io);
2732
2733     s->many_ioeventfds = kvm_check_many_ioeventfds();
2734
2735     s->sync_mmu = !!kvm_vm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);
2736     if (!s->sync_mmu) {
2737         ret = ram_block_discard_disable(true);
2738         assert(!ret);
2739     }
2740
2741     if (s->kvm_dirty_ring_size) {
2742         ret = kvm_dirty_ring_reaper_init(s);
2743         if (ret) {
2744             goto err;
2745         }
2746     }
2747
2748     if (kvm_check_extension(kvm_state, KVM_CAP_BINARY_STATS_FD)) {
2749         add_stats_callbacks(STATS_PROVIDER_KVM, query_stats_cb,
2750                             query_stats_schemas_cb);
2751     }
2752
2753     return 0;
2754
2755 err:
2756     assert(ret < 0);
2757     if (s->vmfd >= 0) {
2758         close(s->vmfd);
2759     }
2760     if (s->fd != -1) {
2761         close(s->fd);
2762     }
2763     g_free(s->memory_listener.slots);
2764
2765     return ret;
2766 }
2767
2768 void kvm_set_sigmask_len(KVMState *s, unsigned int sigmask_len)
2769 {
2770     s->sigmask_len = sigmask_len;
2771 }
2772
2773 static void kvm_handle_io(uint16_t port, MemTxAttrs attrs, void *data, int direction,
2774                           int size, uint32_t count)
2775 {
2776     int i;
2777     uint8_t *ptr = data;
2778
2779     for (i = 0; i < count; i++) {
2780         address_space_rw(&address_space_io, port, attrs,
2781                          ptr, size,
2782                          direction == KVM_EXIT_IO_OUT);
2783         ptr += size;
2784     }
2785 }
2786
2787 static int kvm_handle_internal_error(CPUState *cpu, struct kvm_run *run)
2788 {
2789     fprintf(stderr, "KVM internal error. Suberror: %d\n",
2790             run->internal.suberror);
2791
2792     if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) {
2793         int i;
2794
2795         for (i = 0; i < run->internal.ndata; ++i) {
2796             fprintf(stderr, "extra data[%d]: 0x%016"PRIx64"\n",
2797                     i, (uint64_t)run->internal.data[i]);
2798         }
2799     }
2800     if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {
2801         fprintf(stderr, "emulation failure\n");
2802         if (!kvm_arch_stop_on_emulation_error(cpu)) {
2803             cpu_dump_state(cpu, stderr, CPU_DUMP_CODE);
2804             return EXCP_INTERRUPT;
2805         }
2806     }
2807     /* FIXME: Should trigger a qmp message to let management know
2808      * something went wrong.
2809      */
2810     return -1;
2811 }
2812
2813 void kvm_flush_coalesced_mmio_buffer(void)
2814 {
2815     KVMState *s = kvm_state;
2816
2817     if (!s || s->coalesced_flush_in_progress) {
2818         return;
2819     }
2820
2821     s->coalesced_flush_in_progress = true;
2822
2823     if (s->coalesced_mmio_ring) {
2824         struct kvm_coalesced_mmio_ring *ring = s->coalesced_mmio_ring;
2825         while (ring->first != ring->last) {
2826             struct kvm_coalesced_mmio *ent;
2827
2828             ent = &ring->coalesced_mmio[ring->first];
2829
2830             if (ent->pio == 1) {
2831                 address_space_write(&address_space_io, ent->phys_addr,
2832                                     MEMTXATTRS_UNSPECIFIED, ent->data,
2833                                     ent->len);
2834             } else {
2835                 cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
2836             }
2837             smp_wmb();
2838             ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
2839         }
2840     }
2841
2842     s->coalesced_flush_in_progress = false;
2843 }
2844
2845 bool kvm_cpu_check_are_resettable(void)
2846 {
2847     return kvm_arch_cpu_check_are_resettable();
2848 }
2849
2850 static void do_kvm_cpu_synchronize_state(CPUState *cpu, run_on_cpu_data arg)
2851 {
2852     if (!cpu->vcpu_dirty) {
2853         kvm_arch_get_registers(cpu);
2854         cpu->vcpu_dirty = true;
2855     }
2856 }
2857
2858 void kvm_cpu_synchronize_state(CPUState *cpu)
2859 {
2860     if (!cpu->vcpu_dirty) {
2861         run_on_cpu(cpu, do_kvm_cpu_synchronize_state, RUN_ON_CPU_NULL);
2862     }
2863 }
2864
2865 static void do_kvm_cpu_synchronize_post_reset(CPUState *cpu, run_on_cpu_data arg)
2866 {
2867     kvm_arch_put_registers(cpu, KVM_PUT_RESET_STATE);
2868     cpu->vcpu_dirty = false;
2869 }
2870
2871 void kvm_cpu_synchronize_post_reset(CPUState *cpu)
2872 {
2873     run_on_cpu(cpu, do_kvm_cpu_synchronize_post_reset, RUN_ON_CPU_NULL);
2874 }
2875
2876 static void do_kvm_cpu_synchronize_post_init(CPUState *cpu, run_on_cpu_data arg)
2877 {
2878     kvm_arch_put_registers(cpu, KVM_PUT_FULL_STATE);
2879     cpu->vcpu_dirty = false;
2880 }
2881
2882 void kvm_cpu_synchronize_post_init(CPUState *cpu)
2883 {
2884     run_on_cpu(cpu, do_kvm_cpu_synchronize_post_init, RUN_ON_CPU_NULL);
2885 }
2886
2887 static void do_kvm_cpu_synchronize_pre_loadvm(CPUState *cpu, run_on_cpu_data arg)
2888 {
2889     cpu->vcpu_dirty = true;
2890 }
2891
2892 void kvm_cpu_synchronize_pre_loadvm(CPUState *cpu)
2893 {
2894     run_on_cpu(cpu, do_kvm_cpu_synchronize_pre_loadvm, RUN_ON_CPU_NULL);
2895 }
2896
2897 #ifdef KVM_HAVE_MCE_INJECTION
2898 static __thread void *pending_sigbus_addr;
2899 static __thread int pending_sigbus_code;
2900 static __thread bool have_sigbus_pending;
2901 #endif
2902
2903 static void kvm_cpu_kick(CPUState *cpu)
2904 {
2905     qatomic_set(&cpu->kvm_run->immediate_exit, 1);
2906 }
2907
2908 static void kvm_cpu_kick_self(void)
2909 {
2910     if (kvm_immediate_exit) {
2911         kvm_cpu_kick(current_cpu);
2912     } else {
2913         qemu_cpu_kick_self();
2914     }
2915 }
2916
2917 static void kvm_eat_signals(CPUState *cpu)
2918 {
2919     struct timespec ts = { 0, 0 };
2920     siginfo_t siginfo;
2921     sigset_t waitset;
2922     sigset_t chkset;
2923     int r;
2924
2925     if (kvm_immediate_exit) {
2926         qatomic_set(&cpu->kvm_run->immediate_exit, 0);
2927         /* Write kvm_run->immediate_exit before the cpu->exit_request
2928          * write in kvm_cpu_exec.
2929          */
2930         smp_wmb();
2931         return;
2932     }
2933
2934     sigemptyset(&waitset);
2935     sigaddset(&waitset, SIG_IPI);
2936
2937     do {
2938         r = sigtimedwait(&waitset, &siginfo, &ts);
2939         if (r == -1 && !(errno == EAGAIN || errno == EINTR)) {
2940             perror("sigtimedwait");
2941             exit(1);
2942         }
2943
2944         r = sigpending(&chkset);
2945         if (r == -1) {
2946             perror("sigpending");
2947             exit(1);
2948         }
2949     } while (sigismember(&chkset, SIG_IPI));
2950 }
2951
2952 int kvm_cpu_exec(CPUState *cpu)
2953 {
2954     struct kvm_run *run = cpu->kvm_run;
2955     int ret, run_ret;
2956
2957     DPRINTF("kvm_cpu_exec()\n");
2958
2959     if (kvm_arch_process_async_events(cpu)) {
2960         qatomic_set(&cpu->exit_request, 0);
2961         return EXCP_HLT;
2962     }
2963
2964     qemu_mutex_unlock_iothread();
2965     cpu_exec_start(cpu);
2966
2967     do {
2968         MemTxAttrs attrs;
2969
2970         if (cpu->vcpu_dirty) {
2971             kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE);
2972             cpu->vcpu_dirty = false;
2973         }
2974
2975         kvm_arch_pre_run(cpu, run);
2976         if (qatomic_read(&cpu->exit_request)) {
2977             DPRINTF("interrupt exit requested\n");
2978             /*
2979              * KVM requires us to reenter the kernel after IO exits to complete
2980              * instruction emulation. This self-signal will ensure that we
2981              * leave ASAP again.
2982              */
2983             kvm_cpu_kick_self();
2984         }
2985
2986         /* Read cpu->exit_request before KVM_RUN reads run->immediate_exit.
2987          * Matching barrier in kvm_eat_signals.
2988          */
2989         smp_rmb();
2990
2991         run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
2992
2993         attrs = kvm_arch_post_run(cpu, run);
2994
2995 #ifdef KVM_HAVE_MCE_INJECTION
2996         if (unlikely(have_sigbus_pending)) {
2997             qemu_mutex_lock_iothread();
2998             kvm_arch_on_sigbus_vcpu(cpu, pending_sigbus_code,
2999                                     pending_sigbus_addr);
3000             have_sigbus_pending = false;
3001             qemu_mutex_unlock_iothread();
3002         }
3003 #endif
3004
3005         if (run_ret < 0) {
3006             if (run_ret == -EINTR || run_ret == -EAGAIN) {
3007                 DPRINTF("io window exit\n");
3008                 kvm_eat_signals(cpu);
3009                 ret = EXCP_INTERRUPT;
3010                 break;
3011             }
3012             fprintf(stderr, "error: kvm run failed %s\n",
3013                     strerror(-run_ret));
3014 #ifdef TARGET_PPC
3015             if (run_ret == -EBUSY) {
3016                 fprintf(stderr,
3017                         "This is probably because your SMT is enabled.\n"
3018                         "VCPU can only run on primary threads with all "
3019                         "secondary threads offline.\n");
3020             }
3021 #endif
3022             ret = -1;
3023             break;
3024         }
3025
3026         trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);
3027         switch (run->exit_reason) {
3028         case KVM_EXIT_IO:
3029             DPRINTF("handle_io\n");
3030             /* Called outside BQL */
3031             kvm_handle_io(run->io.port, attrs,
3032                           (uint8_t *)run + run->io.data_offset,
3033                           run->io.direction,
3034                           run->io.size,
3035                           run->io.count);
3036             ret = 0;
3037             break;
3038         case KVM_EXIT_MMIO:
3039             DPRINTF("handle_mmio\n");
3040             /* Called outside BQL */
3041             address_space_rw(&address_space_memory,
3042                              run->mmio.phys_addr, attrs,
3043                              run->mmio.data,
3044                              run->mmio.len,
3045                              run->mmio.is_write);
3046             ret = 0;
3047             break;
3048         case KVM_EXIT_IRQ_WINDOW_OPEN:
3049             DPRINTF("irq_window_open\n");
3050             ret = EXCP_INTERRUPT;
3051             break;
3052         case KVM_EXIT_SHUTDOWN:
3053             DPRINTF("shutdown\n");
3054             qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET);
3055             ret = EXCP_INTERRUPT;
3056             break;
3057         case KVM_EXIT_UNKNOWN:
3058             fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
3059                     (uint64_t)run->hw.hardware_exit_reason);
3060             ret = -1;
3061             break;
3062         case KVM_EXIT_INTERNAL_ERROR:
3063             ret = kvm_handle_internal_error(cpu, run);
3064             break;
3065         case KVM_EXIT_DIRTY_RING_FULL:
3066             /*
3067              * We shouldn't continue if the dirty ring of this vcpu is
3068              * still full.  Got kicked by KVM_RESET_DIRTY_RINGS.
3069              */
3070             trace_kvm_dirty_ring_full(cpu->cpu_index);
3071             qemu_mutex_lock_iothread();
3072             /*
3073              * We throttle vCPU by making it sleep once it exit from kernel
3074              * due to dirty ring full. In the dirtylimit scenario, reaping
3075              * all vCPUs after a single vCPU dirty ring get full result in
3076              * the miss of sleep, so just reap the ring-fulled vCPU.
3077              */
3078             if (dirtylimit_in_service()) {
3079                 kvm_dirty_ring_reap(kvm_state, cpu);
3080             } else {
3081                 kvm_dirty_ring_reap(kvm_state, NULL);
3082             }
3083             qemu_mutex_unlock_iothread();
3084             dirtylimit_vcpu_execute(cpu);
3085             ret = 0;
3086             break;
3087         case KVM_EXIT_SYSTEM_EVENT:
3088             switch (run->system_event.type) {
3089             case KVM_SYSTEM_EVENT_SHUTDOWN:
3090                 qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
3091                 ret = EXCP_INTERRUPT;
3092                 break;
3093             case KVM_SYSTEM_EVENT_RESET:
3094                 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET);
3095                 ret = EXCP_INTERRUPT;
3096                 break;
3097             case KVM_SYSTEM_EVENT_CRASH:
3098                 kvm_cpu_synchronize_state(cpu);
3099                 qemu_mutex_lock_iothread();
3100                 qemu_system_guest_panicked(cpu_get_crash_info(cpu));
3101                 qemu_mutex_unlock_iothread();
3102                 ret = 0;
3103                 break;
3104             default:
3105                 DPRINTF("kvm_arch_handle_exit\n");
3106                 ret = kvm_arch_handle_exit(cpu, run);
3107                 break;
3108             }
3109             break;
3110         default:
3111             DPRINTF("kvm_arch_handle_exit\n");
3112             ret = kvm_arch_handle_exit(cpu, run);
3113             break;
3114         }
3115     } while (ret == 0);
3116
3117     cpu_exec_end(cpu);
3118     qemu_mutex_lock_iothread();
3119
3120     if (ret < 0) {
3121         cpu_dump_state(cpu, stderr, CPU_DUMP_CODE);
3122         vm_stop(RUN_STATE_INTERNAL_ERROR);
3123     }
3124
3125     qatomic_set(&cpu->exit_request, 0);
3126     return ret;
3127 }
3128
3129 int kvm_ioctl(KVMState *s, int type, ...)
3130 {
3131     int ret;
3132     void *arg;
3133     va_list ap;
3134
3135     va_start(ap, type);
3136     arg = va_arg(ap, void *);
3137     va_end(ap);
3138
3139     trace_kvm_ioctl(type, arg);
3140     ret = ioctl(s->fd, type, arg);
3141     if (ret == -1) {
3142         ret = -errno;
3143     }
3144     return ret;
3145 }
3146
3147 int kvm_vm_ioctl(KVMState *s, int type, ...)
3148 {
3149     int ret;
3150     void *arg;
3151     va_list ap;
3152
3153     va_start(ap, type);
3154     arg = va_arg(ap, void *);
3155     va_end(ap);
3156
3157     trace_kvm_vm_ioctl(type, arg);
3158     accel_ioctl_begin();
3159     ret = ioctl(s->vmfd, type, arg);
3160     accel_ioctl_end();
3161     if (ret == -1) {
3162         ret = -errno;
3163     }
3164     return ret;
3165 }
3166
3167 int kvm_vcpu_ioctl(CPUState *cpu, int type, ...)
3168 {
3169     int ret;
3170     void *arg;
3171     va_list ap;
3172
3173     va_start(ap, type);
3174     arg = va_arg(ap, void *);
3175     va_end(ap);
3176
3177     trace_kvm_vcpu_ioctl(cpu->cpu_index, type, arg);
3178     accel_cpu_ioctl_begin(cpu);
3179     ret = ioctl(cpu->kvm_fd, type, arg);
3180     accel_cpu_ioctl_end(cpu);
3181     if (ret == -1) {
3182         ret = -errno;
3183     }
3184     return ret;
3185 }
3186
3187 int kvm_device_ioctl(int fd, int type, ...)
3188 {
3189     int ret;
3190     void *arg;
3191     va_list ap;
3192
3193     va_start(ap, type);
3194     arg = va_arg(ap, void *);
3195     va_end(ap);
3196
3197     trace_kvm_device_ioctl(fd, type, arg);
3198     accel_ioctl_begin();
3199     ret = ioctl(fd, type, arg);
3200     accel_ioctl_end();
3201     if (ret == -1) {
3202         ret = -errno;
3203     }
3204     return ret;
3205 }
3206
3207 int kvm_vm_check_attr(KVMState *s, uint32_t group, uint64_t attr)
3208 {
3209     int ret;
3210     struct kvm_device_attr attribute = {
3211         .group = group,
3212         .attr = attr,
3213     };
3214
3215     if (!kvm_vm_attributes_allowed) {
3216         return 0;
3217     }
3218
3219     ret = kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attribute);
3220     /* kvm returns 0 on success for HAS_DEVICE_ATTR */
3221     return ret ? 0 : 1;
3222 }
3223
3224 int kvm_device_check_attr(int dev_fd, uint32_t group, uint64_t attr)
3225 {
3226     struct kvm_device_attr attribute = {
3227         .group = group,
3228         .attr = attr,
3229         .flags = 0,
3230     };
3231
3232     return kvm_device_ioctl(dev_fd, KVM_HAS_DEVICE_ATTR, &attribute) ? 0 : 1;
3233 }
3234
3235 int kvm_device_access(int fd, int group, uint64_t attr,
3236                       void *val, bool write, Error **errp)
3237 {
3238     struct kvm_device_attr kvmattr;
3239     int err;
3240
3241     kvmattr.flags = 0;
3242     kvmattr.group = group;
3243     kvmattr.attr = attr;
3244     kvmattr.addr = (uintptr_t)val;
3245
3246     err = kvm_device_ioctl(fd,
3247                            write ? KVM_SET_DEVICE_ATTR : KVM_GET_DEVICE_ATTR,
3248                            &kvmattr);
3249     if (err < 0) {
3250         error_setg_errno(errp, -err,
3251                          "KVM_%s_DEVICE_ATTR failed: Group %d "
3252                          "attr 0x%016" PRIx64,
3253                          write ? "SET" : "GET", group, attr);
3254     }
3255     return err;
3256 }
3257
3258 bool kvm_has_sync_mmu(void)
3259 {
3260     return kvm_state->sync_mmu;
3261 }
3262
3263 int kvm_has_vcpu_events(void)
3264 {
3265     return kvm_state->vcpu_events;
3266 }
3267
3268 int kvm_has_robust_singlestep(void)
3269 {
3270     return kvm_state->robust_singlestep;
3271 }
3272
3273 int kvm_has_debugregs(void)
3274 {
3275     return kvm_state->debugregs;
3276 }
3277
3278 int kvm_max_nested_state_length(void)
3279 {
3280     return kvm_state->max_nested_state_len;
3281 }
3282
3283 int kvm_has_many_ioeventfds(void)
3284 {
3285     if (!kvm_enabled()) {
3286         return 0;
3287     }
3288     return kvm_state->many_ioeventfds;
3289 }
3290
3291 int kvm_has_gsi_routing(void)
3292 {
3293 #ifdef KVM_CAP_IRQ_ROUTING
3294     return kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING);
3295 #else
3296     return false;
3297 #endif
3298 }
3299
3300 int kvm_has_intx_set_mask(void)
3301 {
3302     return kvm_state->intx_set_mask;
3303 }
3304
3305 bool kvm_arm_supports_user_irq(void)
3306 {
3307     return kvm_check_extension(kvm_state, KVM_CAP_ARM_USER_IRQ);
3308 }
3309
3310 #ifdef KVM_CAP_SET_GUEST_DEBUG
3311 struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *cpu,
3312                                                  target_ulong pc)
3313 {
3314     struct kvm_sw_breakpoint *bp;
3315
3316     QTAILQ_FOREACH(bp, &cpu->kvm_state->kvm_sw_breakpoints, entry) {
3317         if (bp->pc == pc) {
3318             return bp;
3319         }
3320     }
3321     return NULL;
3322 }
3323
3324 int kvm_sw_breakpoints_active(CPUState *cpu)
3325 {
3326     return !QTAILQ_EMPTY(&cpu->kvm_state->kvm_sw_breakpoints);
3327 }
3328
3329 struct kvm_set_guest_debug_data {
3330     struct kvm_guest_debug dbg;
3331     int err;
3332 };
3333
3334 static void kvm_invoke_set_guest_debug(CPUState *cpu, run_on_cpu_data data)
3335 {
3336     struct kvm_set_guest_debug_data *dbg_data =
3337         (struct kvm_set_guest_debug_data *) data.host_ptr;
3338
3339     dbg_data->err = kvm_vcpu_ioctl(cpu, KVM_SET_GUEST_DEBUG,
3340                                    &dbg_data->dbg);
3341 }
3342
3343 int kvm_update_guest_debug(CPUState *cpu, unsigned long reinject_trap)
3344 {
3345     struct kvm_set_guest_debug_data data;
3346
3347     data.dbg.control = reinject_trap;
3348
3349     if (cpu->singlestep_enabled) {
3350         data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
3351
3352         if (cpu->singlestep_enabled & SSTEP_NOIRQ) {
3353             data.dbg.control |= KVM_GUESTDBG_BLOCKIRQ;
3354         }
3355     }
3356     kvm_arch_update_guest_debug(cpu, &data.dbg);
3357
3358     run_on_cpu(cpu, kvm_invoke_set_guest_debug,
3359                RUN_ON_CPU_HOST_PTR(&data));
3360     return data.err;
3361 }
3362
3363 bool kvm_supports_guest_debug(void)
3364 {
3365     /* probed during kvm_init() */
3366     return kvm_has_guest_debug;
3367 }
3368
3369 int kvm_insert_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
3370 {
3371     struct kvm_sw_breakpoint *bp;
3372     int err;
3373
3374     if (type == GDB_BREAKPOINT_SW) {
3375         bp = kvm_find_sw_breakpoint(cpu, addr);
3376         if (bp) {
3377             bp->use_count++;
3378             return 0;
3379         }
3380
3381         bp = g_new(struct kvm_sw_breakpoint, 1);
3382         bp->pc = addr;
3383         bp->use_count = 1;
3384         err = kvm_arch_insert_sw_breakpoint(cpu, bp);
3385         if (err) {
3386             g_free(bp);
3387             return err;
3388         }
3389
3390         QTAILQ_INSERT_HEAD(&cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
3391     } else {
3392         err = kvm_arch_insert_hw_breakpoint(addr, len, type);
3393         if (err) {
3394             return err;
3395         }
3396     }
3397
3398     CPU_FOREACH(cpu) {
3399         err = kvm_update_guest_debug(cpu, 0);
3400         if (err) {
3401             return err;
3402         }
3403     }
3404     return 0;
3405 }
3406
3407 int kvm_remove_breakpoint(CPUState *cpu, int type, vaddr addr, vaddr len)
3408 {
3409     struct kvm_sw_breakpoint *bp;
3410     int err;
3411
3412     if (type == GDB_BREAKPOINT_SW) {
3413         bp = kvm_find_sw_breakpoint(cpu, addr);
3414         if (!bp) {
3415             return -ENOENT;
3416         }
3417
3418         if (bp->use_count > 1) {
3419             bp->use_count--;
3420             return 0;
3421         }
3422
3423         err = kvm_arch_remove_sw_breakpoint(cpu, bp);
3424         if (err) {
3425             return err;
3426         }
3427
3428         QTAILQ_REMOVE(&cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
3429         g_free(bp);
3430     } else {
3431         err = kvm_arch_remove_hw_breakpoint(addr, len, type);
3432         if (err) {
3433             return err;
3434         }
3435     }
3436
3437     CPU_FOREACH(cpu) {
3438         err = kvm_update_guest_debug(cpu, 0);
3439         if (err) {
3440             return err;
3441         }
3442     }
3443     return 0;
3444 }
3445
3446 void kvm_remove_all_breakpoints(CPUState *cpu)
3447 {
3448     struct kvm_sw_breakpoint *bp, *next;
3449     KVMState *s = cpu->kvm_state;
3450     CPUState *tmpcpu;
3451
3452     QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
3453         if (kvm_arch_remove_sw_breakpoint(cpu, bp) != 0) {
3454             /* Try harder to find a CPU that currently sees the breakpoint. */
3455             CPU_FOREACH(tmpcpu) {
3456                 if (kvm_arch_remove_sw_breakpoint(tmpcpu, bp) == 0) {
3457                     break;
3458                 }
3459             }
3460         }
3461         QTAILQ_REMOVE(&s->kvm_sw_breakpoints, bp, entry);
3462         g_free(bp);
3463     }
3464     kvm_arch_remove_all_hw_breakpoints();
3465
3466     CPU_FOREACH(cpu) {
3467         kvm_update_guest_debug(cpu, 0);
3468     }
3469 }
3470
3471 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
3472
3473 static int kvm_set_signal_mask(CPUState *cpu, const sigset_t *sigset)
3474 {
3475     KVMState *s = kvm_state;
3476     struct kvm_signal_mask *sigmask;
3477     int r;
3478
3479     sigmask = g_malloc(sizeof(*sigmask) + sizeof(*sigset));
3480
3481     sigmask->len = s->sigmask_len;
3482     memcpy(sigmask->sigset, sigset, sizeof(*sigset));
3483     r = kvm_vcpu_ioctl(cpu, KVM_SET_SIGNAL_MASK, sigmask);
3484     g_free(sigmask);
3485
3486     return r;
3487 }
3488
3489 static void kvm_ipi_signal(int sig)
3490 {
3491     if (current_cpu) {
3492         assert(kvm_immediate_exit);
3493         kvm_cpu_kick(current_cpu);
3494     }
3495 }
3496
3497 void kvm_init_cpu_signals(CPUState *cpu)
3498 {
3499     int r;
3500     sigset_t set;
3501     struct sigaction sigact;
3502
3503     memset(&sigact, 0, sizeof(sigact));
3504     sigact.sa_handler = kvm_ipi_signal;
3505     sigaction(SIG_IPI, &sigact, NULL);
3506
3507     pthread_sigmask(SIG_BLOCK, NULL, &set);
3508 #if defined KVM_HAVE_MCE_INJECTION
3509     sigdelset(&set, SIGBUS);
3510     pthread_sigmask(SIG_SETMASK, &set, NULL);
3511 #endif
3512     sigdelset(&set, SIG_IPI);
3513     if (kvm_immediate_exit) {
3514         r = pthread_sigmask(SIG_SETMASK, &set, NULL);
3515     } else {
3516         r = kvm_set_signal_mask(cpu, &set);
3517     }
3518     if (r) {
3519         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(-r));
3520         exit(1);
3521     }
3522 }
3523
3524 /* Called asynchronously in VCPU thread.  */
3525 int kvm_on_sigbus_vcpu(CPUState *cpu, int code, void *addr)
3526 {
3527 #ifdef KVM_HAVE_MCE_INJECTION
3528     if (have_sigbus_pending) {
3529         return 1;
3530     }
3531     have_sigbus_pending = true;
3532     pending_sigbus_addr = addr;
3533     pending_sigbus_code = code;
3534     qatomic_set(&cpu->exit_request, 1);
3535     return 0;
3536 #else
3537     return 1;
3538 #endif
3539 }
3540
3541 /* Called synchronously (via signalfd) in main thread.  */
3542 int kvm_on_sigbus(int code, void *addr)
3543 {
3544 #ifdef KVM_HAVE_MCE_INJECTION
3545     /* Action required MCE kills the process if SIGBUS is blocked.  Because
3546      * that's what happens in the I/O thread, where we handle MCE via signalfd,
3547      * we can only get action optional here.
3548      */
3549     assert(code != BUS_MCEERR_AR);
3550     kvm_arch_on_sigbus_vcpu(first_cpu, code, addr);
3551     return 0;
3552 #else
3553     return 1;
3554 #endif
3555 }
3556
3557 int kvm_create_device(KVMState *s, uint64_t type, bool test)
3558 {
3559     int ret;
3560     struct kvm_create_device create_dev;
3561
3562     create_dev.type = type;
3563     create_dev.fd = -1;
3564     create_dev.flags = test ? KVM_CREATE_DEVICE_TEST : 0;
3565
3566     if (!kvm_check_extension(s, KVM_CAP_DEVICE_CTRL)) {
3567         return -ENOTSUP;
3568     }
3569
3570     ret = kvm_vm_ioctl(s, KVM_CREATE_DEVICE, &create_dev);
3571     if (ret) {
3572         return ret;
3573     }
3574
3575     return test ? 0 : create_dev.fd;
3576 }
3577
3578 bool kvm_device_supported(int vmfd, uint64_t type)
3579 {
3580     struct kvm_create_device create_dev = {
3581         .type = type,
3582         .fd = -1,
3583         .flags = KVM_CREATE_DEVICE_TEST,
3584     };
3585
3586     if (ioctl(vmfd, KVM_CHECK_EXTENSION, KVM_CAP_DEVICE_CTRL) <= 0) {
3587         return false;
3588     }
3589
3590     return (ioctl(vmfd, KVM_CREATE_DEVICE, &create_dev) >= 0);
3591 }
3592
3593 int kvm_set_one_reg(CPUState *cs, uint64_t id, void *source)
3594 {
3595     struct kvm_one_reg reg;
3596     int r;
3597
3598     reg.id = id;
3599     reg.addr = (uintptr_t) source;
3600     r = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
3601     if (r) {
3602         trace_kvm_failed_reg_set(id, strerror(-r));
3603     }
3604     return r;
3605 }
3606
3607 int kvm_get_one_reg(CPUState *cs, uint64_t id, void *target)
3608 {
3609     struct kvm_one_reg reg;
3610     int r;
3611
3612     reg.id = id;
3613     reg.addr = (uintptr_t) target;
3614     r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
3615     if (r) {
3616         trace_kvm_failed_reg_get(id, strerror(-r));
3617     }
3618     return r;
3619 }
3620
3621 static bool kvm_accel_has_memory(MachineState *ms, AddressSpace *as,
3622                                  hwaddr start_addr, hwaddr size)
3623 {
3624     KVMState *kvm = KVM_STATE(ms->accelerator);
3625     int i;
3626
3627     for (i = 0; i < kvm->nr_as; ++i) {
3628         if (kvm->as[i].as == as && kvm->as[i].ml) {
3629             size = MIN(kvm_max_slot_size, size);
3630             return NULL != kvm_lookup_matching_slot(kvm->as[i].ml,
3631                                                     start_addr, size);
3632         }
3633     }
3634
3635     return false;
3636 }
3637
3638 static void kvm_get_kvm_shadow_mem(Object *obj, Visitor *v,
3639                                    const char *name, void *opaque,
3640                                    Error **errp)
3641 {
3642     KVMState *s = KVM_STATE(obj);
3643     int64_t value = s->kvm_shadow_mem;
3644
3645     visit_type_int(v, name, &value, errp);
3646 }
3647
3648 static void kvm_set_kvm_shadow_mem(Object *obj, Visitor *v,
3649                                    const char *name, void *opaque,
3650                                    Error **errp)
3651 {
3652     KVMState *s = KVM_STATE(obj);
3653     int64_t value;
3654
3655     if (s->fd != -1) {
3656         error_setg(errp, "Cannot set properties after the accelerator has been initialized");
3657         return;
3658     }
3659
3660     if (!visit_type_int(v, name, &value, errp)) {
3661         return;
3662     }
3663
3664     s->kvm_shadow_mem = value;
3665 }
3666
3667 static void kvm_set_kernel_irqchip(Object *obj, Visitor *v,
3668                                    const char *name, void *opaque,
3669                                    Error **errp)
3670 {
3671     KVMState *s = KVM_STATE(obj);
3672     OnOffSplit mode;
3673
3674     if (s->fd != -1) {
3675         error_setg(errp, "Cannot set properties after the accelerator has been initialized");
3676         return;
3677     }
3678
3679     if (!visit_type_OnOffSplit(v, name, &mode, errp)) {
3680         return;
3681     }
3682     switch (mode) {
3683     case ON_OFF_SPLIT_ON:
3684         s->kernel_irqchip_allowed = true;
3685         s->kernel_irqchip_required = true;
3686         s->kernel_irqchip_split = ON_OFF_AUTO_OFF;
3687         break;
3688     case ON_OFF_SPLIT_OFF:
3689         s->kernel_irqchip_allowed = false;
3690         s->kernel_irqchip_required = false;
3691         s->kernel_irqchip_split = ON_OFF_AUTO_OFF;
3692         break;
3693     case ON_OFF_SPLIT_SPLIT:
3694         s->kernel_irqchip_allowed = true;
3695         s->kernel_irqchip_required = true;
3696         s->kernel_irqchip_split = ON_OFF_AUTO_ON;
3697         break;
3698     default:
3699         /* The value was checked in visit_type_OnOffSplit() above. If
3700          * we get here, then something is wrong in QEMU.
3701          */
3702         abort();
3703     }
3704 }
3705
3706 bool kvm_kernel_irqchip_allowed(void)
3707 {
3708     return kvm_state->kernel_irqchip_allowed;
3709 }
3710
3711 bool kvm_kernel_irqchip_required(void)
3712 {
3713     return kvm_state->kernel_irqchip_required;
3714 }
3715
3716 bool kvm_kernel_irqchip_split(void)
3717 {
3718     return kvm_state->kernel_irqchip_split == ON_OFF_AUTO_ON;
3719 }
3720
3721 static void kvm_get_dirty_ring_size(Object *obj, Visitor *v,
3722                                     const char *name, void *opaque,
3723                                     Error **errp)
3724 {
3725     KVMState *s = KVM_STATE(obj);
3726     uint32_t value = s->kvm_dirty_ring_size;
3727
3728     visit_type_uint32(v, name, &value, errp);
3729 }
3730
3731 static void kvm_set_dirty_ring_size(Object *obj, Visitor *v,
3732                                     const char *name, void *opaque,
3733                                     Error **errp)
3734 {
3735     KVMState *s = KVM_STATE(obj);
3736     uint32_t value;
3737
3738     if (s->fd != -1) {
3739         error_setg(errp, "Cannot set properties after the accelerator has been initialized");
3740         return;
3741     }
3742
3743     if (!visit_type_uint32(v, name, &value, errp)) {
3744         return;
3745     }
3746     if (value & (value - 1)) {
3747         error_setg(errp, "dirty-ring-size must be a power of two.");
3748         return;
3749     }
3750
3751     s->kvm_dirty_ring_size = value;
3752 }
3753
3754 static void kvm_accel_instance_init(Object *obj)
3755 {
3756     KVMState *s = KVM_STATE(obj);
3757
3758     s->fd = -1;
3759     s->vmfd = -1;
3760     s->kvm_shadow_mem = -1;
3761     s->kernel_irqchip_allowed = true;
3762     s->kernel_irqchip_split = ON_OFF_AUTO_AUTO;
3763     /* KVM dirty ring is by default off */
3764     s->kvm_dirty_ring_size = 0;
3765     s->kvm_dirty_ring_with_bitmap = false;
3766     s->notify_vmexit = NOTIFY_VMEXIT_OPTION_RUN;
3767     s->notify_window = 0;
3768     s->xen_version = 0;
3769     s->xen_gnttab_max_frames = 64;
3770     s->xen_evtchn_max_pirq = 256;
3771 }
3772
3773 /**
3774  * kvm_gdbstub_sstep_flags():
3775  *
3776  * Returns: SSTEP_* flags that KVM supports for guest debug. The
3777  * support is probed during kvm_init()
3778  */
3779 static int kvm_gdbstub_sstep_flags(void)
3780 {
3781     return kvm_sstep_flags;
3782 }
3783
3784 static void kvm_accel_class_init(ObjectClass *oc, void *data)
3785 {
3786     AccelClass *ac = ACCEL_CLASS(oc);
3787     ac->name = "KVM";
3788     ac->init_machine = kvm_init;
3789     ac->has_memory = kvm_accel_has_memory;
3790     ac->allowed = &kvm_allowed;
3791     ac->gdbstub_supported_sstep_flags = kvm_gdbstub_sstep_flags;
3792
3793     object_class_property_add(oc, "kernel-irqchip", "on|off|split",
3794         NULL, kvm_set_kernel_irqchip,
3795         NULL, NULL);
3796     object_class_property_set_description(oc, "kernel-irqchip",
3797         "Configure KVM in-kernel irqchip");
3798
3799     object_class_property_add(oc, "kvm-shadow-mem", "int",
3800         kvm_get_kvm_shadow_mem, kvm_set_kvm_shadow_mem,
3801         NULL, NULL);
3802     object_class_property_set_description(oc, "kvm-shadow-mem",
3803         "KVM shadow MMU size");
3804
3805     object_class_property_add(oc, "dirty-ring-size", "uint32",
3806         kvm_get_dirty_ring_size, kvm_set_dirty_ring_size,
3807         NULL, NULL);
3808     object_class_property_set_description(oc, "dirty-ring-size",
3809         "Size of KVM dirty page ring buffer (default: 0, i.e. use bitmap)");
3810
3811     kvm_arch_accel_class_init(oc);
3812 }
3813
3814 static const TypeInfo kvm_accel_type = {
3815     .name = TYPE_KVM_ACCEL,
3816     .parent = TYPE_ACCEL,
3817     .instance_init = kvm_accel_instance_init,
3818     .class_init = kvm_accel_class_init,
3819     .instance_size = sizeof(KVMState),
3820 };
3821
3822 static void kvm_type_init(void)
3823 {
3824     type_register_static(&kvm_accel_type);
3825 }
3826
3827 type_init(kvm_type_init);
3828
3829 typedef struct StatsArgs {
3830     union StatsResultsType {
3831         StatsResultList **stats;
3832         StatsSchemaList **schema;
3833     } result;
3834     strList *names;
3835     Error **errp;
3836 } StatsArgs;
3837
3838 static StatsList *add_kvmstat_entry(struct kvm_stats_desc *pdesc,
3839                                     uint64_t *stats_data,
3840                                     StatsList *stats_list,
3841                                     Error **errp)
3842 {
3843
3844     Stats *stats;
3845     uint64List *val_list = NULL;
3846
3847     /* Only add stats that we understand.  */
3848     switch (pdesc->flags & KVM_STATS_TYPE_MASK) {
3849     case KVM_STATS_TYPE_CUMULATIVE:
3850     case KVM_STATS_TYPE_INSTANT:
3851     case KVM_STATS_TYPE_PEAK:
3852     case KVM_STATS_TYPE_LINEAR_HIST:
3853     case KVM_STATS_TYPE_LOG_HIST:
3854         break;
3855     default:
3856         return stats_list;
3857     }
3858
3859     switch (pdesc->flags & KVM_STATS_UNIT_MASK) {
3860     case KVM_STATS_UNIT_NONE:
3861     case KVM_STATS_UNIT_BYTES:
3862     case KVM_STATS_UNIT_CYCLES:
3863     case KVM_STATS_UNIT_SECONDS:
3864     case KVM_STATS_UNIT_BOOLEAN:
3865         break;
3866     default:
3867         return stats_list;
3868     }
3869
3870     switch (pdesc->flags & KVM_STATS_BASE_MASK) {
3871     case KVM_STATS_BASE_POW10:
3872     case KVM_STATS_BASE_POW2:
3873         break;
3874     default:
3875         return stats_list;
3876     }
3877
3878     /* Alloc and populate data list */
3879     stats = g_new0(Stats, 1);
3880     stats->name = g_strdup(pdesc->name);
3881     stats->value = g_new0(StatsValue, 1);;
3882
3883     if ((pdesc->flags & KVM_STATS_UNIT_MASK) == KVM_STATS_UNIT_BOOLEAN) {
3884         stats->value->u.boolean = *stats_data;
3885         stats->value->type = QTYPE_QBOOL;
3886     } else if (pdesc->size == 1) {
3887         stats->value->u.scalar = *stats_data;
3888         stats->value->type = QTYPE_QNUM;
3889     } else {
3890         int i;
3891         for (i = 0; i < pdesc->size; i++) {
3892             QAPI_LIST_PREPEND(val_list, stats_data[i]);
3893         }
3894         stats->value->u.list = val_list;
3895         stats->value->type = QTYPE_QLIST;
3896     }
3897
3898     QAPI_LIST_PREPEND(stats_list, stats);
3899     return stats_list;
3900 }
3901
3902 static StatsSchemaValueList *add_kvmschema_entry(struct kvm_stats_desc *pdesc,
3903                                                  StatsSchemaValueList *list,
3904                                                  Error **errp)
3905 {
3906     StatsSchemaValueList *schema_entry = g_new0(StatsSchemaValueList, 1);
3907     schema_entry->value = g_new0(StatsSchemaValue, 1);
3908
3909     switch (pdesc->flags & KVM_STATS_TYPE_MASK) {
3910     case KVM_STATS_TYPE_CUMULATIVE:
3911         schema_entry->value->type = STATS_TYPE_CUMULATIVE;
3912         break;
3913     case KVM_STATS_TYPE_INSTANT:
3914         schema_entry->value->type = STATS_TYPE_INSTANT;
3915         break;
3916     case KVM_STATS_TYPE_PEAK:
3917         schema_entry->value->type = STATS_TYPE_PEAK;
3918         break;
3919     case KVM_STATS_TYPE_LINEAR_HIST:
3920         schema_entry->value->type = STATS_TYPE_LINEAR_HISTOGRAM;
3921         schema_entry->value->bucket_size = pdesc->bucket_size;
3922         schema_entry->value->has_bucket_size = true;
3923         break;
3924     case KVM_STATS_TYPE_LOG_HIST:
3925         schema_entry->value->type = STATS_TYPE_LOG2_HISTOGRAM;
3926         break;
3927     default:
3928         goto exit;
3929     }
3930
3931     switch (pdesc->flags & KVM_STATS_UNIT_MASK) {
3932     case KVM_STATS_UNIT_NONE:
3933         break;
3934     case KVM_STATS_UNIT_BOOLEAN:
3935         schema_entry->value->has_unit = true;
3936         schema_entry->value->unit = STATS_UNIT_BOOLEAN;
3937         break;
3938     case KVM_STATS_UNIT_BYTES:
3939         schema_entry->value->has_unit = true;
3940         schema_entry->value->unit = STATS_UNIT_BYTES;
3941         break;
3942     case KVM_STATS_UNIT_CYCLES:
3943         schema_entry->value->has_unit = true;
3944         schema_entry->value->unit = STATS_UNIT_CYCLES;
3945         break;
3946     case KVM_STATS_UNIT_SECONDS:
3947         schema_entry->value->has_unit = true;
3948         schema_entry->value->unit = STATS_UNIT_SECONDS;
3949         break;
3950     default:
3951         goto exit;
3952     }
3953
3954     schema_entry->value->exponent = pdesc->exponent;
3955     if (pdesc->exponent) {
3956         switch (pdesc->flags & KVM_STATS_BASE_MASK) {
3957         case KVM_STATS_BASE_POW10:
3958             schema_entry->value->has_base = true;
3959             schema_entry->value->base = 10;
3960             break;
3961         case KVM_STATS_BASE_POW2:
3962             schema_entry->value->has_base = true;
3963             schema_entry->value->base = 2;
3964             break;
3965         default:
3966             goto exit;
3967         }
3968     }
3969
3970     schema_entry->value->name = g_strdup(pdesc->name);
3971     schema_entry->next = list;
3972     return schema_entry;
3973 exit:
3974     g_free(schema_entry->value);
3975     g_free(schema_entry);
3976     return list;
3977 }
3978
3979 /* Cached stats descriptors */
3980 typedef struct StatsDescriptors {
3981     const char *ident; /* cache key, currently the StatsTarget */
3982     struct kvm_stats_desc *kvm_stats_desc;
3983     struct kvm_stats_header kvm_stats_header;
3984     QTAILQ_ENTRY(StatsDescriptors) next;
3985 } StatsDescriptors;
3986
3987 static QTAILQ_HEAD(, StatsDescriptors) stats_descriptors =
3988     QTAILQ_HEAD_INITIALIZER(stats_descriptors);
3989
3990 /*
3991  * Return the descriptors for 'target', that either have already been read
3992  * or are retrieved from 'stats_fd'.
3993  */
3994 static StatsDescriptors *find_stats_descriptors(StatsTarget target, int stats_fd,
3995                                                 Error **errp)
3996 {
3997     StatsDescriptors *descriptors;
3998     const char *ident;
3999     struct kvm_stats_desc *kvm_stats_desc;
4000     struct kvm_stats_header *kvm_stats_header;
4001     size_t size_desc;
4002     ssize_t ret;
4003
4004     ident = StatsTarget_str(target);
4005     QTAILQ_FOREACH(descriptors, &stats_descriptors, next) {
4006         if (g_str_equal(descriptors->ident, ident)) {
4007             return descriptors;
4008         }
4009     }
4010
4011     descriptors = g_new0(StatsDescriptors, 1);
4012
4013     /* Read stats header */
4014     kvm_stats_header = &descriptors->kvm_stats_header;
4015     ret = pread(stats_fd, kvm_stats_header, sizeof(*kvm_stats_header), 0);
4016     if (ret != sizeof(*kvm_stats_header)) {
4017         error_setg(errp, "KVM stats: failed to read stats header: "
4018                    "expected %zu actual %zu",
4019                    sizeof(*kvm_stats_header), ret);
4020         g_free(descriptors);
4021         return NULL;
4022     }
4023     size_desc = sizeof(*kvm_stats_desc) + kvm_stats_header->name_size;
4024
4025     /* Read stats descriptors */
4026     kvm_stats_desc = g_malloc0_n(kvm_stats_header->num_desc, size_desc);
4027     ret = pread(stats_fd, kvm_stats_desc,
4028                 size_desc * kvm_stats_header->num_desc,
4029                 kvm_stats_header->desc_offset);
4030
4031     if (ret != size_desc * kvm_stats_header->num_desc) {
4032         error_setg(errp, "KVM stats: failed to read stats descriptors: "
4033                    "expected %zu actual %zu",
4034                    size_desc * kvm_stats_header->num_desc, ret);
4035         g_free(descriptors);
4036         g_free(kvm_stats_desc);
4037         return NULL;
4038     }
4039     descriptors->kvm_stats_desc = kvm_stats_desc;
4040     descriptors->ident = ident;
4041     QTAILQ_INSERT_TAIL(&stats_descriptors, descriptors, next);
4042     return descriptors;
4043 }
4044
4045 static void query_stats(StatsResultList **result, StatsTarget target,
4046                         strList *names, int stats_fd, CPUState *cpu,
4047                         Error **errp)
4048 {
4049     struct kvm_stats_desc *kvm_stats_desc;
4050     struct kvm_stats_header *kvm_stats_header;
4051     StatsDescriptors *descriptors;
4052     g_autofree uint64_t *stats_data = NULL;
4053     struct kvm_stats_desc *pdesc;
4054     StatsList *stats_list = NULL;
4055     size_t size_desc, size_data = 0;
4056     ssize_t ret;
4057     int i;
4058
4059     descriptors = find_stats_descriptors(target, stats_fd, errp);
4060     if (!descriptors) {
4061         return;
4062     }
4063
4064     kvm_stats_header = &descriptors->kvm_stats_header;
4065     kvm_stats_desc = descriptors->kvm_stats_desc;
4066     size_desc = sizeof(*kvm_stats_desc) + kvm_stats_header->name_size;
4067
4068     /* Tally the total data size; read schema data */
4069     for (i = 0; i < kvm_stats_header->num_desc; ++i) {
4070         pdesc = (void *)kvm_stats_desc + i * size_desc;
4071         size_data += pdesc->size * sizeof(*stats_data);
4072     }
4073
4074     stats_data = g_malloc0(size_data);
4075     ret = pread(stats_fd, stats_data, size_data, kvm_stats_header->data_offset);
4076
4077     if (ret != size_data) {
4078         error_setg(errp, "KVM stats: failed to read data: "
4079                    "expected %zu actual %zu", size_data, ret);
4080         return;
4081     }
4082
4083     for (i = 0; i < kvm_stats_header->num_desc; ++i) {
4084         uint64_t *stats;
4085         pdesc = (void *)kvm_stats_desc + i * size_desc;
4086
4087         /* Add entry to the list */
4088         stats = (void *)stats_data + pdesc->offset;
4089         if (!apply_str_list_filter(pdesc->name, names)) {
4090             continue;
4091         }
4092         stats_list = add_kvmstat_entry(pdesc, stats, stats_list, errp);
4093     }
4094
4095     if (!stats_list) {
4096         return;
4097     }
4098
4099     switch (target) {
4100     case STATS_TARGET_VM:
4101         add_stats_entry(result, STATS_PROVIDER_KVM, NULL, stats_list);
4102         break;
4103     case STATS_TARGET_VCPU:
4104         add_stats_entry(result, STATS_PROVIDER_KVM,
4105                         cpu->parent_obj.canonical_path,
4106                         stats_list);
4107         break;
4108     default:
4109         g_assert_not_reached();
4110     }
4111 }
4112
4113 static void query_stats_schema(StatsSchemaList **result, StatsTarget target,
4114                                int stats_fd, Error **errp)
4115 {
4116     struct kvm_stats_desc *kvm_stats_desc;
4117     struct kvm_stats_header *kvm_stats_header;
4118     StatsDescriptors *descriptors;
4119     struct kvm_stats_desc *pdesc;
4120     StatsSchemaValueList *stats_list = NULL;
4121     size_t size_desc;
4122     int i;
4123
4124     descriptors = find_stats_descriptors(target, stats_fd, errp);
4125     if (!descriptors) {
4126         return;
4127     }
4128
4129     kvm_stats_header = &descriptors->kvm_stats_header;
4130     kvm_stats_desc = descriptors->kvm_stats_desc;
4131     size_desc = sizeof(*kvm_stats_desc) + kvm_stats_header->name_size;
4132
4133     /* Tally the total data size; read schema data */
4134     for (i = 0; i < kvm_stats_header->num_desc; ++i) {
4135         pdesc = (void *)kvm_stats_desc + i * size_desc;
4136         stats_list = add_kvmschema_entry(pdesc, stats_list, errp);
4137     }
4138
4139     add_stats_schema(result, STATS_PROVIDER_KVM, target, stats_list);
4140 }
4141
4142 static void query_stats_vcpu(CPUState *cpu, StatsArgs *kvm_stats_args)
4143 {
4144     int stats_fd = cpu->kvm_vcpu_stats_fd;
4145     Error *local_err = NULL;
4146
4147     if (stats_fd == -1) {
4148         error_setg_errno(&local_err, errno, "KVM stats: ioctl failed");
4149         error_propagate(kvm_stats_args->errp, local_err);
4150         return;
4151     }
4152     query_stats(kvm_stats_args->result.stats, STATS_TARGET_VCPU,
4153                 kvm_stats_args->names, stats_fd, cpu,
4154                 kvm_stats_args->errp);
4155 }
4156
4157 static void query_stats_schema_vcpu(CPUState *cpu, StatsArgs *kvm_stats_args)
4158 {
4159     int stats_fd = cpu->kvm_vcpu_stats_fd;
4160     Error *local_err = NULL;
4161
4162     if (stats_fd == -1) {
4163         error_setg_errno(&local_err, errno, "KVM stats: ioctl failed");
4164         error_propagate(kvm_stats_args->errp, local_err);
4165         return;
4166     }
4167     query_stats_schema(kvm_stats_args->result.schema, STATS_TARGET_VCPU, stats_fd,
4168                        kvm_stats_args->errp);
4169 }
4170
4171 static void query_stats_cb(StatsResultList **result, StatsTarget target,
4172                            strList *names, strList *targets, Error **errp)
4173 {
4174     KVMState *s = kvm_state;
4175     CPUState *cpu;
4176     int stats_fd;
4177
4178     switch (target) {
4179     case STATS_TARGET_VM:
4180     {
4181         stats_fd = kvm_vm_ioctl(s, KVM_GET_STATS_FD, NULL);
4182         if (stats_fd == -1) {
4183             error_setg_errno(errp, errno, "KVM stats: ioctl failed");
4184             return;
4185         }
4186         query_stats(result, target, names, stats_fd, NULL, errp);
4187         close(stats_fd);
4188         break;
4189     }
4190     case STATS_TARGET_VCPU:
4191     {
4192         StatsArgs stats_args;
4193         stats_args.result.stats = result;
4194         stats_args.names = names;
4195         stats_args.errp = errp;
4196         CPU_FOREACH(cpu) {
4197             if (!apply_str_list_filter(cpu->parent_obj.canonical_path, targets)) {
4198                 continue;
4199             }
4200             query_stats_vcpu(cpu, &stats_args);
4201         }
4202         break;
4203     }
4204     default:
4205         break;
4206     }
4207 }
4208
4209 void query_stats_schemas_cb(StatsSchemaList **result, Error **errp)
4210 {
4211     StatsArgs stats_args;
4212     KVMState *s = kvm_state;
4213     int stats_fd;
4214
4215     stats_fd = kvm_vm_ioctl(s, KVM_GET_STATS_FD, NULL);
4216     if (stats_fd == -1) {
4217         error_setg_errno(errp, errno, "KVM stats: ioctl failed");
4218         return;
4219     }
4220     query_stats_schema(result, STATS_TARGET_VM, stats_fd, errp);
4221     close(stats_fd);
4222
4223     if (first_cpu) {
4224         stats_args.result.schema = result;
4225         stats_args.errp = errp;
4226         query_stats_schema_vcpu(first_cpu, &stats_args);
4227     }
4228 }