Annotation of qemu/kvm-all.c, revision 1.1.1.7

1.1       root        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"
1.1.1.5   root       25: #include "hw/hw.h"
                     26: #include "gdbstub.h"
1.1       root       27: #include "kvm.h"
                     28: 
                     29: /* KVM uses PAGE_SIZE in it's definition of COALESCED_MMIO_MAX */
                     30: #define PAGE_SIZE TARGET_PAGE_SIZE
                     31: 
                     32: //#define DEBUG_KVM
                     33: 
                     34: #ifdef DEBUG_KVM
                     35: #define dprintf(fmt, ...) \
                     36:     do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
                     37: #else
                     38: #define dprintf(fmt, ...) \
                     39:     do { } while (0)
                     40: #endif
                     41: 
                     42: typedef struct KVMSlot
                     43: {
                     44:     target_phys_addr_t start_addr;
                     45:     ram_addr_t memory_size;
                     46:     ram_addr_t phys_offset;
                     47:     int slot;
                     48:     int flags;
                     49: } KVMSlot;
                     50: 
                     51: typedef struct kvm_dirty_log KVMDirtyLog;
                     52: 
                     53: int kvm_allowed = 0;
                     54: 
                     55: struct KVMState
                     56: {
                     57:     KVMSlot slots[32];
                     58:     int fd;
                     59:     int vmfd;
1.1.1.7 ! root       60:     int regs_modified;
1.1       root       61:     int coalesced_mmio;
1.1.1.5   root       62:     int broken_set_mem_region;
                     63:     int migration_log;
1.1.1.7 ! root       64:     int vcpu_events;
1.1.1.5   root       65: #ifdef KVM_CAP_SET_GUEST_DEBUG
                     66:     struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
                     67: #endif
1.1.1.7 ! root       68:     int irqchip_in_kernel;
        !            69:     int pit_in_kernel;
1.1       root       70: };
                     71: 
                     72: static KVMState *kvm_state;
                     73: 
                     74: static KVMSlot *kvm_alloc_slot(KVMState *s)
                     75: {
                     76:     int i;
                     77: 
                     78:     for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
                     79:         /* KVM private memory slots */
                     80:         if (i >= 8 && i < 12)
                     81:             continue;
                     82:         if (s->slots[i].memory_size == 0)
                     83:             return &s->slots[i];
                     84:     }
                     85: 
1.1.1.5   root       86:     fprintf(stderr, "%s: no free slot available\n", __func__);
                     87:     abort();
1.1       root       88: }
                     89: 
1.1.1.5   root       90: static KVMSlot *kvm_lookup_matching_slot(KVMState *s,
                     91:                                          target_phys_addr_t start_addr,
                     92:                                          target_phys_addr_t end_addr)
1.1       root       93: {
                     94:     int i;
                     95: 
                     96:     for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
                     97:         KVMSlot *mem = &s->slots[i];
                     98: 
1.1.1.5   root       99:         if (start_addr == mem->start_addr &&
                    100:             end_addr == mem->start_addr + mem->memory_size) {
1.1       root      101:             return mem;
1.1.1.5   root      102:         }
1.1       root      103:     }
                    104: 
                    105:     return NULL;
                    106: }
                    107: 
1.1.1.5   root      108: /*
                    109:  * Find overlapping slot with lowest start address
                    110:  */
                    111: static KVMSlot *kvm_lookup_overlapping_slot(KVMState *s,
                    112:                                             target_phys_addr_t start_addr,
                    113:                                             target_phys_addr_t end_addr)
                    114: {
                    115:     KVMSlot *found = NULL;
                    116:     int i;
                    117: 
                    118:     for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
                    119:         KVMSlot *mem = &s->slots[i];
                    120: 
                    121:         if (mem->memory_size == 0 ||
                    122:             (found && found->start_addr < mem->start_addr)) {
                    123:             continue;
                    124:         }
                    125: 
                    126:         if (end_addr > mem->start_addr &&
                    127:             start_addr < mem->start_addr + mem->memory_size) {
                    128:             found = mem;
                    129:         }
                    130:     }
                    131: 
                    132:     return found;
                    133: }
                    134: 
1.1       root      135: static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
                    136: {
                    137:     struct kvm_userspace_memory_region mem;
                    138: 
                    139:     mem.slot = slot->slot;
                    140:     mem.guest_phys_addr = slot->start_addr;
                    141:     mem.memory_size = slot->memory_size;
1.1.1.5   root      142:     mem.userspace_addr = (unsigned long)qemu_get_ram_ptr(slot->phys_offset);
1.1       root      143:     mem.flags = slot->flags;
1.1.1.5   root      144:     if (s->migration_log) {
                    145:         mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
                    146:     }
1.1       root      147:     return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
                    148: }
                    149: 
1.1.1.5   root      150: static void kvm_reset_vcpu(void *opaque)
                    151: {
                    152:     CPUState *env = opaque;
                    153: 
1.1.1.7 ! root      154:     kvm_arch_reset_vcpu(env);
1.1.1.5   root      155:     if (kvm_arch_put_registers(env)) {
                    156:         fprintf(stderr, "Fatal: kvm vcpu reset failed\n");
                    157:         abort();
                    158:     }
                    159: }
1.1       root      160: 
1.1.1.7 ! root      161: int kvm_irqchip_in_kernel(void)
        !           162: {
        !           163:     return kvm_state->irqchip_in_kernel;
        !           164: }
        !           165: 
        !           166: int kvm_pit_in_kernel(void)
        !           167: {
        !           168:     return kvm_state->pit_in_kernel;
        !           169: }
        !           170: 
        !           171: 
1.1       root      172: int kvm_init_vcpu(CPUState *env)
                    173: {
                    174:     KVMState *s = kvm_state;
                    175:     long mmap_size;
                    176:     int ret;
                    177: 
                    178:     dprintf("kvm_init_vcpu\n");
                    179: 
                    180:     ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
                    181:     if (ret < 0) {
                    182:         dprintf("kvm_create_vcpu failed\n");
                    183:         goto err;
                    184:     }
                    185: 
                    186:     env->kvm_fd = ret;
                    187:     env->kvm_state = s;
                    188: 
                    189:     mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
                    190:     if (mmap_size < 0) {
                    191:         dprintf("KVM_GET_VCPU_MMAP_SIZE failed\n");
                    192:         goto err;
                    193:     }
                    194: 
                    195:     env->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
                    196:                         env->kvm_fd, 0);
                    197:     if (env->kvm_run == MAP_FAILED) {
                    198:         ret = -errno;
                    199:         dprintf("mmap'ing vcpu state failed\n");
                    200:         goto err;
                    201:     }
                    202: 
                    203:     ret = kvm_arch_init_vcpu(env);
1.1.1.5   root      204:     if (ret == 0) {
                    205:         qemu_register_reset(kvm_reset_vcpu, env);
1.1.1.7 ! root      206:         kvm_arch_reset_vcpu(env);
1.1.1.5   root      207:         ret = kvm_arch_put_registers(env);
                    208:     }
1.1       root      209: err:
                    210:     return ret;
                    211: }
                    212: 
                    213: /*
                    214:  * dirty pages logging control
                    215:  */
1.1.1.5   root      216: static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,
                    217:                                       ram_addr_t size, int flags, int mask)
1.1       root      218: {
                    219:     KVMState *s = kvm_state;
1.1.1.5   root      220:     KVMSlot *mem = kvm_lookup_matching_slot(s, phys_addr, phys_addr + size);
                    221:     int old_flags;
                    222: 
1.1       root      223:     if (mem == NULL)  {
1.1.1.5   root      224:             fprintf(stderr, "BUG: %s: invalid parameters " TARGET_FMT_plx "-"
                    225:                     TARGET_FMT_plx "\n", __func__, phys_addr,
1.1.1.7 ! root      226:                     (target_phys_addr_t)(phys_addr + size - 1));
1.1       root      227:             return -EINVAL;
                    228:     }
                    229: 
1.1.1.5   root      230:     old_flags = mem->flags;
1.1       root      231: 
1.1.1.5   root      232:     flags = (mem->flags & ~mask) | flags;
1.1       root      233:     mem->flags = flags;
                    234: 
1.1.1.5   root      235:     /* If nothing changed effectively, no need to issue ioctl */
                    236:     if (s->migration_log) {
                    237:         flags |= KVM_MEM_LOG_DIRTY_PAGES;
                    238:     }
                    239:     if (flags == old_flags) {
                    240:             return 0;
                    241:     }
                    242: 
1.1       root      243:     return kvm_set_user_memory_region(s, mem);
                    244: }
                    245: 
1.1.1.5   root      246: int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t size)
1.1       root      247: {
1.1.1.5   root      248:         return kvm_dirty_pages_log_change(phys_addr, size,
1.1       root      249:                                           KVM_MEM_LOG_DIRTY_PAGES,
                    250:                                           KVM_MEM_LOG_DIRTY_PAGES);
                    251: }
                    252: 
1.1.1.5   root      253: int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t size)
1.1       root      254: {
1.1.1.5   root      255:         return kvm_dirty_pages_log_change(phys_addr, size,
1.1       root      256:                                           0,
                    257:                                           KVM_MEM_LOG_DIRTY_PAGES);
                    258: }
                    259: 
1.1.1.5   root      260: int kvm_set_migration_log(int enable)
                    261: {
                    262:     KVMState *s = kvm_state;
                    263:     KVMSlot *mem;
                    264:     int i, err;
                    265: 
                    266:     s->migration_log = enable;
                    267: 
                    268:     for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
                    269:         mem = &s->slots[i];
                    270: 
                    271:         if (!!(mem->flags & KVM_MEM_LOG_DIRTY_PAGES) == enable) {
                    272:             continue;
                    273:         }
                    274:         err = kvm_set_user_memory_region(s, mem);
                    275:         if (err) {
                    276:             return err;
                    277:         }
                    278:     }
                    279:     return 0;
                    280: }
                    281: 
1.1.1.7 ! root      282: static int test_le_bit(unsigned long nr, unsigned char *addr)
        !           283: {
        !           284:     return (addr[nr >> 3] >> (nr & 7)) & 1;
        !           285: }
        !           286: 
1.1       root      287: /**
                    288:  * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
                    289:  * This function updates qemu's dirty bitmap using cpu_physical_memory_set_dirty().
                    290:  * This means all bits are set to dirty.
                    291:  *
1.1.1.5   root      292:  * @start_add: start of logged region.
1.1       root      293:  * @end_addr: end of logged region.
                    294:  */
1.1.1.5   root      295: int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
                    296:                                    target_phys_addr_t end_addr)
1.1       root      297: {
                    298:     KVMState *s = kvm_state;
1.1.1.5   root      299:     unsigned long size, allocated_size = 0;
                    300:     target_phys_addr_t phys_addr;
1.1       root      301:     ram_addr_t addr;
1.1.1.5   root      302:     KVMDirtyLog d;
                    303:     KVMSlot *mem;
                    304:     int ret = 0;
1.1       root      305: 
1.1.1.5   root      306:     d.dirty_bitmap = NULL;
                    307:     while (start_addr < end_addr) {
                    308:         mem = kvm_lookup_overlapping_slot(s, start_addr, end_addr);
                    309:         if (mem == NULL) {
                    310:             break;
                    311:         }
                    312: 
                    313:         size = ((mem->memory_size >> TARGET_PAGE_BITS) + 7) / 8;
                    314:         if (!d.dirty_bitmap) {
                    315:             d.dirty_bitmap = qemu_malloc(size);
                    316:         } else if (size > allocated_size) {
                    317:             d.dirty_bitmap = qemu_realloc(d.dirty_bitmap, size);
                    318:         }
                    319:         allocated_size = size;
                    320:         memset(d.dirty_bitmap, 0, allocated_size);
                    321: 
                    322:         d.slot = mem->slot;
                    323: 
                    324:         if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
                    325:             dprintf("ioctl failed %d\n", errno);
                    326:             ret = -1;
                    327:             break;
                    328:         }
1.1       root      329: 
1.1.1.5   root      330:         for (phys_addr = mem->start_addr, addr = mem->phys_offset;
                    331:              phys_addr < mem->start_addr + mem->memory_size;
                    332:              phys_addr += TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
1.1.1.7 ! root      333:             unsigned char *bitmap = (unsigned char *)d.dirty_bitmap;
1.1.1.5   root      334:             unsigned nr = (phys_addr - mem->start_addr) >> TARGET_PAGE_BITS;
1.1       root      335: 
1.1.1.7 ! root      336:             if (test_le_bit(nr, bitmap)) {
1.1.1.5   root      337:                 cpu_physical_memory_set_dirty(addr);
                    338:             }
                    339:         }
                    340:         start_addr = phys_addr;
1.1       root      341:     }
                    342:     qemu_free(d.dirty_bitmap);
1.1.1.5   root      343: 
                    344:     return ret;
1.1       root      345: }
                    346: 
                    347: int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
                    348: {
                    349:     int ret = -ENOSYS;
                    350: #ifdef KVM_CAP_COALESCED_MMIO
                    351:     KVMState *s = kvm_state;
                    352: 
                    353:     if (s->coalesced_mmio) {
                    354:         struct kvm_coalesced_mmio_zone zone;
                    355: 
                    356:         zone.addr = start;
                    357:         zone.size = size;
                    358: 
                    359:         ret = kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
                    360:     }
                    361: #endif
                    362: 
                    363:     return ret;
                    364: }
                    365: 
                    366: int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
                    367: {
                    368:     int ret = -ENOSYS;
                    369: #ifdef KVM_CAP_COALESCED_MMIO
                    370:     KVMState *s = kvm_state;
                    371: 
                    372:     if (s->coalesced_mmio) {
                    373:         struct kvm_coalesced_mmio_zone zone;
                    374: 
                    375:         zone.addr = start;
                    376:         zone.size = size;
                    377: 
                    378:         ret = kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
                    379:     }
                    380: #endif
                    381: 
                    382:     return ret;
                    383: }
                    384: 
1.1.1.4   root      385: int kvm_check_extension(KVMState *s, unsigned int extension)
                    386: {
                    387:     int ret;
                    388: 
                    389:     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
                    390:     if (ret < 0) {
                    391:         ret = 0;
                    392:     }
                    393: 
                    394:     return ret;
                    395: }
                    396: 
1.1       root      397: int kvm_init(int smp_cpus)
                    398: {
1.1.1.5   root      399:     static const char upgrade_note[] =
                    400:         "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
                    401:         "(see http://sourceforge.net/projects/kvm).\n";
1.1       root      402:     KVMState *s;
                    403:     int ret;
                    404:     int i;
                    405: 
1.1.1.4   root      406:     if (smp_cpus > 1) {
                    407:         fprintf(stderr, "No SMP KVM support, use '-smp 1'\n");
1.1       root      408:         return -EINVAL;
1.1.1.4   root      409:     }
1.1       root      410: 
                    411:     s = qemu_mallocz(sizeof(KVMState));
                    412: 
1.1.1.5   root      413: #ifdef KVM_CAP_SET_GUEST_DEBUG
1.1.1.7 ! root      414:     QTAILQ_INIT(&s->kvm_sw_breakpoints);
1.1.1.5   root      415: #endif
1.1       root      416:     for (i = 0; i < ARRAY_SIZE(s->slots); i++)
                    417:         s->slots[i].slot = i;
                    418: 
                    419:     s->vmfd = -1;
1.1.1.7 ! root      420:     s->fd = qemu_open("/dev/kvm", O_RDWR);
1.1       root      421:     if (s->fd == -1) {
                    422:         fprintf(stderr, "Could not access KVM kernel module: %m\n");
                    423:         ret = -errno;
                    424:         goto err;
                    425:     }
                    426: 
                    427:     ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
                    428:     if (ret < KVM_API_VERSION) {
                    429:         if (ret > 0)
                    430:             ret = -EINVAL;
                    431:         fprintf(stderr, "kvm version too old\n");
                    432:         goto err;
                    433:     }
                    434: 
                    435:     if (ret > KVM_API_VERSION) {
                    436:         ret = -EINVAL;
                    437:         fprintf(stderr, "kvm version not supported\n");
                    438:         goto err;
                    439:     }
                    440: 
                    441:     s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
                    442:     if (s->vmfd < 0)
                    443:         goto err;
                    444: 
                    445:     /* initially, KVM allocated its own memory and we had to jump through
                    446:      * hooks to make phys_ram_base point to this.  Modern versions of KVM
1.1.1.5   root      447:      * just use a user allocated buffer so we can use regular pages
1.1       root      448:      * unmodified.  Make sure we have a sufficiently modern version of KVM.
                    449:      */
1.1.1.4   root      450:     if (!kvm_check_extension(s, KVM_CAP_USER_MEMORY)) {
                    451:         ret = -EINVAL;
1.1.1.5   root      452:         fprintf(stderr, "kvm does not support KVM_CAP_USER_MEMORY\n%s",
                    453:                 upgrade_note);
1.1       root      454:         goto err;
                    455:     }
                    456: 
                    457:     /* There was a nasty bug in < kvm-80 that prevents memory slots from being
                    458:      * destroyed properly.  Since we rely on this capability, refuse to work
                    459:      * with any kernel without this capability. */
1.1.1.4   root      460:     if (!kvm_check_extension(s, KVM_CAP_DESTROY_MEMORY_REGION_WORKS)) {
                    461:         ret = -EINVAL;
1.1       root      462: 
                    463:         fprintf(stderr,
1.1.1.5   root      464:                 "KVM kernel module broken (DESTROY_MEMORY_REGION).\n%s",
                    465:                 upgrade_note);
1.1       root      466:         goto err;
                    467:     }
                    468: 
                    469: #ifdef KVM_CAP_COALESCED_MMIO
1.1.1.4   root      470:     s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
                    471: #else
                    472:     s->coalesced_mmio = 0;
1.1       root      473: #endif
                    474: 
1.1.1.5   root      475:     s->broken_set_mem_region = 1;
                    476: #ifdef KVM_CAP_JOIN_MEMORY_REGIONS_WORKS
                    477:     ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
                    478:     if (ret > 0) {
                    479:         s->broken_set_mem_region = 0;
                    480:     }
                    481: #endif
                    482: 
1.1.1.7 ! root      483:     s->vcpu_events = 0;
        !           484: #ifdef KVM_CAP_VCPU_EVENTS
        !           485:     s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
        !           486: #endif
        !           487: 
1.1       root      488:     ret = kvm_arch_init(s, smp_cpus);
                    489:     if (ret < 0)
                    490:         goto err;
                    491: 
                    492:     kvm_state = s;
                    493: 
                    494:     return 0;
                    495: 
                    496: err:
                    497:     if (s) {
                    498:         if (s->vmfd != -1)
                    499:             close(s->vmfd);
                    500:         if (s->fd != -1)
                    501:             close(s->fd);
                    502:     }
                    503:     qemu_free(s);
                    504: 
                    505:     return ret;
                    506: }
                    507: 
1.1.1.7 ! root      508: static int kvm_handle_io(uint16_t port, void *data, int direction, int size,
        !           509:                          uint32_t count)
1.1       root      510: {
                    511:     int i;
                    512:     uint8_t *ptr = data;
                    513: 
                    514:     for (i = 0; i < count; i++) {
                    515:         if (direction == KVM_EXIT_IO_IN) {
                    516:             switch (size) {
                    517:             case 1:
1.1.1.7 ! root      518:                 stb_p(ptr, cpu_inb(port));
1.1       root      519:                 break;
                    520:             case 2:
1.1.1.7 ! root      521:                 stw_p(ptr, cpu_inw(port));
1.1       root      522:                 break;
                    523:             case 4:
1.1.1.7 ! root      524:                 stl_p(ptr, cpu_inl(port));
1.1       root      525:                 break;
                    526:             }
                    527:         } else {
                    528:             switch (size) {
                    529:             case 1:
1.1.1.7 ! root      530:                 cpu_outb(port, ldub_p(ptr));
1.1       root      531:                 break;
                    532:             case 2:
1.1.1.7 ! root      533:                 cpu_outw(port, lduw_p(ptr));
1.1       root      534:                 break;
                    535:             case 4:
1.1.1.7 ! root      536:                 cpu_outl(port, ldl_p(ptr));
1.1       root      537:                 break;
                    538:             }
                    539:         }
                    540: 
                    541:         ptr += size;
                    542:     }
                    543: 
                    544:     return 1;
                    545: }
                    546: 
                    547: static void kvm_run_coalesced_mmio(CPUState *env, struct kvm_run *run)
                    548: {
                    549: #ifdef KVM_CAP_COALESCED_MMIO
                    550:     KVMState *s = kvm_state;
                    551:     if (s->coalesced_mmio) {
                    552:         struct kvm_coalesced_mmio_ring *ring;
                    553: 
                    554:         ring = (void *)run + (s->coalesced_mmio * TARGET_PAGE_SIZE);
                    555:         while (ring->first != ring->last) {
                    556:             struct kvm_coalesced_mmio *ent;
                    557: 
                    558:             ent = &ring->coalesced_mmio[ring->first];
                    559: 
                    560:             cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
                    561:             /* FIXME smp_wmb() */
                    562:             ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
                    563:         }
                    564:     }
                    565: #endif
                    566: }
                    567: 
1.1.1.7 ! root      568: void kvm_cpu_synchronize_state(CPUState *env)
        !           569: {
        !           570:     if (!env->kvm_state->regs_modified) {
        !           571:         kvm_arch_get_registers(env);
        !           572:         env->kvm_state->regs_modified = 1;
        !           573:     }
        !           574: }
        !           575: 
1.1       root      576: int kvm_cpu_exec(CPUState *env)
                    577: {
                    578:     struct kvm_run *run = env->kvm_run;
                    579:     int ret;
                    580: 
                    581:     dprintf("kvm_cpu_exec()\n");
                    582: 
                    583:     do {
1.1.1.2   root      584:         if (env->exit_request) {
1.1       root      585:             dprintf("interrupt exit requested\n");
                    586:             ret = 0;
                    587:             break;
                    588:         }
                    589: 
1.1.1.7 ! root      590:         if (env->kvm_state->regs_modified) {
        !           591:             kvm_arch_put_registers(env);
        !           592:             env->kvm_state->regs_modified = 0;
        !           593:         }
        !           594: 
1.1.1.5   root      595:         kvm_arch_pre_run(env, run);
1.1.1.7 ! root      596:         qemu_mutex_unlock_iothread();
1.1       root      597:         ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
1.1.1.7 ! root      598:         qemu_mutex_lock_iothread();
1.1       root      599:         kvm_arch_post_run(env, run);
                    600: 
                    601:         if (ret == -EINTR || ret == -EAGAIN) {
                    602:             dprintf("io window exit\n");
                    603:             ret = 0;
                    604:             break;
                    605:         }
                    606: 
                    607:         if (ret < 0) {
                    608:             dprintf("kvm run failed %s\n", strerror(-ret));
                    609:             abort();
                    610:         }
                    611: 
                    612:         kvm_run_coalesced_mmio(env, run);
                    613: 
                    614:         ret = 0; /* exit loop */
                    615:         switch (run->exit_reason) {
                    616:         case KVM_EXIT_IO:
                    617:             dprintf("handle_io\n");
1.1.1.7 ! root      618:             ret = kvm_handle_io(run->io.port,
1.1       root      619:                                 (uint8_t *)run + run->io.data_offset,
                    620:                                 run->io.direction,
                    621:                                 run->io.size,
                    622:                                 run->io.count);
                    623:             break;
                    624:         case KVM_EXIT_MMIO:
                    625:             dprintf("handle_mmio\n");
                    626:             cpu_physical_memory_rw(run->mmio.phys_addr,
                    627:                                    run->mmio.data,
                    628:                                    run->mmio.len,
                    629:                                    run->mmio.is_write);
                    630:             ret = 1;
                    631:             break;
                    632:         case KVM_EXIT_IRQ_WINDOW_OPEN:
                    633:             dprintf("irq_window_open\n");
                    634:             break;
                    635:         case KVM_EXIT_SHUTDOWN:
                    636:             dprintf("shutdown\n");
                    637:             qemu_system_reset_request();
                    638:             ret = 1;
                    639:             break;
                    640:         case KVM_EXIT_UNKNOWN:
                    641:             dprintf("kvm_exit_unknown\n");
                    642:             break;
                    643:         case KVM_EXIT_FAIL_ENTRY:
                    644:             dprintf("kvm_exit_fail_entry\n");
                    645:             break;
                    646:         case KVM_EXIT_EXCEPTION:
                    647:             dprintf("kvm_exit_exception\n");
                    648:             break;
                    649:         case KVM_EXIT_DEBUG:
                    650:             dprintf("kvm_exit_debug\n");
1.1.1.5   root      651: #ifdef KVM_CAP_SET_GUEST_DEBUG
                    652:             if (kvm_arch_debug(&run->debug.arch)) {
                    653:                 gdb_set_stop_cpu(env);
                    654:                 vm_stop(EXCP_DEBUG);
                    655:                 env->exception_index = EXCP_DEBUG;
                    656:                 return 0;
                    657:             }
                    658:             /* re-enter, this exception was guest-internal */
                    659:             ret = 1;
                    660: #endif /* KVM_CAP_SET_GUEST_DEBUG */
1.1       root      661:             break;
                    662:         default:
                    663:             dprintf("kvm_arch_handle_exit\n");
                    664:             ret = kvm_arch_handle_exit(env, run);
                    665:             break;
                    666:         }
                    667:     } while (ret > 0);
                    668: 
1.1.1.2   root      669:     if (env->exit_request) {
                    670:         env->exit_request = 0;
1.1       root      671:         env->exception_index = EXCP_INTERRUPT;
                    672:     }
                    673: 
                    674:     return ret;
                    675: }
                    676: 
                    677: void kvm_set_phys_mem(target_phys_addr_t start_addr,
                    678:                       ram_addr_t size,
                    679:                       ram_addr_t phys_offset)
                    680: {
                    681:     KVMState *s = kvm_state;
                    682:     ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
1.1.1.5   root      683:     KVMSlot *mem, old;
                    684:     int err;
                    685: 
                    686:     if (start_addr & ~TARGET_PAGE_MASK) {
                    687:         if (flags >= IO_MEM_UNASSIGNED) {
                    688:             if (!kvm_lookup_overlapping_slot(s, start_addr,
                    689:                                              start_addr + size)) {
                    690:                 return;
                    691:             }
                    692:             fprintf(stderr, "Unaligned split of a KVM memory slot\n");
                    693:         } else {
                    694:             fprintf(stderr, "Only page-aligned memory slots supported\n");
                    695:         }
                    696:         abort();
                    697:     }
1.1       root      698: 
                    699:     /* KVM does not support read-only slots */
                    700:     phys_offset &= ~IO_MEM_ROM;
                    701: 
1.1.1.5   root      702:     while (1) {
                    703:         mem = kvm_lookup_overlapping_slot(s, start_addr, start_addr + size);
                    704:         if (!mem) {
                    705:             break;
                    706:         }
1.1       root      707: 
1.1.1.5   root      708:         if (flags < IO_MEM_UNASSIGNED && start_addr >= mem->start_addr &&
                    709:             (start_addr + size <= mem->start_addr + mem->memory_size) &&
                    710:             (phys_offset - start_addr == mem->phys_offset - mem->start_addr)) {
                    711:             /* The new slot fits into the existing one and comes with
                    712:              * identical parameters - nothing to be done. */
                    713:             return;
                    714:         }
1.1       root      715: 
1.1.1.5   root      716:         old = *mem;
1.1       root      717: 
1.1.1.5   root      718:         /* unregister the overlapping slot */
                    719:         mem->memory_size = 0;
                    720:         err = kvm_set_user_memory_region(s, mem);
                    721:         if (err) {
                    722:             fprintf(stderr, "%s: error unregistering overlapping slot: %s\n",
                    723:                     __func__, strerror(-err));
1.1       root      724:             abort();
                    725:         }
1.1.1.5   root      726: 
                    727:         /* Workaround for older KVM versions: we can't join slots, even not by
                    728:          * unregistering the previous ones and then registering the larger
                    729:          * slot. We have to maintain the existing fragmentation. Sigh.
                    730:          *
                    731:          * This workaround assumes that the new slot starts at the same
                    732:          * address as the first existing one. If not or if some overlapping
                    733:          * slot comes around later, we will fail (not seen in practice so far)
                    734:          * - and actually require a recent KVM version. */
                    735:         if (s->broken_set_mem_region &&
                    736:             old.start_addr == start_addr && old.memory_size < size &&
                    737:             flags < IO_MEM_UNASSIGNED) {
                    738:             mem = kvm_alloc_slot(s);
                    739:             mem->memory_size = old.memory_size;
                    740:             mem->start_addr = old.start_addr;
                    741:             mem->phys_offset = old.phys_offset;
                    742:             mem->flags = 0;
                    743: 
                    744:             err = kvm_set_user_memory_region(s, mem);
                    745:             if (err) {
                    746:                 fprintf(stderr, "%s: error updating slot: %s\n", __func__,
                    747:                         strerror(-err));
                    748:                 abort();
                    749:             }
                    750: 
                    751:             start_addr += old.memory_size;
                    752:             phys_offset += old.memory_size;
                    753:             size -= old.memory_size;
                    754:             continue;
                    755:         }
                    756: 
                    757:         /* register prefix slot */
                    758:         if (old.start_addr < start_addr) {
                    759:             mem = kvm_alloc_slot(s);
                    760:             mem->memory_size = start_addr - old.start_addr;
                    761:             mem->start_addr = old.start_addr;
                    762:             mem->phys_offset = old.phys_offset;
                    763:             mem->flags = 0;
                    764: 
                    765:             err = kvm_set_user_memory_region(s, mem);
                    766:             if (err) {
                    767:                 fprintf(stderr, "%s: error registering prefix slot: %s\n",
                    768:                         __func__, strerror(-err));
                    769:                 abort();
                    770:             }
                    771:         }
                    772: 
                    773:         /* register suffix slot */
                    774:         if (old.start_addr + old.memory_size > start_addr + size) {
                    775:             ram_addr_t size_delta;
                    776: 
                    777:             mem = kvm_alloc_slot(s);
                    778:             mem->start_addr = start_addr + size;
                    779:             size_delta = mem->start_addr - old.start_addr;
                    780:             mem->memory_size = old.memory_size - size_delta;
                    781:             mem->phys_offset = old.phys_offset + size_delta;
                    782:             mem->flags = 0;
                    783: 
                    784:             err = kvm_set_user_memory_region(s, mem);
                    785:             if (err) {
                    786:                 fprintf(stderr, "%s: error registering suffix slot: %s\n",
                    787:                         __func__, strerror(-err));
                    788:                 abort();
                    789:             }
                    790:         }
1.1       root      791:     }
1.1.1.5   root      792: 
                    793:     /* in case the KVM bug workaround already "consumed" the new slot */
                    794:     if (!size)
                    795:         return;
                    796: 
1.1       root      797:     /* KVM does not need to know about this memory */
                    798:     if (flags >= IO_MEM_UNASSIGNED)
                    799:         return;
                    800: 
                    801:     mem = kvm_alloc_slot(s);
                    802:     mem->memory_size = size;
                    803:     mem->start_addr = start_addr;
                    804:     mem->phys_offset = phys_offset;
                    805:     mem->flags = 0;
                    806: 
1.1.1.5   root      807:     err = kvm_set_user_memory_region(s, mem);
                    808:     if (err) {
                    809:         fprintf(stderr, "%s: error registering slot: %s\n", __func__,
                    810:                 strerror(-err));
                    811:         abort();
                    812:     }
1.1       root      813: }
                    814: 
                    815: int kvm_ioctl(KVMState *s, int type, ...)
                    816: {
                    817:     int ret;
                    818:     void *arg;
                    819:     va_list ap;
                    820: 
                    821:     va_start(ap, type);
                    822:     arg = va_arg(ap, void *);
                    823:     va_end(ap);
                    824: 
                    825:     ret = ioctl(s->fd, type, arg);
                    826:     if (ret == -1)
                    827:         ret = -errno;
                    828: 
                    829:     return ret;
                    830: }
                    831: 
                    832: int kvm_vm_ioctl(KVMState *s, int type, ...)
                    833: {
                    834:     int ret;
                    835:     void *arg;
                    836:     va_list ap;
                    837: 
                    838:     va_start(ap, type);
                    839:     arg = va_arg(ap, void *);
                    840:     va_end(ap);
                    841: 
                    842:     ret = ioctl(s->vmfd, type, arg);
                    843:     if (ret == -1)
                    844:         ret = -errno;
                    845: 
                    846:     return ret;
                    847: }
                    848: 
                    849: int kvm_vcpu_ioctl(CPUState *env, int type, ...)
                    850: {
                    851:     int ret;
                    852:     void *arg;
                    853:     va_list ap;
                    854: 
                    855:     va_start(ap, type);
                    856:     arg = va_arg(ap, void *);
                    857:     va_end(ap);
                    858: 
                    859:     ret = ioctl(env->kvm_fd, type, arg);
                    860:     if (ret == -1)
                    861:         ret = -errno;
                    862: 
                    863:     return ret;
                    864: }
                    865: 
                    866: int kvm_has_sync_mmu(void)
                    867: {
                    868: #ifdef KVM_CAP_SYNC_MMU
                    869:     KVMState *s = kvm_state;
                    870: 
1.1.1.4   root      871:     return kvm_check_extension(s, KVM_CAP_SYNC_MMU);
                    872: #else
1.1       root      873:     return 0;
1.1.1.4   root      874: #endif
1.1       root      875: }
1.1.1.3   root      876: 
1.1.1.7 ! root      877: int kvm_has_vcpu_events(void)
        !           878: {
        !           879:     return kvm_state->vcpu_events;
        !           880: }
        !           881: 
1.1.1.3   root      882: void kvm_setup_guest_memory(void *start, size_t size)
                    883: {
                    884:     if (!kvm_has_sync_mmu()) {
                    885: #ifdef MADV_DONTFORK
                    886:         int ret = madvise(start, size, MADV_DONTFORK);
                    887: 
                    888:         if (ret) {
                    889:             perror("madvice");
                    890:             exit(1);
                    891:         }
                    892: #else
                    893:         fprintf(stderr,
                    894:                 "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
                    895:         exit(1);
                    896: #endif
                    897:     }
                    898: }
1.1.1.5   root      899: 
                    900: #ifdef KVM_CAP_SET_GUEST_DEBUG
1.1.1.7 ! root      901: static void on_vcpu(CPUState *env, void (*func)(void *data), void *data)
        !           902: {
        !           903: #ifdef CONFIG_IOTHREAD
        !           904:     if (env == cpu_single_env) {
        !           905:         func(data);
        !           906:         return;
        !           907:     }
        !           908:     abort();
        !           909: #else
        !           910:     func(data);
        !           911: #endif
        !           912: }
        !           913: 
1.1.1.5   root      914: struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
                    915:                                                  target_ulong pc)
                    916: {
                    917:     struct kvm_sw_breakpoint *bp;
                    918: 
1.1.1.7 ! root      919:     QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) {
1.1.1.5   root      920:         if (bp->pc == pc)
                    921:             return bp;
                    922:     }
                    923:     return NULL;
                    924: }
                    925: 
                    926: int kvm_sw_breakpoints_active(CPUState *env)
                    927: {
1.1.1.7 ! root      928:     return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints);
        !           929: }
        !           930: 
        !           931: struct kvm_set_guest_debug_data {
        !           932:     struct kvm_guest_debug dbg;
        !           933:     CPUState *env;
        !           934:     int err;
        !           935: };
        !           936: 
        !           937: static void kvm_invoke_set_guest_debug(void *data)
        !           938: {
        !           939:     struct kvm_set_guest_debug_data *dbg_data = data;
        !           940:     CPUState *env = dbg_data->env;
        !           941: 
        !           942:     if (env->kvm_state->regs_modified) {
        !           943:         kvm_arch_put_registers(env);
        !           944:         env->kvm_state->regs_modified = 0;
        !           945:     }
        !           946:     dbg_data->err = kvm_vcpu_ioctl(env, KVM_SET_GUEST_DEBUG, &dbg_data->dbg);
1.1.1.5   root      947: }
                    948: 
                    949: int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
                    950: {
1.1.1.7 ! root      951:     struct kvm_set_guest_debug_data data;
1.1.1.5   root      952: 
1.1.1.7 ! root      953:     data.dbg.control = 0;
1.1.1.5   root      954:     if (env->singlestep_enabled)
1.1.1.7 ! root      955:         data.dbg.control = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
1.1.1.5   root      956: 
1.1.1.7 ! root      957:     kvm_arch_update_guest_debug(env, &data.dbg);
        !           958:     data.dbg.control |= reinject_trap;
        !           959:     data.env = env;
1.1.1.5   root      960: 
1.1.1.7 ! root      961:     on_vcpu(env, kvm_invoke_set_guest_debug, &data);
        !           962:     return data.err;
1.1.1.5   root      963: }
                    964: 
                    965: int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
                    966:                           target_ulong len, int type)
                    967: {
                    968:     struct kvm_sw_breakpoint *bp;
                    969:     CPUState *env;
                    970:     int err;
                    971: 
                    972:     if (type == GDB_BREAKPOINT_SW) {
                    973:         bp = kvm_find_sw_breakpoint(current_env, addr);
                    974:         if (bp) {
                    975:             bp->use_count++;
                    976:             return 0;
                    977:         }
                    978: 
                    979:         bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
                    980:         if (!bp)
                    981:             return -ENOMEM;
                    982: 
                    983:         bp->pc = addr;
                    984:         bp->use_count = 1;
                    985:         err = kvm_arch_insert_sw_breakpoint(current_env, bp);
                    986:         if (err) {
                    987:             free(bp);
                    988:             return err;
                    989:         }
                    990: 
1.1.1.7 ! root      991:         QTAILQ_INSERT_HEAD(&current_env->kvm_state->kvm_sw_breakpoints,
1.1.1.5   root      992:                           bp, entry);
                    993:     } else {
                    994:         err = kvm_arch_insert_hw_breakpoint(addr, len, type);
                    995:         if (err)
                    996:             return err;
                    997:     }
                    998: 
                    999:     for (env = first_cpu; env != NULL; env = env->next_cpu) {
                   1000:         err = kvm_update_guest_debug(env, 0);
                   1001:         if (err)
                   1002:             return err;
                   1003:     }
                   1004:     return 0;
                   1005: }
                   1006: 
                   1007: int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
                   1008:                           target_ulong len, int type)
                   1009: {
                   1010:     struct kvm_sw_breakpoint *bp;
                   1011:     CPUState *env;
                   1012:     int err;
                   1013: 
                   1014:     if (type == GDB_BREAKPOINT_SW) {
                   1015:         bp = kvm_find_sw_breakpoint(current_env, addr);
                   1016:         if (!bp)
                   1017:             return -ENOENT;
                   1018: 
                   1019:         if (bp->use_count > 1) {
                   1020:             bp->use_count--;
                   1021:             return 0;
                   1022:         }
                   1023: 
                   1024:         err = kvm_arch_remove_sw_breakpoint(current_env, bp);
                   1025:         if (err)
                   1026:             return err;
                   1027: 
1.1.1.7 ! root     1028:         QTAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry);
1.1.1.5   root     1029:         qemu_free(bp);
                   1030:     } else {
                   1031:         err = kvm_arch_remove_hw_breakpoint(addr, len, type);
                   1032:         if (err)
                   1033:             return err;
                   1034:     }
                   1035: 
                   1036:     for (env = first_cpu; env != NULL; env = env->next_cpu) {
                   1037:         err = kvm_update_guest_debug(env, 0);
                   1038:         if (err)
                   1039:             return err;
                   1040:     }
                   1041:     return 0;
                   1042: }
                   1043: 
                   1044: void kvm_remove_all_breakpoints(CPUState *current_env)
                   1045: {
                   1046:     struct kvm_sw_breakpoint *bp, *next;
                   1047:     KVMState *s = current_env->kvm_state;
                   1048:     CPUState *env;
                   1049: 
1.1.1.7 ! root     1050:     QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
1.1.1.5   root     1051:         if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
                   1052:             /* Try harder to find a CPU that currently sees the breakpoint. */
                   1053:             for (env = first_cpu; env != NULL; env = env->next_cpu) {
                   1054:                 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0)
                   1055:                     break;
                   1056:             }
                   1057:         }
                   1058:     }
                   1059:     kvm_arch_remove_all_hw_breakpoints();
                   1060: 
                   1061:     for (env = first_cpu; env != NULL; env = env->next_cpu)
                   1062:         kvm_update_guest_debug(env, 0);
                   1063: }
                   1064: 
                   1065: #else /* !KVM_CAP_SET_GUEST_DEBUG */
                   1066: 
                   1067: int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
                   1068: {
                   1069:     return -EINVAL;
                   1070: }
                   1071: 
                   1072: int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
                   1073:                           target_ulong len, int type)
                   1074: {
                   1075:     return -EINVAL;
                   1076: }
                   1077: 
                   1078: int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
                   1079:                           target_ulong len, int type)
                   1080: {
                   1081:     return -EINVAL;
                   1082: }
                   1083: 
                   1084: void kvm_remove_all_breakpoints(CPUState *current_env)
                   1085: {
                   1086: }
                   1087: #endif /* !KVM_CAP_SET_GUEST_DEBUG */

unix.superglobalmegacorp.com