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   <[email protected]>
   9  *  Glauber Costa     <[email protected]>
  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
  19 #include <linux/kvm.h>
  20
  21 #include "qemu-common.h"
  22 #include "qemu/atomic.h"
  23 #include "qemu/option.h"
  24 #include "qemu/config-file.h"
  25 #include "qemu/error-report.h"
  26 #include "hw/hw.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 "qemu/bswap.h"
  33 #include "exec/memory.h"
  34 #include "exec/ram_addr.h"
  35 #include "exec/address-spaces.h"
  36 #include "qemu/event_notifier.h"
  37 #include "trace.h"
  38 #include "hw/irq.h"
  39
  40 #include "hw/boards.h"
  41
  42 /* This check must be after config-host.h is included */
  43 #ifdef CONFIG_EVENTFD
  44 #include <sys/eventfd.h>
  45 #endif
  46
  47 /* KVM uses PAGE_SIZE in its definition of KVM_COALESCED_MMIO_MAX. We
  48  * need to use the real host PAGE_SIZE, as that's what KVM will use.
  49  */
  50 #define PAGE_SIZE getpagesize()
  51
  52 //#define DEBUG_KVM
  53
  54 #ifdef DEBUG_KVM
  55 #define DPRINTF(fmt, ...) \
  56     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
  57 #else
  58 #define DPRINTF(fmt, ...) \
  59     do { } while (0)
  60 #endif
  61
  62 #define KVM_MSI_HASHTAB_SIZE    256
  63
  64 struct KVMParkedVcpu {
  65     unsigned long vcpu_id;
  66     int kvm_fd;
  67     QLIST_ENTRY(KVMParkedVcpu) node;
  68 };
  69
  70 struct KVMState
  71 {
  72     AccelState parent_obj;
  73
  74     int nr_slots;
  75     int fd;
  76     int vmfd;
  77     int coalesced_mmio;
  78     struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
  79     bool coalesced_flush_in_progress;
  80     int broken_set_mem_region;
  81     int vcpu_events;
  82     int robust_singlestep;
  83     int debugregs;
  84 #ifdef KVM_CAP_SET_GUEST_DEBUG
  85     struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
  86 #endif
  87     int many_ioeventfds;
  88     int intx_set_mask;
  89     /* The man page (and posix) say ioctl numbers are signed int, but
  90      * they're not.  Linux, glibc and *BSD all treat ioctl numbers as
  91      * unsigned, and treating them as signed here can break things */
  92     unsigned irq_set_ioctl;
  93     unsigned int sigmask_len;
  94     GHashTable *gsimap;
  95 #ifdef KVM_CAP_IRQ_ROUTING
  96     struct kvm_irq_routing *irq_routes;
  97     int nr_allocated_irq_routes;
  98     unsigned long *used_gsi_bitmap;
  99     unsigned int gsi_count;
 100     QTAILQ_HEAD(msi_hashtab, KVMMSIRoute) msi_hashtab[KVM_MSI_HASHTAB_SIZE];
 101 #endif
 102     KVMMemoryListener memory_listener;
 103     QLIST_HEAD(, KVMParkedVcpu) kvm_parked_vcpus;
 104 };
 105
 106 KVMState *kvm_state;
 107 bool kvm_kernel_irqchip;
 108 bool kvm_split_irqchip;
 109 bool kvm_async_interrupts_allowed;
 110 bool kvm_halt_in_kernel_allowed;
 111 bool kvm_eventfds_allowed;
 112 bool kvm_irqfds_allowed;
 113 bool kvm_resamplefds_allowed;
 114 bool kvm_msi_via_irqfd_allowed;
 115 bool kvm_gsi_routing_allowed;
 116 bool kvm_gsi_direct_mapping;
 117 bool kvm_allowed;
 118 bool kvm_readonly_mem_allowed;
 119 bool kvm_vm_attributes_allowed;
 120 bool kvm_direct_msi_allowed;
 121 bool kvm_ioeventfd_any_length_allowed;
 122
 123 static const KVMCapabilityInfo kvm_required_capabilites[] = {
 124     KVM_CAP_INFO(USER_MEMORY),
 125     KVM_CAP_INFO(DESTROY_MEMORY_REGION_WORKS),
 126     KVM_CAP_LAST_INFO
 127 };
 128
 129 int kvm_get_max_memslots(void)
 130 {
 131     KVMState *s = KVM_STATE(current_machine->accelerator);
 132
 133     return s->nr_slots;
 134 }
 135
 136 static KVMSlot *kvm_get_free_slot(KVMMemoryListener *kml)
 137 {
 138     KVMState *s = kvm_state;
 139     int i;
 140
 141     for (i = 0; i < s->nr_slots; i++) {
 142         if (kml->slots[i].memory_size == 0) {
 143             return &kml->slots[i];
 144         }
 145     }
 146
 147     return NULL;
 148 }
 149
 150 bool kvm_has_free_slot(MachineState *ms)
 151 {
 152     KVMState *s = KVM_STATE(ms->accelerator);
 153
 154     return kvm_get_free_slot(&s->memory_listener);
 155 }
 156
 157 static KVMSlot *kvm_alloc_slot(KVMMemoryListener *kml)
 158 {
 159     KVMSlot *slot = kvm_get_free_slot(kml);
 160
 161     if (slot) {
 162         return slot;
 163     }
 164
 165     fprintf(stderr, "%s: no free slot available\n", __func__);
 166     abort();
 167 }
 168
 169 static KVMSlot *kvm_lookup_matching_slot(KVMMemoryListener *kml,
 170                                          hwaddr start_addr,
 171                                          hwaddr end_addr)
 172 {
 173     KVMState *s = kvm_state;
 174     int i;
 175
 176     for (i = 0; i < s->nr_slots; i++) {
 177         KVMSlot *mem = &kml->slots[i];
 178
 179         if (start_addr == mem->start_addr &&
 180             end_addr == mem->start_addr + mem->memory_size) {
 181             return mem;
 182         }
 183     }
 184
 185     return NULL;
 186 }
 187
 188 /*
 189  * Find overlapping slot with lowest start address
 190  */
 191 static KVMSlot *kvm_lookup_overlapping_slot(KVMMemoryListener *kml,
 192                                             hwaddr start_addr,
 193                                             hwaddr end_addr)
 194 {
 195     KVMState *s = kvm_state;
 196     KVMSlot *found = NULL;
 197     int i;
 198
 199     for (i = 0; i < s->nr_slots; i++) {
 200         KVMSlot *mem = &kml->slots[i];
 201
 202         if (mem->memory_size == 0 ||
 203             (found && found->start_addr < mem->start_addr)) {
 204             continue;
 205         }
 206
 207         if (end_addr > mem->start_addr &&
 208             start_addr < mem->start_addr + mem->memory_size) {
 209             found = mem;
 210         }
 211     }
 212
 213     return found;
 214 }
 215
 216 int kvm_physical_memory_addr_from_host(KVMState *s, void *ram,
 217                                        hwaddr *phys_addr)
 218 {
 219     KVMMemoryListener *kml = &s->memory_listener;
 220     int i;
 221
 222     for (i = 0; i < s->nr_slots; i++) {
 223         KVMSlot *mem = &kml->slots[i];
 224
 225         if (ram >= mem->ram && ram < mem->ram + mem->memory_size) {
 226             *phys_addr = mem->start_addr + (ram - mem->ram);
 227             return 1;
 228         }
 229     }
 230
 231     return 0;
 232 }
 233
 234 static int kvm_set_user_memory_region(KVMMemoryListener *kml, KVMSlot *slot)
 235 {
 236     KVMState *s = kvm_state;
 237     struct kvm_userspace_memory_region mem;
 238
 239     mem.slot = slot->slot | (kml->as_id << 16);
 240     mem.guest_phys_addr = slot->start_addr;
 241     mem.userspace_addr = (unsigned long)slot->ram;
 242     mem.flags = slot->flags;
 243
 244     if (slot->memory_size && mem.flags & KVM_MEM_READONLY) {
 245         /* Set the slot size to 0 before setting the slot to the desired
 246          * value. This is needed based on KVM commit 75d61fbc. */
 247         mem.memory_size = 0;
 248         kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 249     }
 250     mem.memory_size = slot->memory_size;
 251     return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 252 }
 253
 254 int kvm_destroy_vcpu(CPUState *cpu)
 255 {
 256     KVMState *s = kvm_state;
 257     long mmap_size;
 258     struct KVMParkedVcpu *vcpu = NULL;
 259     int ret = 0;
 260
 261     DPRINTF("kvm_destroy_vcpu\n");
 262
 263     mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
 264     if (mmap_size < 0) {
 265         ret = mmap_size;
 266         DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
 267         goto err;
 268     }
 269
 270     ret = munmap(cpu->kvm_run, mmap_size);
 271     if (ret < 0) {
 272         goto err;
 273     }
 274
 275     vcpu = g_malloc0(sizeof(*vcpu));
 276     vcpu->vcpu_id = kvm_arch_vcpu_id(cpu);
 277     vcpu->kvm_fd = cpu->kvm_fd;
 278     QLIST_INSERT_HEAD(&kvm_state->kvm_parked_vcpus, vcpu, node);
 279 err:
 280     return ret;
 281 }
 282
 283 static int kvm_get_vcpu(KVMState *s, unsigned long vcpu_id)
 284 {
 285     struct KVMParkedVcpu *cpu;
 286
 287     QLIST_FOREACH(cpu, &s->kvm_parked_vcpus, node) {
 288         if (cpu->vcpu_id == vcpu_id) {
 289             int kvm_fd;
 290
 291             QLIST_REMOVE(cpu, node);
 292             kvm_fd = cpu->kvm_fd;
 293             g_free(cpu);
 294             return kvm_fd;
 295         }
 296     }
 297
 298     return kvm_vm_ioctl(s, KVM_CREATE_VCPU, (void *)vcpu_id);
 299 }
 300
 301 int kvm_init_vcpu(CPUState *cpu)
 302 {
 303     KVMState *s = kvm_state;
 304     long mmap_size;
 305     int ret;
 306
 307     DPRINTF("kvm_init_vcpu\n");
 308
 309     ret = kvm_get_vcpu(s, kvm_arch_vcpu_id(cpu));
 310     if (ret < 0) {
 311         DPRINTF("kvm_create_vcpu failed\n");
 312         goto err;
 313     }
 314
 315     cpu->kvm_fd = ret;
 316     cpu->kvm_state = s;
 317     cpu->kvm_vcpu_dirty = true;
 318
 319     mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
 320     if (mmap_size < 0) {
 321         ret = mmap_size;
 322         DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
 323         goto err;
 324     }
 325
 326     cpu->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
 327                         cpu->kvm_fd, 0);
 328     if (cpu->kvm_run == MAP_FAILED) {
 329         ret = -errno;
 330         DPRINTF("mmap'ing vcpu state failed\n");
 331         goto err;
 332     }
 333
 334     if (s->coalesced_mmio && !s->coalesced_mmio_ring) {
 335         s->coalesced_mmio_ring =
 336             (void *)cpu->kvm_run + s->coalesced_mmio * PAGE_SIZE;
 337     }
 338
 339     ret = kvm_arch_init_vcpu(cpu);
 340 err:
 341     return ret;
 342 }
 343
 344 /*
 345  * dirty pages logging control
 346  */
 347
 348 static int kvm_mem_flags(MemoryRegion *mr)
 349 {
 350     bool readonly = mr->readonly || memory_region_is_romd(mr);
 351     int flags = 0;
 352
 353     if (memory_region_get_dirty_log_mask(mr) != 0) {
 354         flags |= KVM_MEM_LOG_DIRTY_PAGES;
 355     }
 356     if (readonly && kvm_readonly_mem_allowed) {
 357         flags |= KVM_MEM_READONLY;
 358     }
 359     return flags;
 360 }
 361
 362 static int kvm_slot_update_flags(KVMMemoryListener *kml, KVMSlot *mem,
 363                                  MemoryRegion *mr)
 364 {
 365     int old_flags;
 366
 367     old_flags = mem->flags;
 368     mem->flags = kvm_mem_flags(mr);
 369
 370     /* If nothing changed effectively, no need to issue ioctl */
 371     if (mem->flags == old_flags) {
 372         return 0;
 373     }
 374
 375     return kvm_set_user_memory_region(kml, mem);
 376 }
 377
 378 static int kvm_section_update_flags(KVMMemoryListener *kml,
 379                                     MemoryRegionSection *section)
 380 {
 381     hwaddr phys_addr = section->offset_within_address_space;
 382     ram_addr_t size = int128_get64(section->size);
 383     KVMSlot *mem = kvm_lookup_matching_slot(kml, phys_addr, phys_addr + size);
 384
 385     if (mem == NULL)  {
 386         return 0;
 387     } else {
 388         return kvm_slot_update_flags(kml, mem, section->mr);
 389     }
 390 }
 391
 392 static void kvm_log_start(MemoryListener *listener,
 393                           MemoryRegionSection *section,
 394                           int old, int new)
 395 {
 396     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
 397     int r;
 398
 399     if (old != 0) {
 400         return;
 401     }
 402
 403     r = kvm_section_update_flags(kml, section);
 404     if (r < 0) {
 405         abort();
 406     }
 407 }
 408
 409 static void kvm_log_stop(MemoryListener *listener,
 410                           MemoryRegionSection *section,
 411                           int old, int new)
 412 {
 413     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
 414     int r;
 415
 416     if (new != 0) {
 417         return;
 418     }
 419
 420     r = kvm_section_update_flags(kml, section);
 421     if (r < 0) {
 422         abort();
 423     }
 424 }
 425
 426 /* get kvm's dirty pages bitmap and update qemu's */
 427 static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section,
 428                                          unsigned long *bitmap)
 429 {
 430     ram_addr_t start = section->offset_within_region +
 431                        memory_region_get_ram_addr(section->mr);
 432     ram_addr_t pages = int128_get64(section->size) / getpagesize();
 433
 434     cpu_physical_memory_set_dirty_lebitmap(bitmap, start, pages);
 435     return 0;
 436 }
 437
 438 #define ALIGN(x, y)  (((x)+(y)-1) & ~((y)-1))
 439
 440 /**
 441  * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
 442  * This function updates qemu's dirty bitmap using
 443  * memory_region_set_dirty().  This means all bits are set
 444  * to dirty.
 445  *
 446  * @start_add: start of logged region.
 447  * @end_addr: end of logged region.
 448  */
 449 static int kvm_physical_sync_dirty_bitmap(KVMMemoryListener *kml,
 450                                           MemoryRegionSection *section)
 451 {
 452     KVMState *s = kvm_state;
 453     unsigned long size, allocated_size = 0;
 454     struct kvm_dirty_log d = {};
 455     KVMSlot *mem;
 456     int ret = 0;
 457     hwaddr start_addr = section->offset_within_address_space;
 458     hwaddr end_addr = start_addr + int128_get64(section->size);
 459
 460     d.dirty_bitmap = NULL;
 461     while (start_addr < end_addr) {
 462         mem = kvm_lookup_overlapping_slot(kml, start_addr, end_addr);
 463         if (mem == NULL) {
 464             break;
 465         }
 466
 467         /* XXX bad kernel interface alert
 468          * For dirty bitmap, kernel allocates array of size aligned to
 469          * bits-per-long.  But for case when the kernel is 64bits and
 470          * the userspace is 32bits, userspace can't align to the same
 471          * bits-per-long, since sizeof(long) is different between kernel
 472          * and user space.  This way, userspace will provide buffer which
 473          * may be 4 bytes less than the kernel will use, resulting in
 474          * userspace memory corruption (which is not detectable by valgrind
 475          * too, in most cases).
 476          * So for now, let's align to 64 instead of HOST_LONG_BITS here, in
 477          * a hope that sizeof(long) won't become >8 any time soon.
 478          */
 479         size = ALIGN(((mem->memory_size) >> TARGET_PAGE_BITS),
 480                      /*HOST_LONG_BITS*/ 64) / 8;
 481         if (!d.dirty_bitmap) {
 482             d.dirty_bitmap = g_malloc(size);
 483         } else if (size > allocated_size) {
 484             d.dirty_bitmap = g_realloc(d.dirty_bitmap, size);
 485         }
 486         allocated_size = size;
 487         memset(d.dirty_bitmap, 0, allocated_size);
 488
 489         d.slot = mem->slot | (kml->as_id << 16);
 490         if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
 491             DPRINTF("ioctl failed %d\n", errno);
 492             ret = -1;
 493             break;
 494         }
 495
 496         kvm_get_dirty_pages_log_range(section, d.dirty_bitmap);
 497         start_addr = mem->start_addr + mem->memory_size;
 498     }
 499     g_free(d.dirty_bitmap);
 500
 501     return ret;
 502 }
 503
 504 static void kvm_coalesce_mmio_region(MemoryListener *listener,
 505                                      MemoryRegionSection *secion,
 506                                      hwaddr start, hwaddr size)
 507 {
 508     KVMState *s = kvm_state;
 509
 510     if (s->coalesced_mmio) {
 511         struct kvm_coalesced_mmio_zone zone;
 512
 513         zone.addr = start;
 514         zone.size = size;
 515         zone.pad = 0;
 516
 517         (void)kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
 518     }
 519 }
 520
 521 static void kvm_uncoalesce_mmio_region(MemoryListener *listener,
 522                                        MemoryRegionSection *secion,
 523                                        hwaddr start, hwaddr size)
 524 {
 525     KVMState *s = kvm_state;
 526
 527     if (s->coalesced_mmio) {
 528         struct kvm_coalesced_mmio_zone zone;
 529
 530         zone.addr = start;
 531         zone.size = size;
 532         zone.pad = 0;
 533
 534         (void)kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
 535     }
 536 }
 537
 538 int kvm_check_extension(KVMState *s, unsigned int extension)
 539 {
 540     int ret;
 541
 542     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
 543     if (ret < 0) {
 544         ret = 0;
 545     }
 546
 547     return ret;
 548 }
 549
 550 int kvm_vm_check_extension(KVMState *s, unsigned int extension)
 551 {
 552     int ret;
 553
 554     ret = kvm_vm_ioctl(s, KVM_CHECK_EXTENSION, extension);
 555     if (ret < 0) {
 556         /* VM wide version not implemented, use global one instead */
 557         ret = kvm_check_extension(s, extension);
 558     }
 559
 560     return ret;
 561 }
 562
 563 static uint32_t adjust_ioeventfd_endianness(uint32_t val, uint32_t size)
 564 {
 565 #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
 566     /* The kernel expects ioeventfd values in HOST_WORDS_BIGENDIAN
 567      * endianness, but the memory core hands them in target endianness.
 568      * For example, PPC is always treated as big-endian even if running
 569      * on KVM and on PPC64LE.  Correct here.
 570      */
 571     switch (size) {
 572     case 2:
 573         val = bswap16(val);
 574         break;
 575     case 4:
 576         val = bswap32(val);
 577         break;
 578     }
 579 #endif
 580     return val;
 581 }
 582
 583 static int kvm_set_ioeventfd_mmio(int fd, hwaddr addr, uint32_t val,
 584                                   bool assign, uint32_t size, bool datamatch)
 585 {
 586     int ret;
 587     struct kvm_ioeventfd iofd = {
 588         .datamatch = datamatch ? adjust_ioeventfd_endianness(val, size) : 0,
 589         .addr = addr,
 590         .len = size,
 591         .flags = 0,
 592         .fd = fd,
 593     };
 594
 595     if (!kvm_enabled()) {
 596         return -ENOSYS;
 597     }
 598
 599     if (datamatch) {
 600         iofd.flags |= KVM_IOEVENTFD_FLAG_DATAMATCH;
 601     }
 602     if (!assign) {
 603         iofd.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
 604     }
 605
 606     ret = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &iofd);
 607
 608     if (ret < 0) {
 609         return -errno;
 610     }
 611
 612     return 0;
 613 }
 614
 615 static int kvm_set_ioeventfd_pio(int fd, uint16_t addr, uint16_t val,
 616                                  bool assign, uint32_t size, bool datamatch)
 617 {
 618     struct kvm_ioeventfd kick = {
 619         .datamatch = datamatch ? adjust_ioeventfd_endianness(val, size) : 0,
 620         .addr = addr,
 621         .flags = KVM_IOEVENTFD_FLAG_PIO,
 622         .len = size,
 623         .fd = fd,
 624     };
 625     int r;
 626     if (!kvm_enabled()) {
 627         return -ENOSYS;
 628     }
 629     if (datamatch) {
 630         kick.flags |= KVM_IOEVENTFD_FLAG_DATAMATCH;
 631     }
 632     if (!assign) {
 633         kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
 634     }
 635     r = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
 636     if (r < 0) {
 637         return r;
 638     }
 639     return 0;
 640 }
 641
 642
 643 static int kvm_check_many_ioeventfds(void)
 644 {
 645     /* Userspace can use ioeventfd for io notification.  This requires a host
 646      * that supports eventfd(2) and an I/O thread; since eventfd does not
 647      * support SIGIO it cannot interrupt the vcpu.
 648      *
 649      * Older kernels have a 6 device limit on the KVM io bus.  Find out so we
 650      * can avoid creating too many ioeventfds.
 651      */
 652 #if defined(CONFIG_EVENTFD)
 653     int ioeventfds[7];
 654     int i, ret = 0;
 655     for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
 656         ioeventfds[i] = eventfd(0, EFD_CLOEXEC);
 657         if (ioeventfds[i] < 0) {
 658             break;
 659         }
 660         ret = kvm_set_ioeventfd_pio(ioeventfds[i], 0, i, true, 2, true);
 661         if (ret < 0) {
 662             close(ioeventfds[i]);
 663             break;
 664         }
 665     }
 666
 667     /* Decide whether many devices are supported or not */
 668     ret = i == ARRAY_SIZE(ioeventfds);
 669
 670     while (i-- > 0) {
 671         kvm_set_ioeventfd_pio(ioeventfds[i], 0, i, false, 2, true);
 672         close(ioeventfds[i]);
 673     }
 674     return ret;
 675 #else
 676     return 0;
 677 #endif
 678 }
 679
 680 static const KVMCapabilityInfo *
 681 kvm_check_extension_list(KVMState *s, const KVMCapabilityInfo *list)
 682 {
 683     while (list->name) {
 684         if (!kvm_check_extension(s, list->value)) {
 685             return list;
 686         }
 687         list++;
 688     }
 689     return NULL;
 690 }
 691
 692 static void kvm_set_phys_mem(KVMMemoryListener *kml,
 693                              MemoryRegionSection *section, bool add)
 694 {
 695     KVMState *s = kvm_state;
 696     KVMSlot *mem, old;
 697     int err;
 698     MemoryRegion *mr = section->mr;
 699     bool writeable = !mr->readonly && !mr->rom_device;
 700     hwaddr start_addr = section->offset_within_address_space;
 701     ram_addr_t size = int128_get64(section->size);
 702     void *ram = NULL;
 703     unsigned delta;
 704
 705     /* kvm works in page size chunks, but the function may be called
 706        with sub-page size and unaligned start address. Pad the start
 707        address to next and truncate size to previous page boundary. */
 708     delta = qemu_real_host_page_size - (start_addr & ~qemu_real_host_page_mask);
 709     delta &= ~qemu_real_host_page_mask;
 710     if (delta > size) {
 711         return;
 712     }
 713     start_addr += delta;
 714     size -= delta;
 715     size &= qemu_real_host_page_mask;
 716     if (!size || (start_addr & ~qemu_real_host_page_mask)) {
 717         return;
 718     }
 719
 720     if (!memory_region_is_ram(mr)) {
 721         if (writeable || !kvm_readonly_mem_allowed) {
 722             return;
 723         } else if (!mr->romd_mode) {
 724             /* If the memory device is not in romd_mode, then we actually want
 725              * to remove the kvm memory slot so all accesses will trap. */
 726             add = false;
 727         }
 728     }
 729
 730     ram = memory_region_get_ram_ptr(mr) + section->offset_within_region + delta;
 731
 732     while (1) {
 733         mem = kvm_lookup_overlapping_slot(kml, start_addr, start_addr + size);
 734         if (!mem) {
 735             break;
 736         }
 737
 738         if (add && start_addr >= mem->start_addr &&
 739             (start_addr + size <= mem->start_addr + mem->memory_size) &&
 740             (ram - start_addr == mem->ram - mem->start_addr)) {
 741             /* The new slot fits into the existing one and comes with
 742              * identical parameters - update flags and done. */
 743             kvm_slot_update_flags(kml, mem, mr);
 744             return;
 745         }
 746
 747         old = *mem;
 748
 749         if (mem->flags & KVM_MEM_LOG_DIRTY_PAGES) {
 750             kvm_physical_sync_dirty_bitmap(kml, section);
 751         }
 752
 753         /* unregister the overlapping slot */
 754         mem->memory_size = 0;
 755         err = kvm_set_user_memory_region(kml, mem);
 756         if (err) {
 757             fprintf(stderr, "%s: error unregistering overlapping slot: %s\n",
 758                     __func__, strerror(-err));
 759             abort();
 760         }
 761
 762         /* Workaround for older KVM versions: we can't join slots, even not by
 763          * unregistering the previous ones and then registering the larger
 764          * slot. We have to maintain the existing fragmentation. Sigh.
 765          *
 766          * This workaround assumes that the new slot starts at the same
 767          * address as the first existing one. If not or if some overlapping
 768          * slot comes around later, we will fail (not seen in practice so far)
 769          * - and actually require a recent KVM version. */
 770         if (s->broken_set_mem_region &&
 771             old.start_addr == start_addr && old.memory_size < size && add) {
 772             mem = kvm_alloc_slot(kml);
 773             mem->memory_size = old.memory_size;
 774             mem->start_addr = old.start_addr;
 775             mem->ram = old.ram;
 776             mem->flags = kvm_mem_flags(mr);
 777
 778             err = kvm_set_user_memory_region(kml, mem);
 779             if (err) {
 780                 fprintf(stderr, "%s: error updating slot: %s\n", __func__,
 781                         strerror(-err));
 782                 abort();
 783             }
 784
 785             start_addr += old.memory_size;
 786             ram += old.memory_size;
 787             size -= old.memory_size;
 788             continue;
 789         }
 790
 791         /* register prefix slot */
 792         if (old.start_addr < start_addr) {
 793             mem = kvm_alloc_slot(kml);
 794             mem->memory_size = start_addr - old.start_addr;
 795             mem->start_addr = old.start_addr;
 796             mem->ram = old.ram;
 797             mem->flags =  kvm_mem_flags(mr);
 798
 799             err = kvm_set_user_memory_region(kml, mem);
 800             if (err) {
 801                 fprintf(stderr, "%s: error registering prefix slot: %s\n",
 802                         __func__, strerror(-err));
 803 #ifdef TARGET_PPC
 804                 fprintf(stderr, "%s: This is probably because your kernel's " \
 805                                 "PAGE_SIZE is too big. Please try to use 4k " \
 806                                 "PAGE_SIZE!\n", __func__);
 807 #endif
 808                 abort();
 809             }
 810         }
 811
 812         /* register suffix slot */
 813         if (old.start_addr + old.memory_size > start_addr + size) {
 814             ram_addr_t size_delta;
 815
 816             mem = kvm_alloc_slot(kml);
 817             mem->start_addr = start_addr + size;
 818             size_delta = mem->start_addr - old.start_addr;
 819             mem->memory_size = old.memory_size - size_delta;
 820             mem->ram = old.ram + size_delta;
 821             mem->flags = kvm_mem_flags(mr);
 822
 823             err = kvm_set_user_memory_region(kml, mem);
 824             if (err) {
 825                 fprintf(stderr, "%s: error registering suffix slot: %s\n",
 826                         __func__, strerror(-err));
 827                 abort();
 828             }
 829         }
 830     }
 831
 832     /* in case the KVM bug workaround already "consumed" the new slot */
 833     if (!size) {
 834         return;
 835     }
 836     if (!add) {
 837         return;
 838     }
 839     mem = kvm_alloc_slot(kml);
 840     mem->memory_size = size;
 841     mem->start_addr = start_addr;
 842     mem->ram = ram;
 843     mem->flags = kvm_mem_flags(mr);
 844
 845     err = kvm_set_user_memory_region(kml, mem);
 846     if (err) {
 847         fprintf(stderr, "%s: error registering slot: %s\n", __func__,
 848                 strerror(-err));
 849         abort();
 850     }
 851 }
 852
 853 static void kvm_region_add(MemoryListener *listener,
 854                            MemoryRegionSection *section)
 855 {
 856     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
 857
 858     memory_region_ref(section->mr);
 859     kvm_set_phys_mem(kml, section, true);
 860 }
 861
 862 static void kvm_region_del(MemoryListener *listener,
 863                            MemoryRegionSection *section)
 864 {
 865     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
 866
 867     kvm_set_phys_mem(kml, section, false);
 868     memory_region_unref(section->mr);
 869 }
 870
 871 static void kvm_log_sync(MemoryListener *listener,
 872                          MemoryRegionSection *section)
 873 {
 874     KVMMemoryListener *kml = container_of(listener, KVMMemoryListener, listener);
 875     int r;
 876
 877     r = kvm_physical_sync_dirty_bitmap(kml, section);
 878     if (r < 0) {
 879         abort();
 880     }
 881 }
 882
 883 static void kvm_mem_ioeventfd_add(MemoryListener *listener,
 884                                   MemoryRegionSection *section,
 885                                   bool match_data, uint64_t data,
 886                                   EventNotifier *e)
 887 {
 888     int fd = event_notifier_get_fd(e);
 889     int r;
 890
 891     r = kvm_set_ioeventfd_mmio(fd, section->offset_within_address_space,
 892                                data, true, int128_get64(section->size),
 893                                match_data);
 894     if (r < 0) {
 895         fprintf(stderr, "%s: error adding ioeventfd: %s\n",
 896                 __func__, strerror(-r));
 897         abort();
 898     }
 899 }
 900
 901 static void kvm_mem_ioeventfd_del(MemoryListener *listener,
 902                                   MemoryRegionSection *section,
 903                                   bool match_data, uint64_t data,
 904                                   EventNotifier *e)
 905 {
 906     int fd = event_notifier_get_fd(e);
 907     int r;
 908
 909     r = kvm_set_ioeventfd_mmio(fd, section->offset_within_address_space,
 910                                data, false, int128_get64(section->size),
 911                                match_data);
 912     if (r < 0) {
 913         abort();
 914     }
 915 }
 916
 917 static void kvm_io_ioeventfd_add(MemoryListener *listener,
 918                                  MemoryRegionSection *section,
 919                                  bool match_data, uint64_t data,
 920                                  EventNotifier *e)
 921 {
 922     int fd = event_notifier_get_fd(e);
 923     int r;
 924
 925     r = kvm_set_ioeventfd_pio(fd, section->offset_within_address_space,
 926                               data, true, int128_get64(section->size),
 927                               match_data);
 928     if (r < 0) {
 929         fprintf(stderr, "%s: error adding ioeventfd: %s\n",
 930                 __func__, strerror(-r));
 931         abort();
 932     }
 933 }
 934
 935 static void kvm_io_ioeventfd_del(MemoryListener *listener,
 936                                  MemoryRegionSection *section,
 937                                  bool match_data, uint64_t data,
 938                                  EventNotifier *e)
 939
 940 {
 941     int fd = event_notifier_get_fd(e);
 942     int r;
 943
 944     r = kvm_set_ioeventfd_pio(fd, section->offset_within_address_space,
 945                               data, false, int128_get64(section->size),
 946                               match_data);
 947     if (r < 0) {
 948         abort();
 949     }
 950 }
 951
 952 void kvm_memory_listener_register(KVMState *s, KVMMemoryListener *kml,
 953                                   AddressSpace *as, int as_id)
 954 {
 955     int i;
 956
 957     kml->slots = g_malloc0(s->nr_slots * sizeof(KVMSlot));
 958     kml->as_id = as_id;
 959
 960     for (i = 0; i < s->nr_slots; i++) {
 961         kml->slots[i].slot = i;
 962     }
 963
 964     kml->listener.region_add = kvm_region_add;
 965     kml->listener.region_del = kvm_region_del;
 966     kml->listener.log_start = kvm_log_start;
 967     kml->listener.log_stop = kvm_log_stop;
 968     kml->listener.log_sync = kvm_log_sync;
 969     kml->listener.priority = 10;
 970
 971     memory_listener_register(&kml->listener, as);
 972 }
 973
 974 static MemoryListener kvm_io_listener = {
 975     .eventfd_add = kvm_io_ioeventfd_add,
 976     .eventfd_del = kvm_io_ioeventfd_del,
 977     .priority = 10,
 978 };
 979
 980 static void kvm_handle_interrupt(CPUState *cpu, int mask)
 981 {
 982     cpu->interrupt_request |= mask;
 983
 984     if (!qemu_cpu_is_self(cpu)) {
 985         qemu_cpu_kick(cpu);
 986     }
 987 }
 988
 989 int kvm_set_irq(KVMState *s, int irq, int level)
 990 {
 991     struct kvm_irq_level event;
 992     int ret;
 993
 994     assert(kvm_async_interrupts_enabled());
 995
 996     event.level = level;
 997     event.irq = irq;
 998     ret = kvm_vm_ioctl(s, s->irq_set_ioctl, &event);
 999     if (ret < 0) {
1000         perror("kvm_set_irq");
1001         abort();
1002     }
1003
1004     return (s->irq_set_ioctl == KVM_IRQ_LINE) ? 1 : event.status;
1005 }
1006
1007 #ifdef KVM_CAP_IRQ_ROUTING
1008 typedef struct KVMMSIRoute {
1009     struct kvm_irq_routing_entry kroute;
1010     QTAILQ_ENTRY(KVMMSIRoute) entry;
1011 } KVMMSIRoute;
1012
1013 static void set_gsi(KVMState *s, unsigned int gsi)
1014 {
1015     set_bit(gsi, s->used_gsi_bitmap);
1016 }
1017
1018 static void clear_gsi(KVMState *s, unsigned int gsi)
1019 {
1020     clear_bit(gsi, s->used_gsi_bitmap);
1021 }
1022
1023 void kvm_init_irq_routing(KVMState *s)
1024 {
1025     int gsi_count, i;
1026
1027     gsi_count = kvm_check_extension(s, KVM_CAP_IRQ_ROUTING) - 1;
1028     if (gsi_count > 0) {
1029         /* Round up so we can search ints using ffs */
1030         s->used_gsi_bitmap = bitmap_new(gsi_count);
1031         s->gsi_count = gsi_count;
1032     }
1033
1034     s->irq_routes = g_malloc0(sizeof(*s->irq_routes));
1035     s->nr_allocated_irq_routes = 0;
1036
1037     if (!kvm_direct_msi_allowed) {
1038         for (i = 0; i < KVM_MSI_HASHTAB_SIZE; i++) {
1039             QTAILQ_INIT(&s->msi_hashtab[i]);
1040         }
1041     }
1042
1043     kvm_arch_init_irq_routing(s);
1044 }
1045
1046 void kvm_irqchip_commit_routes(KVMState *s)
1047 {
1048     int ret;
1049
1050     s->irq_routes->flags = 0;
1051     trace_kvm_irqchip_commit_routes();
1052     ret = kvm_vm_ioctl(s, KVM_SET_GSI_ROUTING, s->irq_routes);
1053     assert(ret == 0);
1054 }
1055
1056 static void kvm_add_routing_entry(KVMState *s,
1057                                   struct kvm_irq_routing_entry *entry)
1058 {
1059     struct kvm_irq_routing_entry *new;
1060     int n, size;
1061
1062     if (s->irq_routes->nr == s->nr_allocated_irq_routes) {
1063         n = s->nr_allocated_irq_routes * 2;
1064         if (n < 64) {
1065             n = 64;
1066         }
1067         size = sizeof(struct kvm_irq_routing);
1068         size += n * sizeof(*new);
1069         s->irq_routes = g_realloc(s->irq_routes, size);
1070         s->nr_allocated_irq_routes = n;
1071     }
1072     n = s->irq_routes->nr++;
1073     new = &s->irq_routes->entries[n];
1074
1075     *new = *entry;
1076
1077     set_gsi(s, entry->gsi);
1078 }
1079
1080 static int kvm_update_routing_entry(KVMState *s,
1081                                     struct kvm_irq_routing_entry *new_entry)
1082 {
1083     struct kvm_irq_routing_entry *entry;
1084     int n;
1085
1086     for (n = 0; n < s->irq_routes->nr; n++) {
1087         entry = &s->irq_routes->entries[n];
1088         if (entry->gsi != new_entry->gsi) {
1089             continue;
1090         }
1091
1092         if(!memcmp(entry, new_entry, sizeof *entry)) {
1093             return 0;
1094         }
1095
1096         *entry = *new_entry;
1097
1098         return 0;
1099     }
1100
1101     return -ESRCH;
1102 }
1103
1104 void kvm_irqchip_add_irq_route(KVMState *s, int irq, int irqchip, int pin)
1105 {
1106     struct kvm_irq_routing_entry e = {};
1107
1108     assert(pin < s->gsi_count);
1109
1110     e.gsi = irq;
1111     e.type = KVM_IRQ_ROUTING_IRQCHIP;
1112     e.flags = 0;
1113     e.u.irqchip.irqchip = irqchip;
1114     e.u.irqchip.pin = pin;
1115     kvm_add_routing_entry(s, &e);
1116 }
1117
1118 void kvm_irqchip_release_virq(KVMState *s, int virq)
1119 {
1120     struct kvm_irq_routing_entry *e;
1121     int i;
1122
1123     if (kvm_gsi_direct_mapping()) {
1124         return;
1125     }
1126
1127     for (i = 0; i < s->irq_routes->nr; i++) {
1128         e = &s->irq_routes->entries[i];
1129         if (e->gsi == virq) {
1130             s->irq_routes->nr--;
1131             *e = s->irq_routes->entries[s->irq_routes->nr];
1132         }
1133     }
1134     clear_gsi(s, virq);
1135     kvm_arch_release_virq_post(virq);
1136 }
1137
1138 static unsigned int kvm_hash_msi(uint32_t data)
1139 {
1140     /* This is optimized for IA32 MSI layout. However, no other arch shall
1141      * repeat the mistake of not providing a direct MSI injection API. */
1142     return data & 0xff;
1143 }
1144
1145 static void kvm_flush_dynamic_msi_routes(KVMState *s)
1146 {
1147     KVMMSIRoute *route, *next;
1148     unsigned int hash;
1149
1150     for (hash = 0; hash < KVM_MSI_HASHTAB_SIZE; hash++) {
1151         QTAILQ_FOREACH_SAFE(route, &s->msi_hashtab[hash], entry, next) {
1152             kvm_irqchip_release_virq(s, route->kroute.gsi);
1153             QTAILQ_REMOVE(&s->msi_hashtab[hash], route, entry);
1154             g_free(route);
1155         }
1156     }
1157 }
1158
1159 static int kvm_irqchip_get_virq(KVMState *s)
1160 {
1161     int next_virq;
1162
1163     /*
1164      * PIC and IOAPIC share the first 16 GSI numbers, thus the available
1165      * GSI numbers are more than the number of IRQ route. Allocating a GSI
1166      * number can succeed even though a new route entry cannot be added.
1167      * When this happens, flush dynamic MSI entries to free IRQ route entries.
1168      */
1169     if (!kvm_direct_msi_allowed && s->irq_routes->nr == s->gsi_count) {
1170         kvm_flush_dynamic_msi_routes(s);
1171     }
1172
1173     /* Return the lowest unused GSI in the bitmap */
1174     next_virq = find_first_zero_bit(s->used_gsi_bitmap, s->gsi_count);
1175     if (next_virq >= s->gsi_count) {
1176         return -ENOSPC;
1177     } else {
1178         return next_virq;
1179     }
1180 }
1181
1182 static KVMMSIRoute *kvm_lookup_msi_route(KVMState *s, MSIMessage msg)
1183 {
1184     unsigned int hash = kvm_hash_msi(msg.data);
1185     KVMMSIRoute *route;
1186
1187     QTAILQ_FOREACH(route, &s->msi_hashtab[hash], entry) {
1188         if (route->kroute.u.msi.address_lo == (uint32_t)msg.address &&
1189             route->kroute.u.msi.address_hi == (msg.address >> 32) &&
1190             route->kroute.u.msi.data == le32_to_cpu(msg.data)) {
1191             return route;
1192         }
1193     }
1194     return NULL;
1195 }
1196
1197 int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg)
1198 {
1199     struct kvm_msi msi;
1200     KVMMSIRoute *route;
1201
1202     if (kvm_direct_msi_allowed) {
1203         msi.address_lo = (uint32_t)msg.address;
1204         msi.address_hi = msg.address >> 32;
1205         msi.data = le32_to_cpu(msg.data);
1206         msi.flags = 0;
1207         memset(msi.pad, 0, sizeof(msi.pad));
1208
1209         return kvm_vm_ioctl(s, KVM_SIGNAL_MSI, &msi);
1210     }
1211
1212     route = kvm_lookup_msi_route(s, msg);
1213     if (!route) {
1214         int virq;
1215
1216         virq = kvm_irqchip_get_virq(s);
1217         if (virq < 0) {
1218             return virq;
1219         }
1220
1221         route = g_malloc0(sizeof(KVMMSIRoute));
1222         route->kroute.gsi = virq;
1223         route->kroute.type = KVM_IRQ_ROUTING_MSI;
1224         route->kroute.flags = 0;
1225         route->kroute.u.msi.address_lo = (uint32_t)msg.address;
1226         route->kroute.u.msi.address_hi = msg.address >> 32;
1227         route->kroute.u.msi.data = le32_to_cpu(msg.data);
1228
1229         kvm_add_routing_entry(s, &route->kroute);
1230         kvm_irqchip_commit_routes(s);
1231
1232         QTAILQ_INSERT_TAIL(&s->msi_hashtab[kvm_hash_msi(msg.data)], route,
1233                            entry);
1234     }
1235
1236     assert(route->kroute.type == KVM_IRQ_ROUTING_MSI);
1237
1238     return kvm_set_irq(s, route->kroute.gsi, 1);
1239 }
1240
1241 int kvm_irqchip_add_msi_route(KVMState *s, int vector, PCIDevice *dev)
1242 {
1243     struct kvm_irq_routing_entry kroute = {};
1244     int virq;
1245     MSIMessage msg = {0, 0};
1246
1247     if (dev) {
1248         msg = pci_get_msi_message(dev, vector);
1249     }
1250
1251     if (kvm_gsi_direct_mapping()) {
1252         return kvm_arch_msi_data_to_gsi(msg.data);
1253     }
1254
1255     if (!kvm_gsi_routing_enabled()) {
1256         return -ENOSYS;
1257     }
1258
1259     virq = kvm_irqchip_get_virq(s);
1260     if (virq < 0) {
1261         return virq;
1262     }
1263
1264     kroute.gsi = virq;
1265     kroute.type = KVM_IRQ_ROUTING_MSI;
1266     kroute.flags = 0;
1267     kroute.u.msi.address_lo = (uint32_t)msg.address;
1268     kroute.u.msi.address_hi = msg.address >> 32;
1269     kroute.u.msi.data = le32_to_cpu(msg.data);
1270     if (kvm_arch_fixup_msi_route(&kroute, msg.address, msg.data, dev)) {
1271         kvm_irqchip_release_virq(s, virq);
1272         return -EINVAL;
1273     }
1274
1275     trace_kvm_irqchip_add_msi_route(virq);
1276
1277     kvm_add_routing_entry(s, &kroute);
1278     kvm_arch_add_msi_route_post(&kroute, vector, dev);
1279     kvm_irqchip_commit_routes(s);
1280
1281     return virq;
1282 }
1283
1284 int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg,
1285                                  PCIDevice *dev)
1286 {
1287     struct kvm_irq_routing_entry kroute = {};
1288
1289     if (kvm_gsi_direct_mapping()) {
1290         return 0;
1291     }
1292
1293     if (!kvm_irqchip_in_kernel()) {
1294         return -ENOSYS;
1295     }
1296
1297     kroute.gsi = virq;
1298     kroute.type = KVM_IRQ_ROUTING_MSI;
1299     kroute.flags = 0;
1300     kroute.u.msi.address_lo = (uint32_t)msg.address;
1301     kroute.u.msi.address_hi = msg.address >> 32;
1302     kroute.u.msi.data = le32_to_cpu(msg.data);
1303     if (kvm_arch_fixup_msi_route(&kroute, msg.address, msg.data, dev)) {
1304         return -EINVAL;
1305     }
1306
1307     trace_kvm_irqchip_update_msi_route(virq);
1308
1309     return kvm_update_routing_entry(s, &kroute);
1310 }
1311
1312 static int kvm_irqchip_assign_irqfd(KVMState *s, int fd, int rfd, int virq,
1313                                     bool assign)
1314 {
1315     struct kvm_irqfd irqfd = {
1316         .fd = fd,
1317         .gsi = virq,
1318         .flags = assign ? 0 : KVM_IRQFD_FLAG_DEASSIGN,
1319     };
1320
1321     if (rfd != -1) {
1322         irqfd.flags |= KVM_IRQFD_FLAG_RESAMPLE;
1323         irqfd.resamplefd = rfd;
1324     }
1325
1326     if (!kvm_irqfds_enabled()) {
1327         return -ENOSYS;
1328     }
1329
1330     return kvm_vm_ioctl(s, KVM_IRQFD, &irqfd);
1331 }
1332
1333 int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter)
1334 {
1335     struct kvm_irq_routing_entry kroute = {};
1336     int virq;
1337
1338     if (!kvm_gsi_routing_enabled()) {
1339         return -ENOSYS;
1340     }
1341
1342     virq = kvm_irqchip_get_virq(s);
1343     if (virq < 0) {
1344         return virq;
1345     }
1346
1347     kroute.gsi = virq;
1348     kroute.type = KVM_IRQ_ROUTING_S390_ADAPTER;
1349     kroute.flags = 0;
1350     kroute.u.adapter.summary_addr = adapter->summary_addr;
1351     kroute.u.adapter.ind_addr = adapter->ind_addr;
1352     kroute.u.adapter.summary_offset = adapter->summary_offset;
1353     kroute.u.adapter.ind_offset = adapter->ind_offset;
1354     kroute.u.adapter.adapter_id = adapter->adapter_id;
1355
1356     kvm_add_routing_entry(s, &kroute);
1357
1358     return virq;
1359 }
1360
1361 int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint)
1362 {
1363     struct kvm_irq_routing_entry kroute = {};
1364     int virq;
1365
1366     if (!kvm_gsi_routing_enabled()) {
1367         return -ENOSYS;
1368     }
1369     if (!kvm_check_extension(s, KVM_CAP_HYPERV_SYNIC)) {
1370         return -ENOSYS;
1371     }
1372     virq = kvm_irqchip_get_virq(s);
1373     if (virq < 0) {
1374         return virq;
1375     }
1376
1377     kroute.gsi = virq;
1378     kroute.type = KVM_IRQ_ROUTING_HV_SINT;
1379     kroute.flags = 0;
1380     kroute.u.hv_sint.vcpu = vcpu;
1381     kroute.u.hv_sint.sint = sint;
1382
1383     kvm_add_routing_entry(s, &kroute);
1384     kvm_irqchip_commit_routes(s);
1385
1386     return virq;
1387 }
1388
1389 #else /* !KVM_CAP_IRQ_ROUTING */
1390
1391 void kvm_init_irq_routing(KVMState *s)
1392 {
1393 }
1394
1395 void kvm_irqchip_release_virq(KVMState *s, int virq)
1396 {
1397 }
1398
1399 int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg)
1400 {
1401     abort();
1402 }
1403
1404 int kvm_irqchip_add_msi_route(KVMState *s, int vector, PCIDevice *dev)
1405 {
1406     return -ENOSYS;
1407 }
1408
1409 int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter)
1410 {
1411     return -ENOSYS;
1412 }
1413
1414 int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint)
1415 {
1416     return -ENOSYS;
1417 }
1418
1419 static int kvm_irqchip_assign_irqfd(KVMState *s, int fd, int virq, bool assign)
1420 {
1421     abort();
1422 }
1423
1424 int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg)
1425 {
1426     return -ENOSYS;
1427 }
1428 #endif /* !KVM_CAP_IRQ_ROUTING */
1429
1430 int kvm_irqchip_add_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
1431                                        EventNotifier *rn, int virq)
1432 {
1433     return kvm_irqchip_assign_irqfd(s, event_notifier_get_fd(n),
1434            rn ? event_notifier_get_fd(rn) : -1, virq, true);
1435 }
1436
1437 int kvm_irqchip_remove_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
1438                                           int virq)
1439 {
1440     return kvm_irqchip_assign_irqfd(s, event_notifier_get_fd(n), -1, virq,
1441            false);
1442 }
1443
1444 int kvm_irqchip_add_irqfd_notifier(KVMState *s, EventNotifier *n,
1445                                    EventNotifier *rn, qemu_irq irq)
1446 {
1447     gpointer key, gsi;
1448     gboolean found = g_hash_table_lookup_extended(s->gsimap, irq, &key, &gsi);
1449
1450     if (!found) {
1451         return -ENXIO;
1452     }
1453     return kvm_irqchip_add_irqfd_notifier_gsi(s, n, rn, GPOINTER_TO_INT(gsi));
1454 }
1455
1456 int kvm_irqchip_remove_irqfd_notifier(KVMState *s, EventNotifier *n,
1457                                       qemu_irq irq)
1458 {
1459     gpointer key, gsi;
1460     gboolean found = g_hash_table_lookup_extended(s->gsimap, irq, &key, &gsi);
1461
1462     if (!found) {
1463         return -ENXIO;
1464     }
1465     return kvm_irqchip_remove_irqfd_notifier_gsi(s, n, GPOINTER_TO_INT(gsi));
1466 }
1467
1468 void kvm_irqchip_set_qemuirq_gsi(KVMState *s, qemu_irq irq, int gsi)
1469 {
1470     g_hash_table_insert(s->gsimap, irq, GINT_TO_POINTER(gsi));
1471 }
1472
1473 static void kvm_irqchip_create(MachineState *machine, KVMState *s)
1474 {
1475     int ret;
1476
1477     if (kvm_check_extension(s, KVM_CAP_IRQCHIP)) {
1478         ;
1479     } else if (kvm_check_extension(s, KVM_CAP_S390_IRQCHIP)) {
1480         ret = kvm_vm_enable_cap(s, KVM_CAP_S390_IRQCHIP, 0);
1481         if (ret < 0) {
1482             fprintf(stderr, "Enable kernel irqchip failed: %s\n", strerror(-ret));
1483             exit(1);
1484         }
1485     } else {
1486         return;
1487     }
1488
1489     /* First probe and see if there's a arch-specific hook to create the
1490      * in-kernel irqchip for us */
1491     ret = kvm_arch_irqchip_create(machine, s);
1492     if (ret == 0) {
1493         if (machine_kernel_irqchip_split(machine)) {
1494             perror("Split IRQ chip mode not supported.");
1495             exit(1);
1496         } else {
1497             ret = kvm_vm_ioctl(s, KVM_CREATE_IRQCHIP);
1498         }
1499     }
1500     if (ret < 0) {
1501         fprintf(stderr, "Create kernel irqchip failed: %s\n", strerror(-ret));
1502         exit(1);
1503     }
1504
1505     kvm_kernel_irqchip = true;
1506     /* If we have an in-kernel IRQ chip then we must have asynchronous
1507      * interrupt delivery (though the reverse is not necessarily true)
1508      */
1509     kvm_async_interrupts_allowed = true;
1510     kvm_halt_in_kernel_allowed = true;
1511
1512     kvm_init_irq_routing(s);
1513
1514     s->gsimap = g_hash_table_new(g_direct_hash, g_direct_equal);
1515 }
1516
1517 /* Find number of supported CPUs using the recommended
1518  * procedure from the kernel API documentation to cope with
1519  * older kernels that may be missing capabilities.
1520  */
1521 static int kvm_recommended_vcpus(KVMState *s)
1522 {
1523     int ret = kvm_check_extension(s, KVM_CAP_NR_VCPUS);
1524     return (ret) ? ret : 4;
1525 }
1526
1527 static int kvm_max_vcpus(KVMState *s)
1528 {
1529     int ret = kvm_check_extension(s, KVM_CAP_MAX_VCPUS);
1530     return (ret) ? ret : kvm_recommended_vcpus(s);
1531 }
1532
1533 static int kvm_max_vcpu_id(KVMState *s)
1534 {
1535     int ret = kvm_check_extension(s, KVM_CAP_MAX_VCPU_ID);
1536     return (ret) ? ret : kvm_max_vcpus(s);
1537 }
1538
1539 bool kvm_vcpu_id_is_valid(int vcpu_id)
1540 {
1541     KVMState *s = KVM_STATE(current_machine->accelerator);
1542     return vcpu_id >= 0 && vcpu_id < kvm_max_vcpu_id(s);
1543 }
1544
1545 static int kvm_init(MachineState *ms)
1546 {
1547     MachineClass *mc = MACHINE_GET_CLASS(ms);
1548     static const char upgrade_note[] =
1549         "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
1550         "(see http://sourceforge.net/projects/kvm).\n";
1551     struct {
1552         const char *name;
1553         int num;
1554     } num_cpus[] = {
1555         { "SMP",          smp_cpus },
1556         { "hotpluggable", max_cpus },
1557         { NULL, }
1558     }, *nc = num_cpus;
1559     int soft_vcpus_limit, hard_vcpus_limit;
1560     KVMState *s;
1561     const KVMCapabilityInfo *missing_cap;
1562     int ret;
1563     int type = 0;
1564     const char *kvm_type;
1565
1566     s = KVM_STATE(ms->accelerator);
1567
1568     /*
1569      * On systems where the kernel can support different base page
1570      * sizes, host page size may be different from TARGET_PAGE_SIZE,
1571      * even with KVM.  TARGET_PAGE_SIZE is assumed to be the minimum
1572      * page size for the system though.
1573      */
1574     assert(TARGET_PAGE_SIZE <= getpagesize());
1575
1576     s->sigmask_len = 8;
1577
1578 #ifdef KVM_CAP_SET_GUEST_DEBUG
1579     QTAILQ_INIT(&s->kvm_sw_breakpoints);
1580 #endif
1581     QLIST_INIT(&s->kvm_parked_vcpus);
1582     s->vmfd = -1;
1583     s->fd = qemu_open("/dev/kvm", O_RDWR);
1584     if (s->fd == -1) {
1585         fprintf(stderr, "Could not access KVM kernel module: %m\n");
1586         ret = -errno;
1587         goto err;
1588     }
1589
1590     ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
1591     if (ret < KVM_API_VERSION) {
1592         if (ret >= 0) {
1593             ret = -EINVAL;
1594         }
1595         fprintf(stderr, "kvm version too old\n");
1596         goto err;
1597     }
1598
1599     if (ret > KVM_API_VERSION) {
1600         ret = -EINVAL;
1601         fprintf(stderr, "kvm version not supported\n");
1602         goto err;
1603     }
1604
1605     s->nr_slots = kvm_check_extension(s, KVM_CAP_NR_MEMSLOTS);
1606
1607     /* If unspecified, use the default value */
1608     if (!s->nr_slots) {
1609         s->nr_slots = 32;
1610     }
1611
1612     /* check the vcpu limits */
1613     soft_vcpus_limit = kvm_recommended_vcpus(s);
1614     hard_vcpus_limit = kvm_max_vcpus(s);
1615
1616     while (nc->name) {
1617         if (nc->num > soft_vcpus_limit) {
1618             fprintf(stderr,
1619                     "Warning: Number of %s cpus requested (%d) exceeds "
1620                     "the recommended cpus supported by KVM (%d)\n",
1621                     nc->name, nc->num, soft_vcpus_limit);
1622
1623             if (nc->num > hard_vcpus_limit) {
1624                 fprintf(stderr, "Number of %s cpus requested (%d) exceeds "
1625                         "the maximum cpus supported by KVM (%d)\n",
1626                         nc->name, nc->num, hard_vcpus_limit);
1627                 exit(1);
1628             }
1629         }
1630         nc++;
1631     }
1632
1633     kvm_type = qemu_opt_get(qemu_get_machine_opts(), "kvm-type");
1634     if (mc->kvm_type) {
1635         type = mc->kvm_type(kvm_type);
1636     } else if (kvm_type) {
1637         ret = -EINVAL;
1638         fprintf(stderr, "Invalid argument kvm-type=%s\n", kvm_type);
1639         goto err;
1640     }
1641
1642     do {
1643         ret = kvm_ioctl(s, KVM_CREATE_VM, type);
1644     } while (ret == -EINTR);
1645
1646     if (ret < 0) {
1647         fprintf(stderr, "ioctl(KVM_CREATE_VM) failed: %d %s\n", -ret,
1648                 strerror(-ret));
1649
1650 #ifdef TARGET_S390X
1651         if (ret == -EINVAL) {
1652             fprintf(stderr,
1653                     "Host kernel setup problem detected. Please verify:\n");
1654             fprintf(stderr, "- for kernels supporting the switch_amode or"
1655                     " user_mode parameters, whether\n");
1656             fprintf(stderr,
1657                     "  user space is running in primary address space\n");
1658             fprintf(stderr,
1659                     "- for kernels supporting the vm.allocate_pgste sysctl, "
1660                     "whether it is enabled\n");
1661         }
1662 #endif
1663         goto err;
1664     }
1665
1666     s->vmfd = ret;
1667     missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
1668     if (!missing_cap) {
1669         missing_cap =
1670             kvm_check_extension_list(s, kvm_arch_required_capabilities);
1671     }
1672     if (missing_cap) {
1673         ret = -EINVAL;
1674         fprintf(stderr, "kvm does not support %s\n%s",
1675                 missing_cap->name, upgrade_note);
1676         goto err;
1677     }
1678
1679     s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
1680
1681     s->broken_set_mem_region = 1;
1682     ret = kvm_check_extension(s, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
1683     if (ret > 0) {
1684         s->broken_set_mem_region = 0;
1685     }
1686
1687 #ifdef KVM_CAP_VCPU_EVENTS
1688     s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
1689 #endif
1690
1691     s->robust_singlestep =
1692         kvm_check_extension(s, KVM_CAP_X86_ROBUST_SINGLESTEP);
1693
1694 #ifdef KVM_CAP_DEBUGREGS
1695     s->debugregs = kvm_check_extension(s, KVM_CAP_DEBUGREGS);
1696 #endif
1697
1698 #ifdef KVM_CAP_IRQ_ROUTING
1699     kvm_direct_msi_allowed = (kvm_check_extension(s, KVM_CAP_SIGNAL_MSI) > 0);
1700 #endif
1701
1702     s->intx_set_mask = kvm_check_extension(s, KVM_CAP_PCI_2_3);
1703
1704     s->irq_set_ioctl = KVM_IRQ_LINE;
1705     if (kvm_check_extension(s, KVM_CAP_IRQ_INJECT_STATUS)) {
1706         s->irq_set_ioctl = KVM_IRQ_LINE_STATUS;
1707     }
1708
1709 #ifdef KVM_CAP_READONLY_MEM
1710     kvm_readonly_mem_allowed =
1711         (kvm_check_extension(s, KVM_CAP_READONLY_MEM) > 0);
1712 #endif
1713
1714     kvm_eventfds_allowed =
1715         (kvm_check_extension(s, KVM_CAP_IOEVENTFD) > 0);
1716
1717     kvm_irqfds_allowed =
1718         (kvm_check_extension(s, KVM_CAP_IRQFD) > 0);
1719
1720     kvm_resamplefds_allowed =
1721         (kvm_check_extension(s, KVM_CAP_IRQFD_RESAMPLE) > 0);
1722
1723     kvm_vm_attributes_allowed =
1724         (kvm_check_extension(s, KVM_CAP_VM_ATTRIBUTES) > 0);
1725
1726     kvm_ioeventfd_any_length_allowed =
1727         (kvm_check_extension(s, KVM_CAP_IOEVENTFD_ANY_LENGTH) > 0);
1728
1729     ret = kvm_arch_init(ms, s);
1730     if (ret < 0) {
1731         goto err;
1732     }
1733
1734     if (machine_kernel_irqchip_allowed(ms)) {
1735         kvm_irqchip_create(ms, s);
1736     }
1737
1738     kvm_state = s;
1739
1740     if (kvm_eventfds_allowed) {
1741         s->memory_listener.listener.eventfd_add = kvm_mem_ioeventfd_add;
1742         s->memory_listener.listener.eventfd_del = kvm_mem_ioeventfd_del;
1743     }
1744     s->memory_listener.listener.coalesced_mmio_add = kvm_coalesce_mmio_region;
1745     s->memory_listener.listener.coalesced_mmio_del = kvm_uncoalesce_mmio_region;
1746
1747     kvm_memory_listener_register(s, &s->memory_listener,
1748                                  &address_space_memory, 0);
1749     memory_listener_register(&kvm_io_listener,
1750                              &address_space_io);
1751
1752     s->many_ioeventfds = kvm_check_many_ioeventfds();
1753
1754     cpu_interrupt_handler = kvm_handle_interrupt;
1755
1756     return 0;
1757
1758 err:
1759     assert(ret < 0);
1760     if (s->vmfd >= 0) {
1761         close(s->vmfd);
1762     }
1763     if (s->fd != -1) {
1764         close(s->fd);
1765     }
1766     g_free(s->memory_listener.slots);
1767
1768     return ret;
1769 }
1770
1771 void kvm_set_sigmask_len(KVMState *s, unsigned int sigmask_len)
1772 {
1773     s->sigmask_len = sigmask_len;
1774 }
1775
1776 static void kvm_handle_io(uint16_t port, MemTxAttrs attrs, void *data, int direction,
1777                           int size, uint32_t count)
1778 {
1779     int i;
1780     uint8_t *ptr = data;
1781
1782     for (i = 0; i < count; i++) {
1783         address_space_rw(&address_space_io, port, attrs,
1784                          ptr, size,
1785                          direction == KVM_EXIT_IO_OUT);
1786         ptr += size;
1787     }
1788 }
1789
1790 static int kvm_handle_internal_error(CPUState *cpu, struct kvm_run *run)
1791 {
1792     fprintf(stderr, "KVM internal error. Suberror: %d\n",
1793             run->internal.suberror);
1794
1795     if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) {
1796         int i;
1797
1798         for (i = 0; i < run->internal.ndata; ++i) {
1799             fprintf(stderr, "extra data[%d]: %"PRIx64"\n",
1800                     i, (uint64_t)run->internal.data[i]);
1801         }
1802     }
1803     if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {
1804         fprintf(stderr, "emulation failure\n");
1805         if (!kvm_arch_stop_on_emulation_error(cpu)) {
1806             cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);
1807             return EXCP_INTERRUPT;
1808         }
1809     }
1810     /* FIXME: Should trigger a qmp message to let management know
1811      * something went wrong.
1812      */
1813     return -1;
1814 }
1815
1816 void kvm_flush_coalesced_mmio_buffer(void)
1817 {
1818     KVMState *s = kvm_state;
1819
1820     if (s->coalesced_flush_in_progress) {
1821         return;
1822     }
1823
1824     s->coalesced_flush_in_progress = true;
1825
1826     if (s->coalesced_mmio_ring) {
1827         struct kvm_coalesced_mmio_ring *ring = s->coalesced_mmio_ring;
1828         while (ring->first != ring->last) {
1829             struct kvm_coalesced_mmio *ent;
1830
1831             ent = &ring->coalesced_mmio[ring->first];
1832
1833             cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
1834             smp_wmb();
1835             ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
1836         }
1837     }
1838
1839     s->coalesced_flush_in_progress = false;
1840 }
1841
1842 static void do_kvm_cpu_synchronize_state(void *arg)
1843 {
1844     CPUState *cpu = arg;
1845
1846     if (!cpu->kvm_vcpu_dirty) {
1847         kvm_arch_get_registers(cpu);
1848         cpu->kvm_vcpu_dirty = true;
1849     }
1850 }
1851
1852 void kvm_cpu_synchronize_state(CPUState *cpu)
1853 {
1854     if (!cpu->kvm_vcpu_dirty) {
1855         run_on_cpu(cpu, do_kvm_cpu_synchronize_state, cpu);
1856     }
1857 }
1858
1859 static void do_kvm_cpu_synchronize_post_reset(void *arg)
1860 {
1861     CPUState *cpu = arg;
1862
1863     kvm_arch_put_registers(cpu, KVM_PUT_RESET_STATE);
1864     cpu->kvm_vcpu_dirty = false;
1865 }
1866
1867 void kvm_cpu_synchronize_post_reset(CPUState *cpu)
1868 {
1869     run_on_cpu(cpu, do_kvm_cpu_synchronize_post_reset, cpu);
1870 }
1871
1872 static void do_kvm_cpu_synchronize_post_init(void *arg)
1873 {
1874     CPUState *cpu = arg;
1875
1876     kvm_arch_put_registers(cpu, KVM_PUT_FULL_STATE);
1877     cpu->kvm_vcpu_dirty = false;
1878 }
1879
1880 void kvm_cpu_synchronize_post_init(CPUState *cpu)
1881 {
1882     run_on_cpu(cpu, do_kvm_cpu_synchronize_post_init, cpu);
1883 }
1884
1885 int kvm_cpu_exec(CPUState *cpu)
1886 {
1887     struct kvm_run *run = cpu->kvm_run;
1888     int ret, run_ret;
1889
1890     DPRINTF("kvm_cpu_exec()\n");
1891
1892     if (kvm_arch_process_async_events(cpu)) {
1893         cpu->exit_request = 0;
1894         return EXCP_HLT;
1895     }
1896
1897     qemu_mutex_unlock_iothread();
1898
1899     do {
1900         MemTxAttrs attrs;
1901
1902         if (cpu->kvm_vcpu_dirty) {
1903             kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE);
1904             cpu->kvm_vcpu_dirty = false;
1905         }
1906
1907         kvm_arch_pre_run(cpu, run);
1908         if (cpu->exit_request) {
1909             DPRINTF("interrupt exit requested\n");
1910             /*
1911              * KVM requires us to reenter the kernel after IO exits to complete
1912              * instruction emulation. This self-signal will ensure that we
1913              * leave ASAP again.
1914              */
1915             qemu_cpu_kick_self();
1916         }
1917
1918         run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
1919
1920         attrs = kvm_arch_post_run(cpu, run);
1921
1922         if (run_ret < 0) {
1923             if (run_ret == -EINTR || run_ret == -EAGAIN) {
1924                 DPRINTF("io window exit\n");
1925                 ret = EXCP_INTERRUPT;
1926                 break;
1927             }
1928             fprintf(stderr, "error: kvm run failed %s\n",
1929                     strerror(-run_ret));
1930 #ifdef TARGET_PPC
1931             if (run_ret == -EBUSY) {
1932                 fprintf(stderr,
1933                         "This is probably because your SMT is enabled.\n"
1934                         "VCPU can only run on primary threads with all "
1935                         "secondary threads offline.\n");
1936             }
1937 #endif
1938             ret = -1;
1939             break;
1940         }
1941
1942         trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);
1943         switch (run->exit_reason) {
1944         case KVM_EXIT_IO:
1945             DPRINTF("handle_io\n");
1946             /* Called outside BQL */
1947             kvm_handle_io(run->io.port, attrs,
1948                           (uint8_t *)run + run->io.data_offset,
1949                           run->io.direction,
1950                           run->io.size,
1951                           run->io.count);
1952             ret = 0;
1953             break;
1954         case KVM_EXIT_MMIO:
1955             DPRINTF("handle_mmio\n");
1956             /* Called outside BQL */
1957             address_space_rw(&address_space_memory,
1958                              run->mmio.phys_addr, attrs,
1959                              run->mmio.data,
1960                              run->mmio.len,
1961                              run->mmio.is_write);
1962             ret = 0;
1963             break;
1964         case KVM_EXIT_IRQ_WINDOW_OPEN:
1965             DPRINTF("irq_window_open\n");
1966             ret = EXCP_INTERRUPT;
1967             break;
1968         case KVM_EXIT_SHUTDOWN:
1969             DPRINTF("shutdown\n");
1970             qemu_system_reset_request();
1971             ret = EXCP_INTERRUPT;
1972             break;
1973         case KVM_EXIT_UNKNOWN:
1974             fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
1975                     (uint64_t)run->hw.hardware_exit_reason);
1976             ret = -1;
1977             break;
1978         case KVM_EXIT_INTERNAL_ERROR:
1979             ret = kvm_handle_internal_error(cpu, run);
1980             break;
1981         case KVM_EXIT_SYSTEM_EVENT:
1982             switch (run->system_event.type) {
1983             case KVM_SYSTEM_EVENT_SHUTDOWN:
1984                 qemu_system_shutdown_request();
1985                 ret = EXCP_INTERRUPT;
1986                 break;
1987             case KVM_SYSTEM_EVENT_RESET:
1988                 qemu_system_reset_request();
1989                 ret = EXCP_INTERRUPT;
1990                 break;
1991             case KVM_SYSTEM_EVENT_CRASH:
1992                 qemu_mutex_lock_iothread();
1993                 qemu_system_guest_panicked();
1994                 qemu_mutex_unlock_iothread();
1995                 ret = 0;
1996                 break;
1997             default:
1998                 DPRINTF("kvm_arch_handle_exit\n");
1999                 ret = kvm_arch_handle_exit(cpu, run);
2000                 break;
2001             }
2002             break;
2003         default:
2004             DPRINTF("kvm_arch_handle_exit\n");
2005             ret = kvm_arch_handle_exit(cpu, run);
2006             break;
2007         }
2008     } while (ret == 0);
2009
2010     qemu_mutex_lock_iothread();
2011
2012     if (ret < 0) {
2013         cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);
2014         vm_stop(RUN_STATE_INTERNAL_ERROR);
2015     }
2016
2017     cpu->exit_request = 0;
2018     return ret;
2019 }
2020
2021 int kvm_ioctl(KVMState *s, int type, ...)
2022 {
2023     int ret;
2024     void *arg;
2025     va_list ap;
2026
2027     va_start(ap, type);
2028     arg = va_arg(ap, void *);
2029     va_end(ap);
2030
2031     trace_kvm_ioctl(type, arg);
2032     ret = ioctl(s->fd, type, arg);
2033     if (ret == -1) {
2034         ret = -errno;
2035     }
2036     return ret;
2037 }
2038
2039 int kvm_vm_ioctl(KVMState *s, int type, ...)
2040 {
2041     int ret;
2042     void *arg;
2043     va_list ap;
2044
2045     va_start(ap, type);
2046     arg = va_arg(ap, void *);
2047     va_end(ap);
2048
2049     trace_kvm_vm_ioctl(type, arg);
2050     ret = ioctl(s->vmfd, type, arg);
2051     if (ret == -1) {
2052         ret = -errno;
2053     }
2054     return ret;
2055 }
2056
2057 int kvm_vcpu_ioctl(CPUState *cpu, int type, ...)
2058 {
2059     int ret;
2060     void *arg;
2061     va_list ap;
2062
2063     va_start(ap, type);
2064     arg = va_arg(ap, void *);
2065     va_end(ap);
2066
2067     trace_kvm_vcpu_ioctl(cpu->cpu_index, type, arg);
2068     ret = ioctl(cpu->kvm_fd, type, arg);
2069     if (ret == -1) {
2070         ret = -errno;
2071     }
2072     return ret;
2073 }
2074
2075 int kvm_device_ioctl(int fd, int type, ...)
2076 {
2077     int ret;
2078     void *arg;
2079     va_list ap;
2080
2081     va_start(ap, type);
2082     arg = va_arg(ap, void *);
2083     va_end(ap);
2084
2085     trace_kvm_device_ioctl(fd, type, arg);
2086     ret = ioctl(fd, type, arg);
2087     if (ret == -1) {
2088         ret = -errno;
2089     }
2090     return ret;
2091 }
2092
2093 int kvm_vm_check_attr(KVMState *s, uint32_t group, uint64_t attr)
2094 {
2095     int ret;
2096     struct kvm_device_attr attribute = {
2097         .group = group,
2098         .attr = attr,
2099     };
2100
2101     if (!kvm_vm_attributes_allowed) {
2102         return 0;
2103     }
2104
2105     ret = kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attribute);
2106     /* kvm returns 0 on success for HAS_DEVICE_ATTR */
2107     return ret ? 0 : 1;
2108 }
2109
2110 int kvm_device_check_attr(int dev_fd, uint32_t group, uint64_t attr)
2111 {
2112     struct kvm_device_attr attribute = {
2113         .group = group,
2114         .attr = attr,
2115         .flags = 0,
2116     };
2117
2118     return kvm_device_ioctl(dev_fd, KVM_HAS_DEVICE_ATTR, &attribute) ? 0 : 1;
2119 }
2120
2121 void kvm_device_access(int fd, int group, uint64_t attr,
2122                        void *val, bool write)
2123 {
2124     struct kvm_device_attr kvmattr;
2125     int err;
2126
2127     kvmattr.flags = 0;
2128     kvmattr.group = group;
2129     kvmattr.attr = attr;
2130     kvmattr.addr = (uintptr_t)val;
2131
2132     err = kvm_device_ioctl(fd,
2133                            write ? KVM_SET_DEVICE_ATTR : KVM_GET_DEVICE_ATTR,
2134                            &kvmattr);
2135     if (err < 0) {
2136         error_report("KVM_%s_DEVICE_ATTR failed: %s",
2137                      write ? "SET" : "GET", strerror(-err));
2138         error_printf("Group %d attr 0x%016" PRIx64, group, attr);
2139         abort();
2140     }
2141 }
2142
2143 int kvm_has_sync_mmu(void)
2144 {
2145     return kvm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);
2146 }
2147
2148 int kvm_has_vcpu_events(void)
2149 {
2150     return kvm_state->vcpu_events;
2151 }
2152
2153 int kvm_has_robust_singlestep(void)
2154 {
2155     return kvm_state->robust_singlestep;
2156 }
2157
2158 int kvm_has_debugregs(void)
2159 {
2160     return kvm_state->debugregs;
2161 }
2162
2163 int kvm_has_many_ioeventfds(void)
2164 {
2165     if (!kvm_enabled()) {
2166         return 0;
2167     }
2168     return kvm_state->many_ioeventfds;
2169 }
2170
2171 int kvm_has_gsi_routing(void)
2172 {
2173 #ifdef KVM_CAP_IRQ_ROUTING
2174     return kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING);
2175 #else
2176     return false;
2177 #endif
2178 }
2179
2180 int kvm_has_intx_set_mask(void)
2181 {
2182     return kvm_state->intx_set_mask;
2183 }
2184
2185 void kvm_setup_guest_memory(void *start, size_t size)
2186 {
2187     if (!kvm_has_sync_mmu()) {
2188         int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK);
2189
2190         if (ret) {
2191             perror("qemu_madvise");
2192             fprintf(stderr,
2193                     "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
2194             exit(1);
2195         }
2196     }
2197 }
2198
2199 #ifdef KVM_CAP_SET_GUEST_DEBUG
2200 struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *cpu,
2201                                                  target_ulong pc)
2202 {
2203     struct kvm_sw_breakpoint *bp;
2204
2205     QTAILQ_FOREACH(bp, &cpu->kvm_state->kvm_sw_breakpoints, entry) {
2206         if (bp->pc == pc) {
2207             return bp;
2208         }
2209     }
2210     return NULL;
2211 }
2212
2213 int kvm_sw_breakpoints_active(CPUState *cpu)
2214 {
2215     return !QTAILQ_EMPTY(&cpu->kvm_state->kvm_sw_breakpoints);
2216 }
2217
2218 struct kvm_set_guest_debug_data {
2219     struct kvm_guest_debug dbg;
2220     CPUState *cpu;
2221     int err;
2222 };
2223
2224 static void kvm_invoke_set_guest_debug(void *data)
2225 {
2226     struct kvm_set_guest_debug_data *dbg_data = data;
2227
2228     dbg_data->err = kvm_vcpu_ioctl(dbg_data->cpu, KVM_SET_GUEST_DEBUG,
2229                                    &dbg_data->dbg);
2230 }
2231
2232 int kvm_update_guest_debug(CPUState *cpu, unsigned long reinject_trap)
2233 {
2234     struct kvm_set_guest_debug_data data;
2235
2236     data.dbg.control = reinject_trap;
2237
2238     if (cpu->singlestep_enabled) {
2239         data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
2240     }
2241     kvm_arch_update_guest_debug(cpu, &data.dbg);
2242     data.cpu = cpu;
2243
2244     run_on_cpu(cpu, kvm_invoke_set_guest_debug, &data);
2245     return data.err;
2246 }
2247
2248 int kvm_insert_breakpoint(CPUState *cpu, target_ulong addr,
2249                           target_ulong len, int type)
2250 {
2251     struct kvm_sw_breakpoint *bp;
2252     int err;
2253
2254     if (type == GDB_BREAKPOINT_SW) {
2255         bp = kvm_find_sw_breakpoint(cpu, addr);
2256         if (bp) {
2257             bp->use_count++;
2258             return 0;
2259         }
2260
2261         bp = g_malloc(sizeof(struct kvm_sw_breakpoint));
2262         bp->pc = addr;
2263         bp->use_count = 1;
2264         err = kvm_arch_insert_sw_breakpoint(cpu, bp);
2265         if (err) {
2266             g_free(bp);
2267             return err;
2268         }
2269
2270         QTAILQ_INSERT_HEAD(&cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
2271     } else {
2272         err = kvm_arch_insert_hw_breakpoint(addr, len, type);
2273         if (err) {
2274             return err;
2275         }
2276     }
2277
2278     CPU_FOREACH(cpu) {
2279         err = kvm_update_guest_debug(cpu, 0);
2280         if (err) {
2281             return err;
2282         }
2283     }
2284     return 0;
2285 }
2286
2287 int kvm_remove_breakpoint(CPUState *cpu, target_ulong addr,
2288                           target_ulong len, int type)
2289 {
2290     struct kvm_sw_breakpoint *bp;
2291     int err;
2292
2293     if (type == GDB_BREAKPOINT_SW) {
2294         bp = kvm_find_sw_breakpoint(cpu, addr);
2295         if (!bp) {
2296             return -ENOENT;
2297         }
2298
2299         if (bp->use_count > 1) {
2300             bp->use_count--;
2301             return 0;
2302         }
2303
2304         err = kvm_arch_remove_sw_breakpoint(cpu, bp);
2305         if (err) {
2306             return err;
2307         }
2308
2309         QTAILQ_REMOVE(&cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
2310         g_free(bp);
2311     } else {
2312         err = kvm_arch_remove_hw_breakpoint(addr, len, type);
2313         if (err) {
2314             return err;
2315         }
2316     }
2317
2318     CPU_FOREACH(cpu) {
2319         err = kvm_update_guest_debug(cpu, 0);
2320         if (err) {
2321             return err;
2322         }
2323     }
2324     return 0;
2325 }
2326
2327 void kvm_remove_all_breakpoints(CPUState *cpu)
2328 {
2329     struct kvm_sw_breakpoint *bp, *next;
2330     KVMState *s = cpu->kvm_state;
2331     CPUState *tmpcpu;
2332
2333     QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
2334         if (kvm_arch_remove_sw_breakpoint(cpu, bp) != 0) {
2335             /* Try harder to find a CPU that currently sees the breakpoint. */
2336             CPU_FOREACH(tmpcpu) {
2337                 if (kvm_arch_remove_sw_breakpoint(tmpcpu, bp) == 0) {
2338                     break;
2339                 }
2340             }
2341         }
2342         QTAILQ_REMOVE(&s->kvm_sw_breakpoints, bp, entry);
2343         g_free(bp);
2344     }
2345     kvm_arch_remove_all_hw_breakpoints();
2346
2347     CPU_FOREACH(cpu) {
2348         kvm_update_guest_debug(cpu, 0);
2349     }
2350 }
2351
2352 #else /* !KVM_CAP_SET_GUEST_DEBUG */
2353
2354 int kvm_update_guest_debug(CPUState *cpu, unsigned long reinject_trap)
2355 {
2356     return -EINVAL;
2357 }
2358
2359 int kvm_insert_breakpoint(CPUState *cpu, target_ulong addr,
2360                           target_ulong len, int type)
2361 {
2362     return -EINVAL;
2363 }
2364
2365 int kvm_remove_breakpoint(CPUState *cpu, target_ulong addr,
2366                           target_ulong len, int type)
2367 {
2368     return -EINVAL;
2369 }
2370
2371 void kvm_remove_all_breakpoints(CPUState *cpu)
2372 {
2373 }
2374 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
2375
2376 int kvm_set_signal_mask(CPUState *cpu, const sigset_t *sigset)
2377 {
2378     KVMState *s = kvm_state;
2379     struct kvm_signal_mask *sigmask;
2380     int r;
2381
2382     if (!sigset) {
2383         return kvm_vcpu_ioctl(cpu, KVM_SET_SIGNAL_MASK, NULL);
2384     }
2385
2386     sigmask = g_malloc(sizeof(*sigmask) + sizeof(*sigset));
2387
2388     sigmask->len = s->sigmask_len;
2389     memcpy(sigmask->sigset, sigset, sizeof(*sigset));
2390     r = kvm_vcpu_ioctl(cpu, KVM_SET_SIGNAL_MASK, sigmask);
2391     g_free(sigmask);
2392
2393     return r;
2394 }
2395 int kvm_on_sigbus_vcpu(CPUState *cpu, int code, void *addr)
2396 {
2397     return kvm_arch_on_sigbus_vcpu(cpu, code, addr);
2398 }
2399
2400 int kvm_on_sigbus(int code, void *addr)
2401 {
2402     return kvm_arch_on_sigbus(code, addr);
2403 }
2404
2405 int kvm_create_device(KVMState *s, uint64_t type, bool test)
2406 {
2407     int ret;
2408     struct kvm_create_device create_dev;
2409
2410     create_dev.type = type;
2411     create_dev.fd = -1;
2412     create_dev.flags = test ? KVM_CREATE_DEVICE_TEST : 0;
2413
2414     if (!kvm_check_extension(s, KVM_CAP_DEVICE_CTRL)) {
2415         return -ENOTSUP;
2416     }
2417
2418     ret = kvm_vm_ioctl(s, KVM_CREATE_DEVICE, &create_dev);
2419     if (ret) {
2420         return ret;
2421     }
2422
2423     return test ? 0 : create_dev.fd;
2424 }
2425
2426 bool kvm_device_supported(int vmfd, uint64_t type)
2427 {
2428     struct kvm_create_device create_dev = {
2429         .type = type,
2430         .fd = -1,
2431         .flags = KVM_CREATE_DEVICE_TEST,
2432     };
2433
2434     if (ioctl(vmfd, KVM_CHECK_EXTENSION, KVM_CAP_DEVICE_CTRL) <= 0) {
2435         return false;
2436     }
2437
2438     return (ioctl(vmfd, KVM_CREATE_DEVICE, &create_dev) >= 0);
2439 }
2440
2441 int kvm_set_one_reg(CPUState *cs, uint64_t id, void *source)
2442 {
2443     struct kvm_one_reg reg;
2444     int r;
2445
2446     reg.id = id;
2447     reg.addr = (uintptr_t) source;
2448     r = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
2449     if (r) {
2450         trace_kvm_failed_reg_set(id, strerror(-r));
2451     }
2452     return r;
2453 }
2454
2455 int kvm_get_one_reg(CPUState *cs, uint64_t id, void *target)
2456 {
2457     struct kvm_one_reg reg;
2458     int r;
2459
2460     reg.id = id;
2461     reg.addr = (uintptr_t) target;
2462     r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
2463     if (r) {
2464         trace_kvm_failed_reg_get(id, strerror(-r));
2465     }
2466     return r;
2467 }
2468
2469 static void kvm_accel_class_init(ObjectClass *oc, void *data)
2470 {
2471     AccelClass *ac = ACCEL_CLASS(oc);
2472     ac->name = "KVM";
2473     ac->init_machine = kvm_init;
2474     ac->allowed = &kvm_allowed;
2475 }
2476
2477 static const TypeInfo kvm_accel_type = {
2478     .name = TYPE_KVM_ACCEL,
2479     .parent = TYPE_ACCEL,
2480     .class_init = kvm_accel_class_init,
2481     .instance_size = sizeof(KVMState),
2482 };
2483
2484 static void kvm_type_init(void)
2485 {
2486     type_register_static(&kvm_accel_type);
2487 }
2488
2489 type_init(kvm_type_init);