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
  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     if (kvm_gsi_direct_mapping()) {
1051         return;
1052     }
1053
1054     if (!kvm_gsi_routing_enabled()) {
1055         return;
1056     }
1057
1058     s->irq_routes->flags = 0;
1059     trace_kvm_irqchip_commit_routes();
1060     ret = kvm_vm_ioctl(s, KVM_SET_GSI_ROUTING, s->irq_routes);
1061     assert(ret == 0);
1062 }
1063
1064 static void kvm_add_routing_entry(KVMState *s,
1065                                   struct kvm_irq_routing_entry *entry)
1066 {
1067     struct kvm_irq_routing_entry *new;
1068     int n, size;
1069
1070     if (s->irq_routes->nr == s->nr_allocated_irq_routes) {
1071         n = s->nr_allocated_irq_routes * 2;
1072         if (n < 64) {
1073             n = 64;
1074         }
1075         size = sizeof(struct kvm_irq_routing);
1076         size += n * sizeof(*new);
1077         s->irq_routes = g_realloc(s->irq_routes, size);
1078         s->nr_allocated_irq_routes = n;
1079     }
1080     n = s->irq_routes->nr++;
1081     new = &s->irq_routes->entries[n];
1082
1083     *new = *entry;
1084
1085     set_gsi(s, entry->gsi);
1086 }
1087
1088 static int kvm_update_routing_entry(KVMState *s,
1089                                     struct kvm_irq_routing_entry *new_entry)
1090 {
1091     struct kvm_irq_routing_entry *entry;
1092     int n;
1093
1094     for (n = 0; n < s->irq_routes->nr; n++) {
1095         entry = &s->irq_routes->entries[n];
1096         if (entry->gsi != new_entry->gsi) {
1097             continue;
1098         }
1099
1100         if(!memcmp(entry, new_entry, sizeof *entry)) {
1101             return 0;
1102         }
1103
1104         *entry = *new_entry;
1105
1106         return 0;
1107     }
1108
1109     return -ESRCH;
1110 }
1111
1112 void kvm_irqchip_add_irq_route(KVMState *s, int irq, int irqchip, int pin)
1113 {
1114     struct kvm_irq_routing_entry e = {};
1115
1116     assert(pin < s->gsi_count);
1117
1118     e.gsi = irq;
1119     e.type = KVM_IRQ_ROUTING_IRQCHIP;
1120     e.flags = 0;
1121     e.u.irqchip.irqchip = irqchip;
1122     e.u.irqchip.pin = pin;
1123     kvm_add_routing_entry(s, &e);
1124 }
1125
1126 void kvm_irqchip_release_virq(KVMState *s, int virq)
1127 {
1128     struct kvm_irq_routing_entry *e;
1129     int i;
1130
1131     if (kvm_gsi_direct_mapping()) {
1132         return;
1133     }
1134
1135     for (i = 0; i < s->irq_routes->nr; i++) {
1136         e = &s->irq_routes->entries[i];
1137         if (e->gsi == virq) {
1138             s->irq_routes->nr--;
1139             *e = s->irq_routes->entries[s->irq_routes->nr];
1140         }
1141     }
1142     clear_gsi(s, virq);
1143     kvm_arch_release_virq_post(virq);
1144 }
1145
1146 static unsigned int kvm_hash_msi(uint32_t data)
1147 {
1148     /* This is optimized for IA32 MSI layout. However, no other arch shall
1149      * repeat the mistake of not providing a direct MSI injection API. */
1150     return data & 0xff;
1151 }
1152
1153 static void kvm_flush_dynamic_msi_routes(KVMState *s)
1154 {
1155     KVMMSIRoute *route, *next;
1156     unsigned int hash;
1157
1158     for (hash = 0; hash < KVM_MSI_HASHTAB_SIZE; hash++) {
1159         QTAILQ_FOREACH_SAFE(route, &s->msi_hashtab[hash], entry, next) {
1160             kvm_irqchip_release_virq(s, route->kroute.gsi);
1161             QTAILQ_REMOVE(&s->msi_hashtab[hash], route, entry);
1162             g_free(route);
1163         }
1164     }
1165 }
1166
1167 static int kvm_irqchip_get_virq(KVMState *s)
1168 {
1169     int next_virq;
1170
1171     /*
1172      * PIC and IOAPIC share the first 16 GSI numbers, thus the available
1173      * GSI numbers are more than the number of IRQ route. Allocating a GSI
1174      * number can succeed even though a new route entry cannot be added.
1175      * When this happens, flush dynamic MSI entries to free IRQ route entries.
1176      */
1177     if (!kvm_direct_msi_allowed && s->irq_routes->nr == s->gsi_count) {
1178         kvm_flush_dynamic_msi_routes(s);
1179     }
1180
1181     /* Return the lowest unused GSI in the bitmap */
1182     next_virq = find_first_zero_bit(s->used_gsi_bitmap, s->gsi_count);
1183     if (next_virq >= s->gsi_count) {
1184         return -ENOSPC;
1185     } else {
1186         return next_virq;
1187     }
1188 }
1189
1190 static KVMMSIRoute *kvm_lookup_msi_route(KVMState *s, MSIMessage msg)
1191 {
1192     unsigned int hash = kvm_hash_msi(msg.data);
1193     KVMMSIRoute *route;
1194
1195     QTAILQ_FOREACH(route, &s->msi_hashtab[hash], entry) {
1196         if (route->kroute.u.msi.address_lo == (uint32_t)msg.address &&
1197             route->kroute.u.msi.address_hi == (msg.address >> 32) &&
1198             route->kroute.u.msi.data == le32_to_cpu(msg.data)) {
1199             return route;
1200         }
1201     }
1202     return NULL;
1203 }
1204
1205 int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg)
1206 {
1207     struct kvm_msi msi;
1208     KVMMSIRoute *route;
1209
1210     if (kvm_direct_msi_allowed) {
1211         msi.address_lo = (uint32_t)msg.address;
1212         msi.address_hi = msg.address >> 32;
1213         msi.data = le32_to_cpu(msg.data);
1214         msi.flags = 0;
1215         memset(msi.pad, 0, sizeof(msi.pad));
1216
1217         return kvm_vm_ioctl(s, KVM_SIGNAL_MSI, &msi);
1218     }
1219
1220     route = kvm_lookup_msi_route(s, msg);
1221     if (!route) {
1222         int virq;
1223
1224         virq = kvm_irqchip_get_virq(s);
1225         if (virq < 0) {
1226             return virq;
1227         }
1228
1229         route = g_malloc0(sizeof(KVMMSIRoute));
1230         route->kroute.gsi = virq;
1231         route->kroute.type = KVM_IRQ_ROUTING_MSI;
1232         route->kroute.flags = 0;
1233         route->kroute.u.msi.address_lo = (uint32_t)msg.address;
1234         route->kroute.u.msi.address_hi = msg.address >> 32;
1235         route->kroute.u.msi.data = le32_to_cpu(msg.data);
1236
1237         kvm_add_routing_entry(s, &route->kroute);
1238         kvm_irqchip_commit_routes(s);
1239
1240         QTAILQ_INSERT_TAIL(&s->msi_hashtab[kvm_hash_msi(msg.data)], route,
1241                            entry);
1242     }
1243
1244     assert(route->kroute.type == KVM_IRQ_ROUTING_MSI);
1245
1246     return kvm_set_irq(s, route->kroute.gsi, 1);
1247 }
1248
1249 int kvm_irqchip_add_msi_route(KVMState *s, int vector, PCIDevice *dev)
1250 {
1251     struct kvm_irq_routing_entry kroute = {};
1252     int virq;
1253     MSIMessage msg = {0, 0};
1254
1255     if (dev) {
1256         msg = pci_get_msi_message(dev, vector);
1257     }
1258
1259     if (kvm_gsi_direct_mapping()) {
1260         return kvm_arch_msi_data_to_gsi(msg.data);
1261     }
1262
1263     if (!kvm_gsi_routing_enabled()) {
1264         return -ENOSYS;
1265     }
1266
1267     virq = kvm_irqchip_get_virq(s);
1268     if (virq < 0) {
1269         return virq;
1270     }
1271
1272     kroute.gsi = virq;
1273     kroute.type = KVM_IRQ_ROUTING_MSI;
1274     kroute.flags = 0;
1275     kroute.u.msi.address_lo = (uint32_t)msg.address;
1276     kroute.u.msi.address_hi = msg.address >> 32;
1277     kroute.u.msi.data = le32_to_cpu(msg.data);
1278     if (kvm_arch_fixup_msi_route(&kroute, msg.address, msg.data, dev)) {
1279         kvm_irqchip_release_virq(s, virq);
1280         return -EINVAL;
1281     }
1282
1283     trace_kvm_irqchip_add_msi_route(virq);
1284
1285     kvm_add_routing_entry(s, &kroute);
1286     kvm_arch_add_msi_route_post(&kroute, vector, dev);
1287     kvm_irqchip_commit_routes(s);
1288
1289     return virq;
1290 }
1291
1292 int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg,
1293                                  PCIDevice *dev)
1294 {
1295     struct kvm_irq_routing_entry kroute = {};
1296
1297     if (kvm_gsi_direct_mapping()) {
1298         return 0;
1299     }
1300
1301     if (!kvm_irqchip_in_kernel()) {
1302         return -ENOSYS;
1303     }
1304
1305     kroute.gsi = virq;
1306     kroute.type = KVM_IRQ_ROUTING_MSI;
1307     kroute.flags = 0;
1308     kroute.u.msi.address_lo = (uint32_t)msg.address;
1309     kroute.u.msi.address_hi = msg.address >> 32;
1310     kroute.u.msi.data = le32_to_cpu(msg.data);
1311     if (kvm_arch_fixup_msi_route(&kroute, msg.address, msg.data, dev)) {
1312         return -EINVAL;
1313     }
1314
1315     trace_kvm_irqchip_update_msi_route(virq);
1316
1317     return kvm_update_routing_entry(s, &kroute);
1318 }
1319
1320 static int kvm_irqchip_assign_irqfd(KVMState *s, int fd, int rfd, int virq,
1321                                     bool assign)
1322 {
1323     struct kvm_irqfd irqfd = {
1324         .fd = fd,
1325         .gsi = virq,
1326         .flags = assign ? 0 : KVM_IRQFD_FLAG_DEASSIGN,
1327     };
1328
1329     if (rfd != -1) {
1330         irqfd.flags |= KVM_IRQFD_FLAG_RESAMPLE;
1331         irqfd.resamplefd = rfd;
1332     }
1333
1334     if (!kvm_irqfds_enabled()) {
1335         return -ENOSYS;
1336     }
1337
1338     return kvm_vm_ioctl(s, KVM_IRQFD, &irqfd);
1339 }
1340
1341 int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter)
1342 {
1343     struct kvm_irq_routing_entry kroute = {};
1344     int virq;
1345
1346     if (!kvm_gsi_routing_enabled()) {
1347         return -ENOSYS;
1348     }
1349
1350     virq = kvm_irqchip_get_virq(s);
1351     if (virq < 0) {
1352         return virq;
1353     }
1354
1355     kroute.gsi = virq;
1356     kroute.type = KVM_IRQ_ROUTING_S390_ADAPTER;
1357     kroute.flags = 0;
1358     kroute.u.adapter.summary_addr = adapter->summary_addr;
1359     kroute.u.adapter.ind_addr = adapter->ind_addr;
1360     kroute.u.adapter.summary_offset = adapter->summary_offset;
1361     kroute.u.adapter.ind_offset = adapter->ind_offset;
1362     kroute.u.adapter.adapter_id = adapter->adapter_id;
1363
1364     kvm_add_routing_entry(s, &kroute);
1365
1366     return virq;
1367 }
1368
1369 int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint)
1370 {
1371     struct kvm_irq_routing_entry kroute = {};
1372     int virq;
1373
1374     if (!kvm_gsi_routing_enabled()) {
1375         return -ENOSYS;
1376     }
1377     if (!kvm_check_extension(s, KVM_CAP_HYPERV_SYNIC)) {
1378         return -ENOSYS;
1379     }
1380     virq = kvm_irqchip_get_virq(s);
1381     if (virq < 0) {
1382         return virq;
1383     }
1384
1385     kroute.gsi = virq;
1386     kroute.type = KVM_IRQ_ROUTING_HV_SINT;
1387     kroute.flags = 0;
1388     kroute.u.hv_sint.vcpu = vcpu;
1389     kroute.u.hv_sint.sint = sint;
1390
1391     kvm_add_routing_entry(s, &kroute);
1392     kvm_irqchip_commit_routes(s);
1393
1394     return virq;
1395 }
1396
1397 #else /* !KVM_CAP_IRQ_ROUTING */
1398
1399 void kvm_init_irq_routing(KVMState *s)
1400 {
1401 }
1402
1403 void kvm_irqchip_release_virq(KVMState *s, int virq)
1404 {
1405 }
1406
1407 int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg)
1408 {
1409     abort();
1410 }
1411
1412 int kvm_irqchip_add_msi_route(KVMState *s, int vector, PCIDevice *dev)
1413 {
1414     return -ENOSYS;
1415 }
1416
1417 int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter)
1418 {
1419     return -ENOSYS;
1420 }
1421
1422 int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint)
1423 {
1424     return -ENOSYS;
1425 }
1426
1427 static int kvm_irqchip_assign_irqfd(KVMState *s, int fd, int virq, bool assign)
1428 {
1429     abort();
1430 }
1431
1432 int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg)
1433 {
1434     return -ENOSYS;
1435 }
1436 #endif /* !KVM_CAP_IRQ_ROUTING */
1437
1438 int kvm_irqchip_add_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
1439                                        EventNotifier *rn, int virq)
1440 {
1441     return kvm_irqchip_assign_irqfd(s, event_notifier_get_fd(n),
1442            rn ? event_notifier_get_fd(rn) : -1, virq, true);
1443 }
1444
1445 int kvm_irqchip_remove_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
1446                                           int virq)
1447 {
1448     return kvm_irqchip_assign_irqfd(s, event_notifier_get_fd(n), -1, virq,
1449            false);
1450 }
1451
1452 int kvm_irqchip_add_irqfd_notifier(KVMState *s, EventNotifier *n,
1453                                    EventNotifier *rn, qemu_irq irq)
1454 {
1455     gpointer key, gsi;
1456     gboolean found = g_hash_table_lookup_extended(s->gsimap, irq, &key, &gsi);
1457
1458     if (!found) {
1459         return -ENXIO;
1460     }
1461     return kvm_irqchip_add_irqfd_notifier_gsi(s, n, rn, GPOINTER_TO_INT(gsi));
1462 }
1463
1464 int kvm_irqchip_remove_irqfd_notifier(KVMState *s, EventNotifier *n,
1465                                       qemu_irq irq)
1466 {
1467     gpointer key, gsi;
1468     gboolean found = g_hash_table_lookup_extended(s->gsimap, irq, &key, &gsi);
1469
1470     if (!found) {
1471         return -ENXIO;
1472     }
1473     return kvm_irqchip_remove_irqfd_notifier_gsi(s, n, GPOINTER_TO_INT(gsi));
1474 }
1475
1476 void kvm_irqchip_set_qemuirq_gsi(KVMState *s, qemu_irq irq, int gsi)
1477 {
1478     g_hash_table_insert(s->gsimap, irq, GINT_TO_POINTER(gsi));
1479 }
1480
1481 static void kvm_irqchip_create(MachineState *machine, KVMState *s)
1482 {
1483     int ret;
1484
1485     if (kvm_check_extension(s, KVM_CAP_IRQCHIP)) {
1486         ;
1487     } else if (kvm_check_extension(s, KVM_CAP_S390_IRQCHIP)) {
1488         ret = kvm_vm_enable_cap(s, KVM_CAP_S390_IRQCHIP, 0);
1489         if (ret < 0) {
1490             fprintf(stderr, "Enable kernel irqchip failed: %s\n", strerror(-ret));
1491             exit(1);
1492         }
1493     } else {
1494         return;
1495     }
1496
1497     /* First probe and see if there's a arch-specific hook to create the
1498      * in-kernel irqchip for us */
1499     ret = kvm_arch_irqchip_create(machine, s);
1500     if (ret == 0) {
1501         if (machine_kernel_irqchip_split(machine)) {
1502             perror("Split IRQ chip mode not supported.");
1503             exit(1);
1504         } else {
1505             ret = kvm_vm_ioctl(s, KVM_CREATE_IRQCHIP);
1506         }
1507     }
1508     if (ret < 0) {
1509         fprintf(stderr, "Create kernel irqchip failed: %s\n", strerror(-ret));
1510         exit(1);
1511     }
1512
1513     kvm_kernel_irqchip = true;
1514     /* If we have an in-kernel IRQ chip then we must have asynchronous
1515      * interrupt delivery (though the reverse is not necessarily true)
1516      */
1517     kvm_async_interrupts_allowed = true;
1518     kvm_halt_in_kernel_allowed = true;
1519
1520     kvm_init_irq_routing(s);
1521
1522     s->gsimap = g_hash_table_new(g_direct_hash, g_direct_equal);
1523 }
1524
1525 /* Find number of supported CPUs using the recommended
1526  * procedure from the kernel API documentation to cope with
1527  * older kernels that may be missing capabilities.
1528  */
1529 static int kvm_recommended_vcpus(KVMState *s)
1530 {
1531     int ret = kvm_check_extension(s, KVM_CAP_NR_VCPUS);
1532     return (ret) ? ret : 4;
1533 }
1534
1535 static int kvm_max_vcpus(KVMState *s)
1536 {
1537     int ret = kvm_check_extension(s, KVM_CAP_MAX_VCPUS);
1538     return (ret) ? ret : kvm_recommended_vcpus(s);
1539 }
1540
1541 static int kvm_max_vcpu_id(KVMState *s)
1542 {
1543     int ret = kvm_check_extension(s, KVM_CAP_MAX_VCPU_ID);
1544     return (ret) ? ret : kvm_max_vcpus(s);
1545 }
1546
1547 bool kvm_vcpu_id_is_valid(int vcpu_id)
1548 {
1549     KVMState *s = KVM_STATE(current_machine->accelerator);
1550     return vcpu_id >= 0 && vcpu_id < kvm_max_vcpu_id(s);
1551 }
1552
1553 static int kvm_init(MachineState *ms)
1554 {
1555     MachineClass *mc = MACHINE_GET_CLASS(ms);
1556     static const char upgrade_note[] =
1557         "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
1558         "(see http://sourceforge.net/projects/kvm).\n";
1559     struct {
1560         const char *name;
1561         int num;
1562     } num_cpus[] = {
1563         { "SMP",          smp_cpus },
1564         { "hotpluggable", max_cpus },
1565         { NULL, }
1566     }, *nc = num_cpus;
1567     int soft_vcpus_limit, hard_vcpus_limit;
1568     KVMState *s;
1569     const KVMCapabilityInfo *missing_cap;
1570     int ret;
1571     int type = 0;
1572     const char *kvm_type;
1573
1574     s = KVM_STATE(ms->accelerator);
1575
1576     /*
1577      * On systems where the kernel can support different base page
1578      * sizes, host page size may be different from TARGET_PAGE_SIZE,
1579      * even with KVM.  TARGET_PAGE_SIZE is assumed to be the minimum
1580      * page size for the system though.
1581      */
1582     assert(TARGET_PAGE_SIZE <= getpagesize());
1583
1584     s->sigmask_len = 8;
1585
1586 #ifdef KVM_CAP_SET_GUEST_DEBUG
1587     QTAILQ_INIT(&s->kvm_sw_breakpoints);
1588 #endif
1589     QLIST_INIT(&s->kvm_parked_vcpus);
1590     s->vmfd = -1;
1591     s->fd = qemu_open("/dev/kvm", O_RDWR);
1592     if (s->fd == -1) {
1593         fprintf(stderr, "Could not access KVM kernel module: %m\n");
1594         ret = -errno;
1595         goto err;
1596     }
1597
1598     ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
1599     if (ret < KVM_API_VERSION) {
1600         if (ret >= 0) {
1601             ret = -EINVAL;
1602         }
1603         fprintf(stderr, "kvm version too old\n");
1604         goto err;
1605     }
1606
1607     if (ret > KVM_API_VERSION) {
1608         ret = -EINVAL;
1609         fprintf(stderr, "kvm version not supported\n");
1610         goto err;
1611     }
1612
1613     s->nr_slots = kvm_check_extension(s, KVM_CAP_NR_MEMSLOTS);
1614
1615     /* If unspecified, use the default value */
1616     if (!s->nr_slots) {
1617         s->nr_slots = 32;
1618     }
1619
1620     /* check the vcpu limits */
1621     soft_vcpus_limit = kvm_recommended_vcpus(s);
1622     hard_vcpus_limit = kvm_max_vcpus(s);
1623
1624     while (nc->name) {
1625         if (nc->num > soft_vcpus_limit) {
1626             fprintf(stderr,
1627                     "Warning: Number of %s cpus requested (%d) exceeds "
1628                     "the recommended cpus supported by KVM (%d)\n",
1629                     nc->name, nc->num, soft_vcpus_limit);
1630
1631             if (nc->num > hard_vcpus_limit) {
1632                 fprintf(stderr, "Number of %s cpus requested (%d) exceeds "
1633                         "the maximum cpus supported by KVM (%d)\n",
1634                         nc->name, nc->num, hard_vcpus_limit);
1635                 exit(1);
1636             }
1637         }
1638         nc++;
1639     }
1640
1641     kvm_type = qemu_opt_get(qemu_get_machine_opts(), "kvm-type");
1642     if (mc->kvm_type) {
1643         type = mc->kvm_type(kvm_type);
1644     } else if (kvm_type) {
1645         ret = -EINVAL;
1646         fprintf(stderr, "Invalid argument kvm-type=%s\n", kvm_type);
1647         goto err;
1648     }
1649
1650     do {
1651         ret = kvm_ioctl(s, KVM_CREATE_VM, type);
1652     } while (ret == -EINTR);
1653
1654     if (ret < 0) {
1655         fprintf(stderr, "ioctl(KVM_CREATE_VM) failed: %d %s\n", -ret,
1656                 strerror(-ret));
1657
1658 #ifdef TARGET_S390X
1659         if (ret == -EINVAL) {
1660             fprintf(stderr,
1661                     "Host kernel setup problem detected. Please verify:\n");
1662             fprintf(stderr, "- for kernels supporting the switch_amode or"
1663                     " user_mode parameters, whether\n");
1664             fprintf(stderr,
1665                     "  user space is running in primary address space\n");
1666             fprintf(stderr,
1667                     "- for kernels supporting the vm.allocate_pgste sysctl, "
1668                     "whether it is enabled\n");
1669         }
1670 #endif
1671         goto err;
1672     }
1673
1674     s->vmfd = ret;
1675     missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
1676     if (!missing_cap) {
1677         missing_cap =
1678             kvm_check_extension_list(s, kvm_arch_required_capabilities);
1679     }
1680     if (missing_cap) {
1681         ret = -EINVAL;
1682         fprintf(stderr, "kvm does not support %s\n%s",
1683                 missing_cap->name, upgrade_note);
1684         goto err;
1685     }
1686
1687     s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
1688
1689     s->broken_set_mem_region = 1;
1690     ret = kvm_check_extension(s, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
1691     if (ret > 0) {
1692         s->broken_set_mem_region = 0;
1693     }
1694
1695 #ifdef KVM_CAP_VCPU_EVENTS
1696     s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
1697 #endif
1698
1699     s->robust_singlestep =
1700         kvm_check_extension(s, KVM_CAP_X86_ROBUST_SINGLESTEP);
1701
1702 #ifdef KVM_CAP_DEBUGREGS
1703     s->debugregs = kvm_check_extension(s, KVM_CAP_DEBUGREGS);
1704 #endif
1705
1706 #ifdef KVM_CAP_IRQ_ROUTING
1707     kvm_direct_msi_allowed = (kvm_check_extension(s, KVM_CAP_SIGNAL_MSI) > 0);
1708 #endif
1709
1710     s->intx_set_mask = kvm_check_extension(s, KVM_CAP_PCI_2_3);
1711
1712     s->irq_set_ioctl = KVM_IRQ_LINE;
1713     if (kvm_check_extension(s, KVM_CAP_IRQ_INJECT_STATUS)) {
1714         s->irq_set_ioctl = KVM_IRQ_LINE_STATUS;
1715     }
1716
1717 #ifdef KVM_CAP_READONLY_MEM
1718     kvm_readonly_mem_allowed =
1719         (kvm_check_extension(s, KVM_CAP_READONLY_MEM) > 0);
1720 #endif
1721
1722     kvm_eventfds_allowed =
1723         (kvm_check_extension(s, KVM_CAP_IOEVENTFD) > 0);
1724
1725     kvm_irqfds_allowed =
1726         (kvm_check_extension(s, KVM_CAP_IRQFD) > 0);
1727
1728     kvm_resamplefds_allowed =
1729         (kvm_check_extension(s, KVM_CAP_IRQFD_RESAMPLE) > 0);
1730
1731     kvm_vm_attributes_allowed =
1732         (kvm_check_extension(s, KVM_CAP_VM_ATTRIBUTES) > 0);
1733
1734     kvm_ioeventfd_any_length_allowed =
1735         (kvm_check_extension(s, KVM_CAP_IOEVENTFD_ANY_LENGTH) > 0);
1736
1737     ret = kvm_arch_init(ms, s);
1738     if (ret < 0) {
1739         goto err;
1740     }
1741
1742     if (machine_kernel_irqchip_allowed(ms)) {
1743         kvm_irqchip_create(ms, s);
1744     }
1745
1746     kvm_state = s;
1747
1748     if (kvm_eventfds_allowed) {
1749         s->memory_listener.listener.eventfd_add = kvm_mem_ioeventfd_add;
1750         s->memory_listener.listener.eventfd_del = kvm_mem_ioeventfd_del;
1751     }
1752     s->memory_listener.listener.coalesced_mmio_add = kvm_coalesce_mmio_region;
1753     s->memory_listener.listener.coalesced_mmio_del = kvm_uncoalesce_mmio_region;
1754
1755     kvm_memory_listener_register(s, &s->memory_listener,
1756                                  &address_space_memory, 0);
1757     memory_listener_register(&kvm_io_listener,
1758                              &address_space_io);
1759
1760     s->many_ioeventfds = kvm_check_many_ioeventfds();
1761
1762     cpu_interrupt_handler = kvm_handle_interrupt;
1763
1764     return 0;
1765
1766 err:
1767     assert(ret < 0);
1768     if (s->vmfd >= 0) {
1769         close(s->vmfd);
1770     }
1771     if (s->fd != -1) {
1772         close(s->fd);
1773     }
1774     g_free(s->memory_listener.slots);
1775
1776     return ret;
1777 }
1778
1779 void kvm_set_sigmask_len(KVMState *s, unsigned int sigmask_len)
1780 {
1781     s->sigmask_len = sigmask_len;
1782 }
1783
1784 static void kvm_handle_io(uint16_t port, MemTxAttrs attrs, void *data, int direction,
1785                           int size, uint32_t count)
1786 {
1787     int i;
1788     uint8_t *ptr = data;
1789
1790     for (i = 0; i < count; i++) {
1791         address_space_rw(&address_space_io, port, attrs,
1792                          ptr, size,
1793                          direction == KVM_EXIT_IO_OUT);
1794         ptr += size;
1795     }
1796 }
1797
1798 static int kvm_handle_internal_error(CPUState *cpu, struct kvm_run *run)
1799 {
1800     fprintf(stderr, "KVM internal error. Suberror: %d\n",
1801             run->internal.suberror);
1802
1803     if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) {
1804         int i;
1805
1806         for (i = 0; i < run->internal.ndata; ++i) {
1807             fprintf(stderr, "extra data[%d]: %"PRIx64"\n",
1808                     i, (uint64_t)run->internal.data[i]);
1809         }
1810     }
1811     if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {
1812         fprintf(stderr, "emulation failure\n");
1813         if (!kvm_arch_stop_on_emulation_error(cpu)) {
1814             cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);
1815             return EXCP_INTERRUPT;
1816         }
1817     }
1818     /* FIXME: Should trigger a qmp message to let management know
1819      * something went wrong.
1820      */
1821     return -1;
1822 }
1823
1824 void kvm_flush_coalesced_mmio_buffer(void)
1825 {
1826     KVMState *s = kvm_state;
1827
1828     if (s->coalesced_flush_in_progress) {
1829         return;
1830     }
1831
1832     s->coalesced_flush_in_progress = true;
1833
1834     if (s->coalesced_mmio_ring) {
1835         struct kvm_coalesced_mmio_ring *ring = s->coalesced_mmio_ring;
1836         while (ring->first != ring->last) {
1837             struct kvm_coalesced_mmio *ent;
1838
1839             ent = &ring->coalesced_mmio[ring->first];
1840
1841             cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
1842             smp_wmb();
1843             ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
1844         }
1845     }
1846
1847     s->coalesced_flush_in_progress = false;
1848 }
1849
1850 static void do_kvm_cpu_synchronize_state(void *arg)
1851 {
1852     CPUState *cpu = arg;
1853
1854     if (!cpu->kvm_vcpu_dirty) {
1855         kvm_arch_get_registers(cpu);
1856         cpu->kvm_vcpu_dirty = true;
1857     }
1858 }
1859
1860 void kvm_cpu_synchronize_state(CPUState *cpu)
1861 {
1862     if (!cpu->kvm_vcpu_dirty) {
1863         run_on_cpu(cpu, do_kvm_cpu_synchronize_state, cpu);
1864     }
1865 }
1866
1867 static void do_kvm_cpu_synchronize_post_reset(void *arg)
1868 {
1869     CPUState *cpu = arg;
1870
1871     kvm_arch_put_registers(cpu, KVM_PUT_RESET_STATE);
1872     cpu->kvm_vcpu_dirty = false;
1873 }
1874
1875 void kvm_cpu_synchronize_post_reset(CPUState *cpu)
1876 {
1877     run_on_cpu(cpu, do_kvm_cpu_synchronize_post_reset, cpu);
1878 }
1879
1880 static void do_kvm_cpu_synchronize_post_init(void *arg)
1881 {
1882     CPUState *cpu = arg;
1883
1884     kvm_arch_put_registers(cpu, KVM_PUT_FULL_STATE);
1885     cpu->kvm_vcpu_dirty = false;
1886 }
1887
1888 void kvm_cpu_synchronize_post_init(CPUState *cpu)
1889 {
1890     run_on_cpu(cpu, do_kvm_cpu_synchronize_post_init, cpu);
1891 }
1892
1893 int kvm_cpu_exec(CPUState *cpu)
1894 {
1895     struct kvm_run *run = cpu->kvm_run;
1896     int ret, run_ret;
1897
1898     DPRINTF("kvm_cpu_exec()\n");
1899
1900     if (kvm_arch_process_async_events(cpu)) {
1901         cpu->exit_request = 0;
1902         return EXCP_HLT;
1903     }
1904
1905     qemu_mutex_unlock_iothread();
1906
1907     do {
1908         MemTxAttrs attrs;
1909
1910         if (cpu->kvm_vcpu_dirty) {
1911             kvm_arch_put_registers(cpu, KVM_PUT_RUNTIME_STATE);
1912             cpu->kvm_vcpu_dirty = false;
1913         }
1914
1915         kvm_arch_pre_run(cpu, run);
1916         if (cpu->exit_request) {
1917             DPRINTF("interrupt exit requested\n");
1918             /*
1919              * KVM requires us to reenter the kernel after IO exits to complete
1920              * instruction emulation. This self-signal will ensure that we
1921              * leave ASAP again.
1922              */
1923             qemu_cpu_kick_self();
1924         }
1925
1926         run_ret = kvm_vcpu_ioctl(cpu, KVM_RUN, 0);
1927
1928         attrs = kvm_arch_post_run(cpu, run);
1929
1930         if (run_ret < 0) {
1931             if (run_ret == -EINTR || run_ret == -EAGAIN) {
1932                 DPRINTF("io window exit\n");
1933                 ret = EXCP_INTERRUPT;
1934                 break;
1935             }
1936             fprintf(stderr, "error: kvm run failed %s\n",
1937                     strerror(-run_ret));
1938 #ifdef TARGET_PPC
1939             if (run_ret == -EBUSY) {
1940                 fprintf(stderr,
1941                         "This is probably because your SMT is enabled.\n"
1942                         "VCPU can only run on primary threads with all "
1943                         "secondary threads offline.\n");
1944             }
1945 #endif
1946             ret = -1;
1947             break;
1948         }
1949
1950         trace_kvm_run_exit(cpu->cpu_index, run->exit_reason);
1951         switch (run->exit_reason) {
1952         case KVM_EXIT_IO:
1953             DPRINTF("handle_io\n");
1954             /* Called outside BQL */
1955             kvm_handle_io(run->io.port, attrs,
1956                           (uint8_t *)run + run->io.data_offset,
1957                           run->io.direction,
1958                           run->io.size,
1959                           run->io.count);
1960             ret = 0;
1961             break;
1962         case KVM_EXIT_MMIO:
1963             DPRINTF("handle_mmio\n");
1964             /* Called outside BQL */
1965             address_space_rw(&address_space_memory,
1966                              run->mmio.phys_addr, attrs,
1967                              run->mmio.data,
1968                              run->mmio.len,
1969                              run->mmio.is_write);
1970             ret = 0;
1971             break;
1972         case KVM_EXIT_IRQ_WINDOW_OPEN:
1973             DPRINTF("irq_window_open\n");
1974             ret = EXCP_INTERRUPT;
1975             break;
1976         case KVM_EXIT_SHUTDOWN:
1977             DPRINTF("shutdown\n");
1978             qemu_system_reset_request();
1979             ret = EXCP_INTERRUPT;
1980             break;
1981         case KVM_EXIT_UNKNOWN:
1982             fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
1983                     (uint64_t)run->hw.hardware_exit_reason);
1984             ret = -1;
1985             break;
1986         case KVM_EXIT_INTERNAL_ERROR:
1987             ret = kvm_handle_internal_error(cpu, run);
1988             break;
1989         case KVM_EXIT_SYSTEM_EVENT:
1990             switch (run->system_event.type) {
1991             case KVM_SYSTEM_EVENT_SHUTDOWN:
1992                 qemu_system_shutdown_request();
1993                 ret = EXCP_INTERRUPT;
1994                 break;
1995             case KVM_SYSTEM_EVENT_RESET:
1996                 qemu_system_reset_request();
1997                 ret = EXCP_INTERRUPT;
1998                 break;
1999             case KVM_SYSTEM_EVENT_CRASH:
2000                 qemu_mutex_lock_iothread();
2001                 qemu_system_guest_panicked();
2002                 qemu_mutex_unlock_iothread();
2003                 ret = 0;
2004                 break;
2005             default:
2006                 DPRINTF("kvm_arch_handle_exit\n");
2007                 ret = kvm_arch_handle_exit(cpu, run);
2008                 break;
2009             }
2010             break;
2011         default:
2012             DPRINTF("kvm_arch_handle_exit\n");
2013             ret = kvm_arch_handle_exit(cpu, run);
2014             break;
2015         }
2016     } while (ret == 0);
2017
2018     qemu_mutex_lock_iothread();
2019
2020     if (ret < 0) {
2021         cpu_dump_state(cpu, stderr, fprintf, CPU_DUMP_CODE);
2022         vm_stop(RUN_STATE_INTERNAL_ERROR);
2023     }
2024
2025     cpu->exit_request = 0;
2026     return ret;
2027 }
2028
2029 int kvm_ioctl(KVMState *s, int type, ...)
2030 {
2031     int ret;
2032     void *arg;
2033     va_list ap;
2034
2035     va_start(ap, type);
2036     arg = va_arg(ap, void *);
2037     va_end(ap);
2038
2039     trace_kvm_ioctl(type, arg);
2040     ret = ioctl(s->fd, type, arg);
2041     if (ret == -1) {
2042         ret = -errno;
2043     }
2044     return ret;
2045 }
2046
2047 int kvm_vm_ioctl(KVMState *s, int type, ...)
2048 {
2049     int ret;
2050     void *arg;
2051     va_list ap;
2052
2053     va_start(ap, type);
2054     arg = va_arg(ap, void *);
2055     va_end(ap);
2056
2057     trace_kvm_vm_ioctl(type, arg);
2058     ret = ioctl(s->vmfd, type, arg);
2059     if (ret == -1) {
2060         ret = -errno;
2061     }
2062     return ret;
2063 }
2064
2065 int kvm_vcpu_ioctl(CPUState *cpu, int type, ...)
2066 {
2067     int ret;
2068     void *arg;
2069     va_list ap;
2070
2071     va_start(ap, type);
2072     arg = va_arg(ap, void *);
2073     va_end(ap);
2074
2075     trace_kvm_vcpu_ioctl(cpu->cpu_index, type, arg);
2076     ret = ioctl(cpu->kvm_fd, type, arg);
2077     if (ret == -1) {
2078         ret = -errno;
2079     }
2080     return ret;
2081 }
2082
2083 int kvm_device_ioctl(int fd, int type, ...)
2084 {
2085     int ret;
2086     void *arg;
2087     va_list ap;
2088
2089     va_start(ap, type);
2090     arg = va_arg(ap, void *);
2091     va_end(ap);
2092
2093     trace_kvm_device_ioctl(fd, type, arg);
2094     ret = ioctl(fd, type, arg);
2095     if (ret == -1) {
2096         ret = -errno;
2097     }
2098     return ret;
2099 }
2100
2101 int kvm_vm_check_attr(KVMState *s, uint32_t group, uint64_t attr)
2102 {
2103     int ret;
2104     struct kvm_device_attr attribute = {
2105         .group = group,
2106         .attr = attr,
2107     };
2108
2109     if (!kvm_vm_attributes_allowed) {
2110         return 0;
2111     }
2112
2113     ret = kvm_vm_ioctl(s, KVM_HAS_DEVICE_ATTR, &attribute);
2114     /* kvm returns 0 on success for HAS_DEVICE_ATTR */
2115     return ret ? 0 : 1;
2116 }
2117
2118 int kvm_device_check_attr(int dev_fd, uint32_t group, uint64_t attr)
2119 {
2120     struct kvm_device_attr attribute = {
2121         .group = group,
2122         .attr = attr,
2123         .flags = 0,
2124     };
2125
2126     return kvm_device_ioctl(dev_fd, KVM_HAS_DEVICE_ATTR, &attribute) ? 0 : 1;
2127 }
2128
2129 void kvm_device_access(int fd, int group, uint64_t attr,
2130                        void *val, bool write)
2131 {
2132     struct kvm_device_attr kvmattr;
2133     int err;
2134
2135     kvmattr.flags = 0;
2136     kvmattr.group = group;
2137     kvmattr.attr = attr;
2138     kvmattr.addr = (uintptr_t)val;
2139
2140     err = kvm_device_ioctl(fd,
2141                            write ? KVM_SET_DEVICE_ATTR : KVM_GET_DEVICE_ATTR,
2142                            &kvmattr);
2143     if (err < 0) {
2144         error_report("KVM_%s_DEVICE_ATTR failed: %s",
2145                      write ? "SET" : "GET", strerror(-err));
2146         error_printf("Group %d attr 0x%016" PRIx64 "\n", group, attr);
2147         abort();
2148     }
2149 }
2150
2151 int kvm_has_sync_mmu(void)
2152 {
2153     return kvm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);
2154 }
2155
2156 int kvm_has_vcpu_events(void)
2157 {
2158     return kvm_state->vcpu_events;
2159 }
2160
2161 int kvm_has_robust_singlestep(void)
2162 {
2163     return kvm_state->robust_singlestep;
2164 }
2165
2166 int kvm_has_debugregs(void)
2167 {
2168     return kvm_state->debugregs;
2169 }
2170
2171 int kvm_has_many_ioeventfds(void)
2172 {
2173     if (!kvm_enabled()) {
2174         return 0;
2175     }
2176     return kvm_state->many_ioeventfds;
2177 }
2178
2179 int kvm_has_gsi_routing(void)
2180 {
2181 #ifdef KVM_CAP_IRQ_ROUTING
2182     return kvm_check_extension(kvm_state, KVM_CAP_IRQ_ROUTING);
2183 #else
2184     return false;
2185 #endif
2186 }
2187
2188 int kvm_has_intx_set_mask(void)
2189 {
2190     return kvm_state->intx_set_mask;
2191 }
2192
2193 void kvm_setup_guest_memory(void *start, size_t size)
2194 {
2195     if (!kvm_has_sync_mmu()) {
2196         int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK);
2197
2198         if (ret) {
2199             perror("qemu_madvise");
2200             fprintf(stderr,
2201                     "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
2202             exit(1);
2203         }
2204     }
2205 }
2206
2207 #ifdef KVM_CAP_SET_GUEST_DEBUG
2208 struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *cpu,
2209                                                  target_ulong pc)
2210 {
2211     struct kvm_sw_breakpoint *bp;
2212
2213     QTAILQ_FOREACH(bp, &cpu->kvm_state->kvm_sw_breakpoints, entry) {
2214         if (bp->pc == pc) {
2215             return bp;
2216         }
2217     }
2218     return NULL;
2219 }
2220
2221 int kvm_sw_breakpoints_active(CPUState *cpu)
2222 {
2223     return !QTAILQ_EMPTY(&cpu->kvm_state->kvm_sw_breakpoints);
2224 }
2225
2226 struct kvm_set_guest_debug_data {
2227     struct kvm_guest_debug dbg;
2228     CPUState *cpu;
2229     int err;
2230 };
2231
2232 static void kvm_invoke_set_guest_debug(void *data)
2233 {
2234     struct kvm_set_guest_debug_data *dbg_data = data;
2235
2236     dbg_data->err = kvm_vcpu_ioctl(dbg_data->cpu, KVM_SET_GUEST_DEBUG,
2237                                    &dbg_data->dbg);
2238 }
2239
2240 int kvm_update_guest_debug(CPUState *cpu, unsigned long reinject_trap)
2241 {
2242     struct kvm_set_guest_debug_data data;
2243
2244     data.dbg.control = reinject_trap;
2245
2246     if (cpu->singlestep_enabled) {
2247         data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
2248     }
2249     kvm_arch_update_guest_debug(cpu, &data.dbg);
2250     data.cpu = cpu;
2251
2252     run_on_cpu(cpu, kvm_invoke_set_guest_debug, &data);
2253     return data.err;
2254 }
2255
2256 int kvm_insert_breakpoint(CPUState *cpu, target_ulong addr,
2257                           target_ulong len, int type)
2258 {
2259     struct kvm_sw_breakpoint *bp;
2260     int err;
2261
2262     if (type == GDB_BREAKPOINT_SW) {
2263         bp = kvm_find_sw_breakpoint(cpu, addr);
2264         if (bp) {
2265             bp->use_count++;
2266             return 0;
2267         }
2268
2269         bp = g_malloc(sizeof(struct kvm_sw_breakpoint));
2270         bp->pc = addr;
2271         bp->use_count = 1;
2272         err = kvm_arch_insert_sw_breakpoint(cpu, bp);
2273         if (err) {
2274             g_free(bp);
2275             return err;
2276         }
2277
2278         QTAILQ_INSERT_HEAD(&cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
2279     } else {
2280         err = kvm_arch_insert_hw_breakpoint(addr, len, type);
2281         if (err) {
2282             return err;
2283         }
2284     }
2285
2286     CPU_FOREACH(cpu) {
2287         err = kvm_update_guest_debug(cpu, 0);
2288         if (err) {
2289             return err;
2290         }
2291     }
2292     return 0;
2293 }
2294
2295 int kvm_remove_breakpoint(CPUState *cpu, target_ulong addr,
2296                           target_ulong len, int type)
2297 {
2298     struct kvm_sw_breakpoint *bp;
2299     int err;
2300
2301     if (type == GDB_BREAKPOINT_SW) {
2302         bp = kvm_find_sw_breakpoint(cpu, addr);
2303         if (!bp) {
2304             return -ENOENT;
2305         }
2306
2307         if (bp->use_count > 1) {
2308             bp->use_count--;
2309             return 0;
2310         }
2311
2312         err = kvm_arch_remove_sw_breakpoint(cpu, bp);
2313         if (err) {
2314             return err;
2315         }
2316
2317         QTAILQ_REMOVE(&cpu->kvm_state->kvm_sw_breakpoints, bp, entry);
2318         g_free(bp);
2319     } else {
2320         err = kvm_arch_remove_hw_breakpoint(addr, len, type);
2321         if (err) {
2322             return err;
2323         }
2324     }
2325
2326     CPU_FOREACH(cpu) {
2327         err = kvm_update_guest_debug(cpu, 0);
2328         if (err) {
2329             return err;
2330         }
2331     }
2332     return 0;
2333 }
2334
2335 void kvm_remove_all_breakpoints(CPUState *cpu)
2336 {
2337     struct kvm_sw_breakpoint *bp, *next;
2338     KVMState *s = cpu->kvm_state;
2339     CPUState *tmpcpu;
2340
2341     QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
2342         if (kvm_arch_remove_sw_breakpoint(cpu, bp) != 0) {
2343             /* Try harder to find a CPU that currently sees the breakpoint. */
2344             CPU_FOREACH(tmpcpu) {
2345                 if (kvm_arch_remove_sw_breakpoint(tmpcpu, bp) == 0) {
2346                     break;
2347                 }
2348             }
2349         }
2350         QTAILQ_REMOVE(&s->kvm_sw_breakpoints, bp, entry);
2351         g_free(bp);
2352     }
2353     kvm_arch_remove_all_hw_breakpoints();
2354
2355     CPU_FOREACH(cpu) {
2356         kvm_update_guest_debug(cpu, 0);
2357     }
2358 }
2359
2360 #else /* !KVM_CAP_SET_GUEST_DEBUG */
2361
2362 int kvm_update_guest_debug(CPUState *cpu, unsigned long reinject_trap)
2363 {
2364     return -EINVAL;
2365 }
2366
2367 int kvm_insert_breakpoint(CPUState *cpu, target_ulong addr,
2368                           target_ulong len, int type)
2369 {
2370     return -EINVAL;
2371 }
2372
2373 int kvm_remove_breakpoint(CPUState *cpu, target_ulong addr,
2374                           target_ulong len, int type)
2375 {
2376     return -EINVAL;
2377 }
2378
2379 void kvm_remove_all_breakpoints(CPUState *cpu)
2380 {
2381 }
2382 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
2383
2384 int kvm_set_signal_mask(CPUState *cpu, const sigset_t *sigset)
2385 {
2386     KVMState *s = kvm_state;
2387     struct kvm_signal_mask *sigmask;
2388     int r;
2389
2390     if (!sigset) {
2391         return kvm_vcpu_ioctl(cpu, KVM_SET_SIGNAL_MASK, NULL);
2392     }
2393
2394     sigmask = g_malloc(sizeof(*sigmask) + sizeof(*sigset));
2395
2396     sigmask->len = s->sigmask_len;
2397     memcpy(sigmask->sigset, sigset, sizeof(*sigset));
2398     r = kvm_vcpu_ioctl(cpu, KVM_SET_SIGNAL_MASK, sigmask);
2399     g_free(sigmask);
2400
2401     return r;
2402 }
2403 int kvm_on_sigbus_vcpu(CPUState *cpu, int code, void *addr)
2404 {
2405     return kvm_arch_on_sigbus_vcpu(cpu, code, addr);
2406 }
2407
2408 int kvm_on_sigbus(int code, void *addr)
2409 {
2410     return kvm_arch_on_sigbus(code, addr);
2411 }
2412
2413 int kvm_create_device(KVMState *s, uint64_t type, bool test)
2414 {
2415     int ret;
2416     struct kvm_create_device create_dev;
2417
2418     create_dev.type = type;
2419     create_dev.fd = -1;
2420     create_dev.flags = test ? KVM_CREATE_DEVICE_TEST : 0;
2421
2422     if (!kvm_check_extension(s, KVM_CAP_DEVICE_CTRL)) {
2423         return -ENOTSUP;
2424     }
2425
2426     ret = kvm_vm_ioctl(s, KVM_CREATE_DEVICE, &create_dev);
2427     if (ret) {
2428         return ret;
2429     }
2430
2431     return test ? 0 : create_dev.fd;
2432 }
2433
2434 bool kvm_device_supported(int vmfd, uint64_t type)
2435 {
2436     struct kvm_create_device create_dev = {
2437         .type = type,
2438         .fd = -1,
2439         .flags = KVM_CREATE_DEVICE_TEST,
2440     };
2441
2442     if (ioctl(vmfd, KVM_CHECK_EXTENSION, KVM_CAP_DEVICE_CTRL) <= 0) {
2443         return false;
2444     }
2445
2446     return (ioctl(vmfd, KVM_CREATE_DEVICE, &create_dev) >= 0);
2447 }
2448
2449 int kvm_set_one_reg(CPUState *cs, uint64_t id, void *source)
2450 {
2451     struct kvm_one_reg reg;
2452     int r;
2453
2454     reg.id = id;
2455     reg.addr = (uintptr_t) source;
2456     r = kvm_vcpu_ioctl(cs, KVM_SET_ONE_REG, &reg);
2457     if (r) {
2458         trace_kvm_failed_reg_set(id, strerror(-r));
2459     }
2460     return r;
2461 }
2462
2463 int kvm_get_one_reg(CPUState *cs, uint64_t id, void *target)
2464 {
2465     struct kvm_one_reg reg;
2466     int r;
2467
2468     reg.id = id;
2469     reg.addr = (uintptr_t) target;
2470     r = kvm_vcpu_ioctl(cs, KVM_GET_ONE_REG, &reg);
2471     if (r) {
2472         trace_kvm_failed_reg_get(id, strerror(-r));
2473     }
2474     return r;
2475 }
2476
2477 static void kvm_accel_class_init(ObjectClass *oc, void *data)
2478 {
2479     AccelClass *ac = ACCEL_CLASS(oc);
2480     ac->name = "KVM";
2481     ac->init_machine = kvm_init;
2482     ac->allowed = &kvm_allowed;
2483 }
2484
2485 static const TypeInfo kvm_accel_type = {
2486     .name = TYPE_KVM_ACCEL,
2487     .parent = TYPE_ACCEL,
2488     .class_init = kvm_accel_class_init,
2489     .instance_size = sizeof(KVMState),
2490 };
2491
2492 static void kvm_type_init(void)
2493 {
2494     type_register_static(&kvm_accel_type);
2495 }
2496
2497 type_init(kvm_type_init);