kvm-all.c

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