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