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