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