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