git.maemo.org Git - qemu/blob - kvm-all.c

   1 /*
   2  * QEMU KVM support
   3  *
   4  * Copyright IBM, Corp. 2008
   5  *           Red Hat, Inc. 2008
   6  *
   7  * Authors:
   8  *  Anthony Liguori   <aliguori@us.ibm.com>
   9  *  Glauber Costa     <gcosta@redhat.com>
  10  *
  11  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  12  * See the COPYING file in the top-level directory.
  13  *
  14  */
  15
  16 #include <sys/types.h>
  17 #include <sys/ioctl.h>
  18 #include <sys/mman.h>
  19 #include <stdarg.h>
  20
  21 #include <linux/kvm.h>
  22
  23 #include "qemu-common.h"
  24 #include "sysemu.h"
  25 #include "kvm.h"
  26
  27 //#define DEBUG_KVM
  28
  29 #ifdef DEBUG_KVM
  30 #define dprintf(fmt, ...) \
  31     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
  32 #else
  33 #define dprintf(fmt, ...) \
  34     do { } while (0)
  35 #endif
  36
  37 typedef struct KVMSlot
  38 {
  39     target_phys_addr_t start_addr;
  40     ram_addr_t memory_size;
  41     ram_addr_t phys_offset;
  42     int slot;
  43     int flags;
  44 } KVMSlot;
  45
  46 typedef struct kvm_dirty_log KVMDirtyLog;
  47
  48 int kvm_allowed = 0;
  49
  50 struct KVMState
  51 {
  52     KVMSlot slots[32];
  53     int fd;
  54     int vmfd;
  55 };
  56
  57 static KVMState *kvm_state;
  58
  59 static KVMSlot *kvm_alloc_slot(KVMState *s)
  60 {
  61     int i;
  62
  63     for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
  64         /* KVM private memory slots */
  65         if (i >= 8 && i < 12)
  66             continue;
  67         if (s->slots[i].memory_size == 0)
  68             return &s->slots[i];
  69     }
  70
  71     return NULL;
  72 }
  73
  74 static KVMSlot *kvm_lookup_slot(KVMState *s, target_phys_addr_t start_addr)
  75 {
  76     int i;
  77
  78     for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
  79         KVMSlot *mem = &s->slots[i];
  80
  81         if (start_addr >= mem->start_addr &&
  82             start_addr < (mem->start_addr + mem->memory_size))
  83             return mem;
  84     }
  85
  86     return NULL;
  87 }
  88
  89 static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
  90 {
  91     struct kvm_userspace_memory_region mem;
  92
  93     mem.slot = slot->slot;
  94     mem.guest_phys_addr = slot->start_addr;
  95     mem.memory_size = slot->memory_size;
  96     mem.userspace_addr = (unsigned long)phys_ram_base + slot->phys_offset;
  97     mem.flags = slot->flags;
  98
  99     return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
 100 }
 101
 102
 103 int kvm_init_vcpu(CPUState *env)
 104 {
 105     KVMState *s = kvm_state;
 106     long mmap_size;
 107     int ret;
 108
 109     dprintf("kvm_init_vcpu\n");
 110
 111     ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
 112     if (ret < 0) {
 113         dprintf("kvm_create_vcpu failed\n");
 114         goto err;
 115     }
 116
 117     env->kvm_fd = ret;
 118     env->kvm_state = s;
 119
 120     mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
 121     if (mmap_size < 0) {
 122         dprintf("KVM_GET_VCPU_MMAP_SIZE failed\n");
 123         goto err;
 124     }
 125
 126     env->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
 127                         env->kvm_fd, 0);
 128     if (env->kvm_run == MAP_FAILED) {
 129         ret = -errno;
 130         dprintf("mmap'ing vcpu state failed\n");
 131         goto err;
 132     }
 133
 134     ret = kvm_arch_init_vcpu(env);
 135
 136 err:
 137     return ret;
 138 }
 139
 140 /*
 141  * dirty pages logging control
 142  */
 143 static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr, target_phys_addr_t end_addr,
 144                                       unsigned flags,
 145                                       unsigned mask)
 146 {
 147     KVMState *s = kvm_state;
 148     KVMSlot *mem = kvm_lookup_slot(s, phys_addr);
 149     if (mem == NULL)  {
 150             dprintf("invalid parameters %llx-%llx\n", phys_addr, end_addr);
 151             return -EINVAL;
 152     }
 153
 154     flags = (mem->flags & ~mask) | flags;
 155     /* Nothing changed, no need to issue ioctl */
 156     if (flags == mem->flags)
 157             return 0;
 158
 159     mem->flags = flags;
 160
 161     return kvm_set_user_memory_region(s, mem);
 162 }
 163
 164 int kvm_log_start(target_phys_addr_t phys_addr, target_phys_addr_t end_addr)
 165 {
 166         return kvm_dirty_pages_log_change(phys_addr, end_addr,
 167                                           KVM_MEM_LOG_DIRTY_PAGES,
 168                                           KVM_MEM_LOG_DIRTY_PAGES);
 169 }
 170
 171 int kvm_log_stop(target_phys_addr_t phys_addr, target_phys_addr_t end_addr)
 172 {
 173         return kvm_dirty_pages_log_change(phys_addr, end_addr,
 174                                           0,
 175                                           KVM_MEM_LOG_DIRTY_PAGES);
 176 }
 177
 178 /**
 179  * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
 180  * This function updates qemu's dirty bitmap using cpu_physical_memory_set_dirty().
 181  * This means all bits are set to dirty.
 182  *
 183  * @start_add: start of logged region. This is what we use to search the memslot
 184  * @end_addr: end of logged region.
 185  */
 186 void kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr, target_phys_addr_t end_addr)
 187 {
 188     KVMState *s = kvm_state;
 189     KVMDirtyLog d;
 190     KVMSlot *mem = kvm_lookup_slot(s, start_addr);
 191     unsigned long alloc_size;
 192     ram_addr_t addr;
 193     target_phys_addr_t phys_addr = start_addr;
 194
 195     dprintf("sync addr: %llx into %lx\n", start_addr, mem->phys_offset);
 196     if (mem == NULL) {
 197             fprintf(stderr, "BUG: %s: invalid parameters\n", __func__);
 198             return;
 199     }
 200
 201     alloc_size = mem->memory_size >> TARGET_PAGE_BITS / sizeof(d.dirty_bitmap);
 202     d.dirty_bitmap = qemu_mallocz(alloc_size);
 203
 204     if (d.dirty_bitmap == NULL) {
 205         dprintf("Could not allocate dirty bitmap\n");
 206         return;
 207     }
 208
 209     d.slot = mem->slot;
 210     dprintf("slot %d, phys_addr %llx, uaddr: %llx\n",
 211             d.slot, mem->start_addr, mem->phys_offset);
 212
 213     if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
 214         dprintf("ioctl failed %d\n", errno);
 215         goto out;
 216     }
 217
 218     phys_addr = start_addr;
 219     for (addr = mem->phys_offset; phys_addr < end_addr; phys_addr+= TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
 220         unsigned long *bitmap = (unsigned long *)d.dirty_bitmap;
 221         unsigned nr = (phys_addr - start_addr) >> TARGET_PAGE_BITS;
 222         unsigned word = nr / (sizeof(*bitmap) * 8);
 223         unsigned bit = nr % (sizeof(*bitmap) * 8);
 224         if ((bitmap[word] >> bit) & 1)
 225             cpu_physical_memory_set_dirty(addr);
 226     }
 227 out:
 228     qemu_free(d.dirty_bitmap);
 229 }
 230
 231 int kvm_init(int smp_cpus)
 232 {
 233     KVMState *s;
 234     int ret;
 235     int i;
 236
 237     if (smp_cpus > 1)
 238         return -EINVAL;
 239
 240     s = qemu_mallocz(sizeof(KVMState));
 241     if (s == NULL)
 242         return -ENOMEM;
 243
 244     for (i = 0; i < ARRAY_SIZE(s->slots); i++)
 245         s->slots[i].slot = i;
 246
 247     s->vmfd = -1;
 248     s->fd = open("/dev/kvm", O_RDWR);
 249     if (s->fd == -1) {
 250         fprintf(stderr, "Could not access KVM kernel module: %m\n");
 251         ret = -errno;
 252         goto err;
 253     }
 254
 255     ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
 256     if (ret < KVM_API_VERSION) {
 257         if (ret > 0)
 258             ret = -EINVAL;
 259         fprintf(stderr, "kvm version too old\n");
 260         goto err;
 261     }
 262
 263     if (ret > KVM_API_VERSION) {
 264         ret = -EINVAL;
 265         fprintf(stderr, "kvm version not supported\n");
 266         goto err;
 267     }
 268
 269     s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
 270     if (s->vmfd < 0)
 271         goto err;
 272
 273     /* initially, KVM allocated its own memory and we had to jump through
 274      * hooks to make phys_ram_base point to this.  Modern versions of KVM
 275      * just use a user allocated buffer so we can use phys_ram_base
 276      * unmodified.  Make sure we have a sufficiently modern version of KVM.
 277      */
 278     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_USER_MEMORY);
 279     if (ret <= 0) {
 280         if (ret == 0)
 281             ret = -EINVAL;
 282         fprintf(stderr, "kvm does not support KVM_CAP_USER_MEMORY\n");
 283         goto err;
 284     }
 285
 286     /* There was a nasty bug in < kvm-80 that prevents memory slots from being
 287      * destroyed properly.  Since we rely on this capability, refuse to work
 288      * with any kernel without this capability. */
 289     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION,
 290                     KVM_CAP_DESTROY_MEMORY_REGION_WORKS);
 291     if (ret <= 0) {
 292         if (ret == 0)
 293             ret = -EINVAL;
 294
 295         fprintf(stderr,
 296                 "KVM kernel module broken (DESTROY_MEMORY_REGION)\n"
 297                 "Please upgrade to at least kvm-81.\n");
 298         goto err;
 299     }
 300
 301     ret = kvm_arch_init(s, smp_cpus);
 302     if (ret < 0)
 303         goto err;
 304
 305     kvm_state = s;
 306
 307     return 0;
 308
 309 err:
 310     if (s) {
 311         if (s->vmfd != -1)
 312             close(s->vmfd);
 313         if (s->fd != -1)
 314             close(s->fd);
 315     }
 316     qemu_free(s);
 317
 318     return ret;
 319 }
 320
 321 static int kvm_handle_io(CPUState *env, uint16_t port, void *data,
 322                          int direction, int size, uint32_t count)
 323 {
 324     int i;
 325     uint8_t *ptr = data;
 326
 327     for (i = 0; i < count; i++) {
 328         if (direction == KVM_EXIT_IO_IN) {
 329             switch (size) {
 330             case 1:
 331                 stb_p(ptr, cpu_inb(env, port));
 332                 break;
 333             case 2:
 334                 stw_p(ptr, cpu_inw(env, port));
 335                 break;
 336             case 4:
 337                 stl_p(ptr, cpu_inl(env, port));
 338                 break;
 339             }
 340         } else {
 341             switch (size) {
 342             case 1:
 343                 cpu_outb(env, port, ldub_p(ptr));
 344                 break;
 345             case 2:
 346                 cpu_outw(env, port, lduw_p(ptr));
 347                 break;
 348             case 4:
 349                 cpu_outl(env, port, ldl_p(ptr));
 350                 break;
 351             }
 352         }
 353
 354         ptr += size;
 355     }
 356
 357     return 1;
 358 }
 359
 360 int kvm_cpu_exec(CPUState *env)
 361 {
 362     struct kvm_run *run = env->kvm_run;
 363     int ret;
 364
 365     dprintf("kvm_cpu_exec()\n");
 366
 367     do {
 368         kvm_arch_pre_run(env, run);
 369
 370         if ((env->interrupt_request & CPU_INTERRUPT_EXIT)) {
 371             dprintf("interrupt exit requested\n");
 372             ret = 0;
 373             break;
 374         }
 375
 376         ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
 377         kvm_arch_post_run(env, run);
 378
 379         if (ret == -EINTR || ret == -EAGAIN) {
 380             dprintf("io window exit\n");
 381             ret = 0;
 382             break;
 383         }
 384
 385         if (ret < 0) {
 386             dprintf("kvm run failed %s\n", strerror(-ret));
 387             abort();
 388         }
 389
 390         ret = 0; /* exit loop */
 391         switch (run->exit_reason) {
 392         case KVM_EXIT_IO:
 393             dprintf("handle_io\n");
 394             ret = kvm_handle_io(env, run->io.port,
 395                                 (uint8_t *)run + run->io.data_offset,
 396                                 run->io.direction,
 397                                 run->io.size,
 398                                 run->io.count);
 399             break;
 400         case KVM_EXIT_MMIO:
 401             dprintf("handle_mmio\n");
 402             cpu_physical_memory_rw(run->mmio.phys_addr,
 403                                    run->mmio.data,
 404                                    run->mmio.len,
 405                                    run->mmio.is_write);
 406             ret = 1;
 407             break;
 408         case KVM_EXIT_IRQ_WINDOW_OPEN:
 409             dprintf("irq_window_open\n");
 410             break;
 411         case KVM_EXIT_SHUTDOWN:
 412             dprintf("shutdown\n");
 413             qemu_system_reset_request();
 414             ret = 1;
 415             break;
 416         case KVM_EXIT_UNKNOWN:
 417             dprintf("kvm_exit_unknown\n");
 418             break;
 419         case KVM_EXIT_FAIL_ENTRY:
 420             dprintf("kvm_exit_fail_entry\n");
 421             break;
 422         case KVM_EXIT_EXCEPTION:
 423             dprintf("kvm_exit_exception\n");
 424             break;
 425         case KVM_EXIT_DEBUG:
 426             dprintf("kvm_exit_debug\n");
 427             break;
 428         default:
 429             dprintf("kvm_arch_handle_exit\n");
 430             ret = kvm_arch_handle_exit(env, run);
 431             break;
 432         }
 433     } while (ret > 0);
 434
 435     if ((env->interrupt_request & CPU_INTERRUPT_EXIT)) {
 436         env->interrupt_request &= ~CPU_INTERRUPT_EXIT;
 437         env->exception_index = EXCP_INTERRUPT;
 438     }
 439
 440     return ret;
 441 }
 442
 443 void kvm_set_phys_mem(target_phys_addr_t start_addr,
 444                       ram_addr_t size,
 445                       ram_addr_t phys_offset)
 446 {
 447     KVMState *s = kvm_state;
 448     ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
 449     KVMSlot *mem;
 450
 451     /* KVM does not support read-only slots */
 452     phys_offset &= ~IO_MEM_ROM;
 453
 454     mem = kvm_lookup_slot(s, start_addr);
 455     if (mem) {
 456         if ((flags == IO_MEM_UNASSIGNED) || (flags >= TLB_MMIO)) {
 457             mem->memory_size = 0;
 458             mem->start_addr = start_addr;
 459             mem->phys_offset = 0;
 460             mem->flags = 0;
 461
 462             kvm_set_user_memory_region(s, mem);
 463         } else if (start_addr >= mem->start_addr &&
 464                    (start_addr + size) <= (mem->start_addr +
 465                                            mem->memory_size)) {
 466             KVMSlot slot;
 467             target_phys_addr_t mem_start;
 468             ram_addr_t mem_size, mem_offset;
 469
 470             /* Not splitting */
 471             if ((phys_offset - (start_addr - mem->start_addr)) ==
 472                 mem->phys_offset)
 473                 return;
 474
 475             /* unregister whole slot */
 476             memcpy(&slot, mem, sizeof(slot));
 477             mem->memory_size = 0;
 478             kvm_set_user_memory_region(s, mem);
 479
 480             /* register prefix slot */
 481             mem_start = slot.start_addr;
 482             mem_size = start_addr - slot.start_addr;
 483             mem_offset = slot.phys_offset;
 484             if (mem_size)
 485                 kvm_set_phys_mem(mem_start, mem_size, mem_offset);
 486
 487             /* register new slot */
 488             kvm_set_phys_mem(start_addr, size, phys_offset);
 489
 490             /* register suffix slot */
 491             mem_start = start_addr + size;
 492             mem_offset += mem_size + size;
 493             mem_size = slot.memory_size - mem_size - size;
 494             if (mem_size)
 495                 kvm_set_phys_mem(mem_start, mem_size, mem_offset);
 496
 497             return;
 498         } else {
 499             printf("Registering overlapping slot\n");
 500             abort();
 501         }
 502     }
 503     /* KVM does not need to know about this memory */
 504     if (flags >= IO_MEM_UNASSIGNED)
 505         return;
 506
 507     mem = kvm_alloc_slot(s);
 508     mem->memory_size = size;
 509     mem->start_addr = start_addr;
 510     mem->phys_offset = phys_offset;
 511     mem->flags = 0;
 512
 513     kvm_set_user_memory_region(s, mem);
 514     /* FIXME deal with errors */
 515 }
 516
 517 int kvm_ioctl(KVMState *s, int type, ...)
 518 {
 519     int ret;
 520     void *arg;
 521     va_list ap;
 522
 523     va_start(ap, type);
 524     arg = va_arg(ap, void *);
 525     va_end(ap);
 526
 527     ret = ioctl(s->fd, type, arg);
 528     if (ret == -1)
 529         ret = -errno;
 530
 531     return ret;
 532 }
 533
 534 int kvm_vm_ioctl(KVMState *s, int type, ...)
 535 {
 536     int ret;
 537     void *arg;
 538     va_list ap;
 539
 540     va_start(ap, type);
 541     arg = va_arg(ap, void *);
 542     va_end(ap);
 543
 544     ret = ioctl(s->vmfd, type, arg);
 545     if (ret == -1)
 546         ret = -errno;
 547
 548     return ret;
 549 }
 550
 551 int kvm_vcpu_ioctl(CPUState *env, int type, ...)
 552 {
 553     int ret;
 554     void *arg;
 555     va_list ap;
 556
 557     va_start(ap, type);
 558     arg = va_arg(ap, void *);
 559     va_end(ap);
 560
 561     ret = ioctl(env->kvm_fd, type, arg);
 562     if (ret == -1)
 563         ret = -errno;
 564
 565     return ret;
 566 }
 567
 568 int kvm_has_sync_mmu(void)
 569 {
 570     KVMState *s = kvm_state;
 571
 572 #ifdef KVM_CAP_SYNC_MMU
 573     if (kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_SYNC_MMU) > 0)
 574         return 1;
 575 #endif
 576
 577     return 0;
 578 }