2008-11-05 17:29:27 +01:00
|
|
|
/*
|
|
|
|
* QEMU KVM support
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2008
|
2008-11-24 20:36:26 +01:00
|
|
|
* Red Hat, Inc. 2008
|
2008-11-05 17:29:27 +01:00
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
2008-11-24 20:36:26 +01:00
|
|
|
* Glauber Costa <gcosta@redhat.com>
|
2008-11-05 17:29:27 +01:00
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/mman.h>
|
2008-11-13 20:21:00 +01:00
|
|
|
#include <stdarg.h>
|
2008-11-05 17:29:27 +01:00
|
|
|
|
|
|
|
#include <linux/kvm.h>
|
|
|
|
|
|
|
|
#include "qemu-common.h"
|
2010-02-22 17:57:54 +01:00
|
|
|
#include "qemu-barrier.h"
|
2008-11-05 17:29:27 +01:00
|
|
|
#include "sysemu.h"
|
2009-05-02 00:29:37 +02:00
|
|
|
#include "hw/hw.h"
|
2009-03-12 21:12:48 +01:00
|
|
|
#include "gdbstub.h"
|
2008-11-05 17:29:27 +01:00
|
|
|
#include "kvm.h"
|
2010-04-23 19:04:14 +02:00
|
|
|
#include "bswap.h"
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2011-01-10 12:50:05 +01:00
|
|
|
/* This check must be after config-host.h is included */
|
|
|
|
#ifdef CONFIG_EVENTFD
|
|
|
|
#include <sys/eventfd.h>
|
|
|
|
#endif
|
|
|
|
|
2008-12-09 21:09:57 +01:00
|
|
|
/* KVM uses PAGE_SIZE in it's definition of COALESCED_MMIO_MAX */
|
|
|
|
#define PAGE_SIZE TARGET_PAGE_SIZE
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
//#define DEBUG_KVM
|
|
|
|
|
|
|
|
#ifdef DEBUG_KVM
|
2010-04-18 16:22:14 +02:00
|
|
|
#define DPRINTF(fmt, ...) \
|
2008-11-05 17:29:27 +01:00
|
|
|
do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
|
|
|
|
#else
|
2010-04-18 16:22:14 +02:00
|
|
|
#define DPRINTF(fmt, ...) \
|
2008-11-05 17:29:27 +01:00
|
|
|
do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2008-11-19 18:41:58 +01:00
|
|
|
typedef struct KVMSlot
|
|
|
|
{
|
2009-10-01 23:12:16 +02:00
|
|
|
target_phys_addr_t start_addr;
|
|
|
|
ram_addr_t memory_size;
|
|
|
|
ram_addr_t phys_offset;
|
2008-11-19 18:41:58 +01:00
|
|
|
int slot;
|
|
|
|
int flags;
|
|
|
|
} KVMSlot;
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2008-11-24 20:36:26 +01:00
|
|
|
typedef struct kvm_dirty_log KVMDirtyLog;
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
struct KVMState
|
|
|
|
{
|
|
|
|
KVMSlot slots[32];
|
|
|
|
int fd;
|
|
|
|
int vmfd;
|
2008-12-09 21:09:57 +01:00
|
|
|
int coalesced_mmio;
|
2010-01-26 12:21:16 +01:00
|
|
|
struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
|
2009-05-01 20:42:15 +02:00
|
|
|
int broken_set_mem_region;
|
2009-05-01 20:52:46 +02:00
|
|
|
int migration_log;
|
2009-11-25 00:33:03 +01:00
|
|
|
int vcpu_events;
|
2010-03-01 19:10:29 +01:00
|
|
|
int robust_singlestep;
|
2010-03-12 15:20:49 +01:00
|
|
|
int debugregs;
|
2009-03-12 21:12:48 +01:00
|
|
|
#ifdef KVM_CAP_SET_GUEST_DEBUG
|
|
|
|
struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
|
|
|
|
#endif
|
2009-07-21 17:26:58 +02:00
|
|
|
int irqchip_in_kernel;
|
|
|
|
int pit_in_kernel;
|
2010-06-17 11:53:07 +02:00
|
|
|
int xsave, xcrs;
|
2011-01-10 12:50:05 +01:00
|
|
|
int many_ioeventfds;
|
2008-11-05 17:29:27 +01:00
|
|
|
};
|
|
|
|
|
2011-02-07 12:19:25 +01:00
|
|
|
KVMState *kvm_state;
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2011-01-21 21:48:17 +01:00
|
|
|
static const KVMCapabilityInfo kvm_required_capabilites[] = {
|
|
|
|
KVM_CAP_INFO(USER_MEMORY),
|
|
|
|
KVM_CAP_INFO(DESTROY_MEMORY_REGION_WORKS),
|
|
|
|
KVM_CAP_LAST_INFO
|
|
|
|
};
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
static KVMSlot *kvm_alloc_slot(KVMState *s)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
|
2011-01-04 09:32:13 +01:00
|
|
|
if (s->slots[i].memory_size == 0) {
|
2008-11-05 17:29:27 +01:00
|
|
|
return &s->slots[i];
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
}
|
|
|
|
|
2009-04-17 16:26:29 +02:00
|
|
|
fprintf(stderr, "%s: no free slot available\n", __func__);
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
static KVMSlot *kvm_lookup_matching_slot(KVMState *s,
|
2009-10-01 23:12:16 +02:00
|
|
|
target_phys_addr_t start_addr,
|
|
|
|
target_phys_addr_t end_addr)
|
2009-04-17 16:26:29 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
|
|
|
|
KVMSlot *mem = &s->slots[i];
|
|
|
|
|
|
|
|
if (start_addr == mem->start_addr &&
|
|
|
|
end_addr == mem->start_addr + mem->memory_size) {
|
|
|
|
return mem;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-04-17 16:26:33 +02:00
|
|
|
/*
|
|
|
|
* Find overlapping slot with lowest start address
|
|
|
|
*/
|
|
|
|
static KVMSlot *kvm_lookup_overlapping_slot(KVMState *s,
|
2009-10-01 23:12:16 +02:00
|
|
|
target_phys_addr_t start_addr,
|
|
|
|
target_phys_addr_t end_addr)
|
2008-11-05 17:29:27 +01:00
|
|
|
{
|
2009-04-17 16:26:33 +02:00
|
|
|
KVMSlot *found = NULL;
|
2008-11-05 17:29:27 +01:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
|
|
|
|
KVMSlot *mem = &s->slots[i];
|
|
|
|
|
2009-04-17 16:26:33 +02:00
|
|
|
if (mem->memory_size == 0 ||
|
|
|
|
(found && found->start_addr < mem->start_addr)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (end_addr > mem->start_addr &&
|
|
|
|
start_addr < mem->start_addr + mem->memory_size) {
|
|
|
|
found = mem;
|
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
}
|
|
|
|
|
2009-04-17 16:26:33 +02:00
|
|
|
return found;
|
2008-11-05 17:29:27 +01:00
|
|
|
}
|
|
|
|
|
2010-10-11 20:31:20 +02:00
|
|
|
int kvm_physical_memory_addr_from_ram(KVMState *s, ram_addr_t ram_addr,
|
|
|
|
target_phys_addr_t *phys_addr)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
|
|
|
|
KVMSlot *mem = &s->slots[i];
|
|
|
|
|
|
|
|
if (ram_addr >= mem->phys_offset &&
|
|
|
|
ram_addr < mem->phys_offset + mem->memory_size) {
|
|
|
|
*phys_addr = mem->start_addr + (ram_addr - mem->phys_offset);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-24 20:36:26 +01:00
|
|
|
static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
|
|
|
|
{
|
|
|
|
struct kvm_userspace_memory_region mem;
|
|
|
|
|
|
|
|
mem.slot = slot->slot;
|
|
|
|
mem.guest_phys_addr = slot->start_addr;
|
|
|
|
mem.memory_size = slot->memory_size;
|
2010-11-22 18:52:34 +01:00
|
|
|
mem.userspace_addr = (unsigned long)qemu_safe_ram_ptr(slot->phys_offset);
|
2008-11-24 20:36:26 +01:00
|
|
|
mem.flags = slot->flags;
|
2009-05-01 20:52:46 +02:00
|
|
|
if (s->migration_log) {
|
|
|
|
mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
|
|
|
|
}
|
2008-11-24 20:36:26 +01:00
|
|
|
return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
|
|
|
|
}
|
|
|
|
|
2009-06-27 09:24:58 +02:00
|
|
|
static void kvm_reset_vcpu(void *opaque)
|
|
|
|
{
|
|
|
|
CPUState *env = opaque;
|
|
|
|
|
2009-11-06 19:39:24 +01:00
|
|
|
kvm_arch_reset_vcpu(env);
|
2009-06-27 09:24:58 +02:00
|
|
|
}
|
2008-11-24 20:36:26 +01:00
|
|
|
|
2009-07-21 17:26:58 +02:00
|
|
|
int kvm_irqchip_in_kernel(void)
|
|
|
|
{
|
|
|
|
return kvm_state->irqchip_in_kernel;
|
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_pit_in_kernel(void)
|
|
|
|
{
|
|
|
|
return kvm_state->pit_in_kernel;
|
|
|
|
}
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
int kvm_init_vcpu(CPUState *env)
|
|
|
|
{
|
|
|
|
KVMState *s = kvm_state;
|
|
|
|
long mmap_size;
|
|
|
|
int ret;
|
|
|
|
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("kvm_init_vcpu\n");
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
|
2008-11-05 17:29:27 +01:00
|
|
|
if (ret < 0) {
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("kvm_create_vcpu failed\n");
|
2008-11-05 17:29:27 +01:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
env->kvm_fd = ret;
|
|
|
|
env->kvm_state = s;
|
2011-03-15 12:26:20 +01:00
|
|
|
env->kvm_vcpu_dirty = 1;
|
2008-11-05 17:29:27 +01:00
|
|
|
|
|
|
|
mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
|
|
|
|
if (mmap_size < 0) {
|
2011-02-01 22:15:48 +01:00
|
|
|
ret = mmap_size;
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
|
2008-11-05 17:29:27 +01:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
env->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
|
|
|
|
env->kvm_fd, 0);
|
|
|
|
if (env->kvm_run == MAP_FAILED) {
|
|
|
|
ret = -errno;
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("mmap'ing vcpu state failed\n");
|
2008-11-05 17:29:27 +01:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2011-01-04 09:32:13 +01:00
|
|
|
if (s->coalesced_mmio && !s->coalesced_mmio_ring) {
|
|
|
|
s->coalesced_mmio_ring =
|
|
|
|
(void *)env->kvm_run + s->coalesced_mmio * PAGE_SIZE;
|
|
|
|
}
|
2010-01-26 12:21:16 +01:00
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
ret = kvm_arch_init_vcpu(env);
|
2009-06-27 09:24:58 +02:00
|
|
|
if (ret == 0) {
|
2009-06-27 09:25:07 +02:00
|
|
|
qemu_register_reset(kvm_reset_vcpu, env);
|
2009-11-06 19:39:24 +01:00
|
|
|
kvm_arch_reset_vcpu(env);
|
2009-06-27 09:24:58 +02:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
err:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-24 20:36:26 +01:00
|
|
|
/*
|
|
|
|
* dirty pages logging control
|
|
|
|
*/
|
2009-10-01 23:12:16 +02:00
|
|
|
static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,
|
|
|
|
ram_addr_t size, int flags, int mask)
|
2008-11-24 20:36:26 +01:00
|
|
|
{
|
|
|
|
KVMState *s = kvm_state;
|
2009-04-17 16:26:29 +02:00
|
|
|
KVMSlot *mem = kvm_lookup_matching_slot(s, phys_addr, phys_addr + size);
|
2009-05-01 20:52:46 +02:00
|
|
|
int old_flags;
|
|
|
|
|
2008-11-24 20:36:26 +01:00
|
|
|
if (mem == NULL) {
|
2009-04-17 16:26:29 +02:00
|
|
|
fprintf(stderr, "BUG: %s: invalid parameters " TARGET_FMT_plx "-"
|
|
|
|
TARGET_FMT_plx "\n", __func__, phys_addr,
|
2009-10-01 23:12:16 +02:00
|
|
|
(target_phys_addr_t)(phys_addr + size - 1));
|
2008-11-24 20:36:26 +01:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-05-01 20:52:46 +02:00
|
|
|
old_flags = mem->flags;
|
2008-11-24 20:36:26 +01:00
|
|
|
|
2009-05-01 20:52:46 +02:00
|
|
|
flags = (mem->flags & ~mask) | flags;
|
2008-11-24 20:36:26 +01:00
|
|
|
mem->flags = flags;
|
|
|
|
|
2009-05-01 20:52:46 +02:00
|
|
|
/* If nothing changed effectively, no need to issue ioctl */
|
|
|
|
if (s->migration_log) {
|
|
|
|
flags |= KVM_MEM_LOG_DIRTY_PAGES;
|
|
|
|
}
|
|
|
|
if (flags == old_flags) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-24 20:36:26 +01:00
|
|
|
return kvm_set_user_memory_region(s, mem);
|
|
|
|
}
|
|
|
|
|
2011-02-07 12:19:23 +01:00
|
|
|
static int kvm_log_start(CPUPhysMemoryClient *client,
|
|
|
|
target_phys_addr_t phys_addr, ram_addr_t size)
|
2008-11-24 20:36:26 +01:00
|
|
|
{
|
2011-01-04 09:32:13 +01:00
|
|
|
return kvm_dirty_pages_log_change(phys_addr, size, KVM_MEM_LOG_DIRTY_PAGES,
|
|
|
|
KVM_MEM_LOG_DIRTY_PAGES);
|
2008-11-24 20:36:26 +01:00
|
|
|
}
|
|
|
|
|
2011-02-07 12:19:23 +01:00
|
|
|
static int kvm_log_stop(CPUPhysMemoryClient *client,
|
|
|
|
target_phys_addr_t phys_addr, ram_addr_t size)
|
2008-11-24 20:36:26 +01:00
|
|
|
{
|
2011-01-04 09:32:13 +01:00
|
|
|
return kvm_dirty_pages_log_change(phys_addr, size, 0,
|
|
|
|
KVM_MEM_LOG_DIRTY_PAGES);
|
2008-11-24 20:36:26 +01:00
|
|
|
}
|
|
|
|
|
2010-01-27 21:07:21 +01:00
|
|
|
static int kvm_set_migration_log(int enable)
|
2009-05-01 20:52:46 +02:00
|
|
|
{
|
|
|
|
KVMState *s = kvm_state;
|
|
|
|
KVMSlot *mem;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
s->migration_log = enable;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
|
|
|
|
mem = &s->slots[i];
|
|
|
|
|
2010-07-14 21:36:49 +02:00
|
|
|
if (!mem->memory_size) {
|
|
|
|
continue;
|
|
|
|
}
|
2009-05-01 20:52:46 +02:00
|
|
|
if (!!(mem->flags & KVM_MEM_LOG_DIRTY_PAGES) == enable) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
err = kvm_set_user_memory_region(s, mem);
|
|
|
|
if (err) {
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-23 19:04:14 +02:00
|
|
|
/* get kvm's dirty pages bitmap and update qemu's */
|
|
|
|
static int kvm_get_dirty_pages_log_range(unsigned long start_addr,
|
|
|
|
unsigned long *bitmap,
|
|
|
|
unsigned long offset,
|
|
|
|
unsigned long mem_size)
|
2009-07-27 12:49:56 +02:00
|
|
|
{
|
2010-04-23 19:04:14 +02:00
|
|
|
unsigned int i, j;
|
|
|
|
unsigned long page_number, addr, addr1, c;
|
|
|
|
ram_addr_t ram_addr;
|
|
|
|
unsigned int len = ((mem_size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) /
|
|
|
|
HOST_LONG_BITS;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bitmap-traveling is faster than memory-traveling (for addr...)
|
|
|
|
* especially when most of the memory is not dirty.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if (bitmap[i] != 0) {
|
|
|
|
c = leul_to_cpu(bitmap[i]);
|
|
|
|
do {
|
|
|
|
j = ffsl(c) - 1;
|
|
|
|
c &= ~(1ul << j);
|
|
|
|
page_number = i * HOST_LONG_BITS + j;
|
|
|
|
addr1 = page_number * TARGET_PAGE_SIZE;
|
|
|
|
addr = offset + addr1;
|
|
|
|
ram_addr = cpu_get_physical_page_desc(addr);
|
|
|
|
cpu_physical_memory_set_dirty(ram_addr);
|
|
|
|
} while (c != 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
2009-07-27 12:49:56 +02:00
|
|
|
}
|
|
|
|
|
2010-04-23 19:04:14 +02:00
|
|
|
#define ALIGN(x, y) (((x)+(y)-1) & ~((y)-1))
|
|
|
|
|
2008-11-24 20:36:26 +01:00
|
|
|
/**
|
|
|
|
* kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
|
|
|
|
* This function updates qemu's dirty bitmap using cpu_physical_memory_set_dirty().
|
|
|
|
* This means all bits are set to dirty.
|
|
|
|
*
|
2009-04-17 16:26:29 +02:00
|
|
|
* @start_add: start of logged region.
|
2008-11-24 20:36:26 +01:00
|
|
|
* @end_addr: end of logged region.
|
|
|
|
*/
|
2010-01-27 21:07:21 +01:00
|
|
|
static int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
|
2011-01-04 09:32:13 +01:00
|
|
|
target_phys_addr_t end_addr)
|
2008-11-24 20:36:26 +01:00
|
|
|
{
|
|
|
|
KVMState *s = kvm_state;
|
2009-05-01 20:52:47 +02:00
|
|
|
unsigned long size, allocated_size = 0;
|
|
|
|
KVMDirtyLog d;
|
|
|
|
KVMSlot *mem;
|
|
|
|
int ret = 0;
|
2008-11-24 20:36:26 +01:00
|
|
|
|
2009-05-01 20:52:47 +02:00
|
|
|
d.dirty_bitmap = NULL;
|
|
|
|
while (start_addr < end_addr) {
|
|
|
|
mem = kvm_lookup_overlapping_slot(s, start_addr, end_addr);
|
|
|
|
if (mem == NULL) {
|
|
|
|
break;
|
|
|
|
}
|
2008-11-24 20:36:26 +01:00
|
|
|
|
fix crash in migration, 32-bit userspace on 64-bit host
This change fixes a long-standing immediate crash (memory corruption
and abort in glibc malloc code) in migration on 32bits.
The bug is present since this commit:
commit 692d9aca97b865b0f7903565274a52606910f129
Author: Bruce Rogers <brogers@novell.com>
Date: Wed Sep 23 16:13:18 2009 -0600
qemu-kvm: allocate correct size for dirty bitmap
The dirty bitmap copied out to userspace is stored in a long array,
and gets copied out to userspace accordingly. This patch accounts
for that correctly. Currently I'm seeing kvm crashing due to writing
beyond the end of the alloc'd dirty bitmap memory, because the buffer
has the wrong size.
Signed-off-by: Bruce Rogers
Signed-off-by: Marcelo Tosatti <mtosatti@redhat.com>
--- a/qemu-kvm.c
+++ b/qemu-kvm.c
@@ int kvm_get_dirty_pages_range(kvm_context_t kvm, unsigned long phys_addr,
- buf = qemu_malloc((slots[i].len / 4096 + 7) / 8 + 2);
+ buf = qemu_malloc(BITMAP_SIZE(slots[i].len));
r = kvm_get_map(kvm, KVM_GET_DIRTY_LOG, i, buf);
BITMAP_SIZE is now open-coded in that function, like this:
size = ALIGN(((mem->memory_size) >> TARGET_PAGE_BITS), HOST_LONG_BITS) / 8;
The problem is that HOST_LONG_BITS in 32bit userspace is 32
but it's 64 in 64bit kernel. So userspace aligns this to
32, and kernel to 64, but since no length is passed from
userspace to kernel on ioctl, kernel uses its size calculation
and copies 4 extra bytes to userspace, corrupting memory.
Here's how it looks like during migrate execution:
our=20, kern=24
our=4, kern=8
...
our=4, kern=8
our=4064, kern=4064
our=512, kern=512
our=4, kern=8
our=20, kern=24
our=4, kern=8
...
our=4, kern=8
our=4064, kern=4064
*** glibc detected *** ./x86_64-softmmu/qemu-system-x86_64: realloc(): invalid next size: 0x08f20528 ***
(our is userspace size above, kern is the size as calculated
by the kernel).
Fix this by always aligning to 64 in a hope that no platform will
have sizeof(long)>8 any time soon, and add a comment describing it
all. It's a small price to pay for bad kernel design.
Alternatively it's possible to fix that in the kernel by using
different size calculation depending on the current process.
But this becomes quite ugly.
Special thanks goes to Stefan Hajnoczi for spotting the fundamental
cause of the issue, and to Alexander Graf for his support in #qemu.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
CC: Bruce Rogers <brogers@novell.com>
Signed-off-by: Avi Kivity <avi@redhat.com>
2011-04-26 18:13:49 +02:00
|
|
|
/* XXX bad kernel interface alert
|
|
|
|
* For dirty bitmap, kernel allocates array of size aligned to
|
|
|
|
* bits-per-long. But for case when the kernel is 64bits and
|
|
|
|
* the userspace is 32bits, userspace can't align to the same
|
|
|
|
* bits-per-long, since sizeof(long) is different between kernel
|
|
|
|
* and user space. This way, userspace will provide buffer which
|
|
|
|
* may be 4 bytes less than the kernel will use, resulting in
|
|
|
|
* userspace memory corruption (which is not detectable by valgrind
|
|
|
|
* too, in most cases).
|
|
|
|
* So for now, let's align to 64 instead of HOST_LONG_BITS here, in
|
|
|
|
* a hope that sizeof(long) wont become >8 any time soon.
|
|
|
|
*/
|
|
|
|
size = ALIGN(((mem->memory_size) >> TARGET_PAGE_BITS),
|
|
|
|
/*HOST_LONG_BITS*/ 64) / 8;
|
2009-05-01 20:52:47 +02:00
|
|
|
if (!d.dirty_bitmap) {
|
|
|
|
d.dirty_bitmap = qemu_malloc(size);
|
|
|
|
} else if (size > allocated_size) {
|
|
|
|
d.dirty_bitmap = qemu_realloc(d.dirty_bitmap, size);
|
|
|
|
}
|
|
|
|
allocated_size = size;
|
|
|
|
memset(d.dirty_bitmap, 0, allocated_size);
|
2008-11-24 20:36:26 +01:00
|
|
|
|
2009-05-01 20:52:47 +02:00
|
|
|
d.slot = mem->slot;
|
2008-11-24 20:36:26 +01:00
|
|
|
|
2009-07-27 22:23:59 +02:00
|
|
|
if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("ioctl failed %d\n", errno);
|
2009-05-01 20:52:47 +02:00
|
|
|
ret = -1;
|
|
|
|
break;
|
|
|
|
}
|
2008-11-24 20:36:26 +01:00
|
|
|
|
2010-04-23 19:04:14 +02:00
|
|
|
kvm_get_dirty_pages_log_range(mem->start_addr, d.dirty_bitmap,
|
|
|
|
mem->start_addr, mem->memory_size);
|
|
|
|
start_addr = mem->start_addr + mem->memory_size;
|
2008-11-24 20:36:26 +01:00
|
|
|
}
|
|
|
|
qemu_free(d.dirty_bitmap);
|
2009-05-01 20:52:47 +02:00
|
|
|
|
|
|
|
return ret;
|
2008-11-24 20:36:26 +01:00
|
|
|
}
|
|
|
|
|
2009-10-01 23:12:16 +02:00
|
|
|
int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
|
2008-12-09 21:09:57 +01:00
|
|
|
{
|
|
|
|
int ret = -ENOSYS;
|
|
|
|
KVMState *s = kvm_state;
|
|
|
|
|
|
|
|
if (s->coalesced_mmio) {
|
|
|
|
struct kvm_coalesced_mmio_zone zone;
|
|
|
|
|
|
|
|
zone.addr = start;
|
|
|
|
zone.size = size;
|
|
|
|
|
|
|
|
ret = kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-10-01 23:12:16 +02:00
|
|
|
int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
|
2008-12-09 21:09:57 +01:00
|
|
|
{
|
|
|
|
int ret = -ENOSYS;
|
|
|
|
KVMState *s = kvm_state;
|
|
|
|
|
|
|
|
if (s->coalesced_mmio) {
|
|
|
|
struct kvm_coalesced_mmio_zone zone;
|
|
|
|
|
|
|
|
zone.addr = start;
|
|
|
|
zone.size = size;
|
|
|
|
|
|
|
|
ret = kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-05-08 22:33:24 +02:00
|
|
|
int kvm_check_extension(KVMState *s, unsigned int extension)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
|
|
|
|
if (ret < 0) {
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-01-10 12:50:05 +01:00
|
|
|
static int kvm_check_many_ioeventfds(void)
|
|
|
|
{
|
2011-01-25 17:17:14 +01:00
|
|
|
/* Userspace can use ioeventfd for io notification. This requires a host
|
|
|
|
* that supports eventfd(2) and an I/O thread; since eventfd does not
|
|
|
|
* support SIGIO it cannot interrupt the vcpu.
|
|
|
|
*
|
|
|
|
* Older kernels have a 6 device limit on the KVM io bus. Find out so we
|
2011-01-10 12:50:05 +01:00
|
|
|
* can avoid creating too many ioeventfds.
|
|
|
|
*/
|
2011-01-25 17:17:14 +01:00
|
|
|
#if defined(CONFIG_EVENTFD) && defined(CONFIG_IOTHREAD)
|
2011-01-10 12:50:05 +01:00
|
|
|
int ioeventfds[7];
|
|
|
|
int i, ret = 0;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
|
|
|
|
ioeventfds[i] = eventfd(0, EFD_CLOEXEC);
|
|
|
|
if (ioeventfds[i] < 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ret = kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, true);
|
|
|
|
if (ret < 0) {
|
|
|
|
close(ioeventfds[i]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Decide whether many devices are supported or not */
|
|
|
|
ret = i == ARRAY_SIZE(ioeventfds);
|
|
|
|
|
|
|
|
while (i-- > 0) {
|
|
|
|
kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, false);
|
|
|
|
close(ioeventfds[i]);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-01-21 21:48:17 +01:00
|
|
|
static const KVMCapabilityInfo *
|
|
|
|
kvm_check_extension_list(KVMState *s, const KVMCapabilityInfo *list)
|
|
|
|
{
|
|
|
|
while (list->name) {
|
|
|
|
if (!kvm_check_extension(s, list->value)) {
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
list++;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-01-04 09:32:13 +01:00
|
|
|
static void kvm_set_phys_mem(target_phys_addr_t start_addr, ram_addr_t size,
|
|
|
|
ram_addr_t phys_offset)
|
2010-01-27 21:07:08 +01:00
|
|
|
{
|
|
|
|
KVMState *s = kvm_state;
|
|
|
|
ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
|
|
|
|
KVMSlot *mem, old;
|
|
|
|
int err;
|
|
|
|
|
2010-07-28 17:13:23 +02:00
|
|
|
/* kvm works in page size chunks, but the function may be called
|
|
|
|
with sub-page size and unaligned start address. */
|
|
|
|
size = TARGET_PAGE_ALIGN(size);
|
|
|
|
start_addr = TARGET_PAGE_ALIGN(start_addr);
|
2010-01-27 21:07:08 +01:00
|
|
|
|
|
|
|
/* KVM does not support read-only slots */
|
|
|
|
phys_offset &= ~IO_MEM_ROM;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
mem = kvm_lookup_overlapping_slot(s, start_addr, start_addr + size);
|
|
|
|
if (!mem) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags < IO_MEM_UNASSIGNED && start_addr >= mem->start_addr &&
|
|
|
|
(start_addr + size <= mem->start_addr + mem->memory_size) &&
|
|
|
|
(phys_offset - start_addr == mem->phys_offset - mem->start_addr)) {
|
|
|
|
/* The new slot fits into the existing one and comes with
|
|
|
|
* identical parameters - nothing to be done. */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
old = *mem;
|
|
|
|
|
|
|
|
/* unregister the overlapping slot */
|
|
|
|
mem->memory_size = 0;
|
|
|
|
err = kvm_set_user_memory_region(s, mem);
|
|
|
|
if (err) {
|
|
|
|
fprintf(stderr, "%s: error unregistering overlapping slot: %s\n",
|
|
|
|
__func__, strerror(-err));
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Workaround for older KVM versions: we can't join slots, even not by
|
|
|
|
* unregistering the previous ones and then registering the larger
|
|
|
|
* slot. We have to maintain the existing fragmentation. Sigh.
|
|
|
|
*
|
|
|
|
* This workaround assumes that the new slot starts at the same
|
|
|
|
* address as the first existing one. If not or if some overlapping
|
|
|
|
* slot comes around later, we will fail (not seen in practice so far)
|
|
|
|
* - and actually require a recent KVM version. */
|
|
|
|
if (s->broken_set_mem_region &&
|
|
|
|
old.start_addr == start_addr && old.memory_size < size &&
|
|
|
|
flags < IO_MEM_UNASSIGNED) {
|
|
|
|
mem = kvm_alloc_slot(s);
|
|
|
|
mem->memory_size = old.memory_size;
|
|
|
|
mem->start_addr = old.start_addr;
|
|
|
|
mem->phys_offset = old.phys_offset;
|
|
|
|
mem->flags = 0;
|
|
|
|
|
|
|
|
err = kvm_set_user_memory_region(s, mem);
|
|
|
|
if (err) {
|
|
|
|
fprintf(stderr, "%s: error updating slot: %s\n", __func__,
|
|
|
|
strerror(-err));
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
start_addr += old.memory_size;
|
|
|
|
phys_offset += old.memory_size;
|
|
|
|
size -= old.memory_size;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* register prefix slot */
|
|
|
|
if (old.start_addr < start_addr) {
|
|
|
|
mem = kvm_alloc_slot(s);
|
|
|
|
mem->memory_size = start_addr - old.start_addr;
|
|
|
|
mem->start_addr = old.start_addr;
|
|
|
|
mem->phys_offset = old.phys_offset;
|
|
|
|
mem->flags = 0;
|
|
|
|
|
|
|
|
err = kvm_set_user_memory_region(s, mem);
|
|
|
|
if (err) {
|
|
|
|
fprintf(stderr, "%s: error registering prefix slot: %s\n",
|
|
|
|
__func__, strerror(-err));
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* register suffix slot */
|
|
|
|
if (old.start_addr + old.memory_size > start_addr + size) {
|
|
|
|
ram_addr_t size_delta;
|
|
|
|
|
|
|
|
mem = kvm_alloc_slot(s);
|
|
|
|
mem->start_addr = start_addr + size;
|
|
|
|
size_delta = mem->start_addr - old.start_addr;
|
|
|
|
mem->memory_size = old.memory_size - size_delta;
|
|
|
|
mem->phys_offset = old.phys_offset + size_delta;
|
|
|
|
mem->flags = 0;
|
|
|
|
|
|
|
|
err = kvm_set_user_memory_region(s, mem);
|
|
|
|
if (err) {
|
|
|
|
fprintf(stderr, "%s: error registering suffix slot: %s\n",
|
|
|
|
__func__, strerror(-err));
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* in case the KVM bug workaround already "consumed" the new slot */
|
2011-01-04 09:32:13 +01:00
|
|
|
if (!size) {
|
2010-01-27 21:07:08 +01:00
|
|
|
return;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2010-01-27 21:07:08 +01:00
|
|
|
/* KVM does not need to know about this memory */
|
2011-01-04 09:32:13 +01:00
|
|
|
if (flags >= IO_MEM_UNASSIGNED) {
|
2010-01-27 21:07:08 +01:00
|
|
|
return;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2010-01-27 21:07:08 +01:00
|
|
|
mem = kvm_alloc_slot(s);
|
|
|
|
mem->memory_size = size;
|
|
|
|
mem->start_addr = start_addr;
|
|
|
|
mem->phys_offset = phys_offset;
|
|
|
|
mem->flags = 0;
|
|
|
|
|
|
|
|
err = kvm_set_user_memory_region(s, mem);
|
|
|
|
if (err) {
|
|
|
|
fprintf(stderr, "%s: error registering slot: %s\n", __func__,
|
|
|
|
strerror(-err));
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-27 21:07:21 +01:00
|
|
|
static void kvm_client_set_memory(struct CPUPhysMemoryClient *client,
|
2011-01-04 09:32:13 +01:00
|
|
|
target_phys_addr_t start_addr,
|
|
|
|
ram_addr_t size, ram_addr_t phys_offset)
|
2010-01-27 21:07:21 +01:00
|
|
|
{
|
2011-01-04 09:32:13 +01:00
|
|
|
kvm_set_phys_mem(start_addr, size, phys_offset);
|
2010-01-27 21:07:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int kvm_client_sync_dirty_bitmap(struct CPUPhysMemoryClient *client,
|
2011-01-04 09:32:13 +01:00
|
|
|
target_phys_addr_t start_addr,
|
|
|
|
target_phys_addr_t end_addr)
|
2010-01-27 21:07:21 +01:00
|
|
|
{
|
2011-01-04 09:32:13 +01:00
|
|
|
return kvm_physical_sync_dirty_bitmap(start_addr, end_addr);
|
2010-01-27 21:07:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int kvm_client_migration_log(struct CPUPhysMemoryClient *client,
|
2011-01-04 09:32:13 +01:00
|
|
|
int enable)
|
2010-01-27 21:07:21 +01:00
|
|
|
{
|
2011-01-04 09:32:13 +01:00
|
|
|
return kvm_set_migration_log(enable);
|
2010-01-27 21:07:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static CPUPhysMemoryClient kvm_cpu_phys_memory_client = {
|
2011-01-04 09:32:13 +01:00
|
|
|
.set_memory = kvm_client_set_memory,
|
|
|
|
.sync_dirty_bitmap = kvm_client_sync_dirty_bitmap,
|
|
|
|
.migration_log = kvm_client_migration_log,
|
2011-02-07 12:19:23 +01:00
|
|
|
.log_start = kvm_log_start,
|
|
|
|
.log_stop = kvm_log_stop,
|
2010-01-27 21:07:21 +01:00
|
|
|
};
|
|
|
|
|
2011-04-13 01:32:56 +02:00
|
|
|
static void kvm_handle_interrupt(CPUState *env, int mask)
|
|
|
|
{
|
|
|
|
env->interrupt_request |= mask;
|
|
|
|
|
|
|
|
if (!qemu_cpu_is_self(env)) {
|
|
|
|
qemu_cpu_kick(env);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-21 21:48:16 +01:00
|
|
|
int kvm_init(void)
|
2008-11-05 17:29:27 +01:00
|
|
|
{
|
2009-06-07 11:30:25 +02:00
|
|
|
static const char upgrade_note[] =
|
|
|
|
"Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
|
|
|
|
"(see http://sourceforge.net/projects/kvm).\n";
|
2008-11-05 17:29:27 +01:00
|
|
|
KVMState *s;
|
2011-01-21 21:48:17 +01:00
|
|
|
const KVMCapabilityInfo *missing_cap;
|
2008-11-05 17:29:27 +01:00
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
s = qemu_mallocz(sizeof(KVMState));
|
|
|
|
|
2009-03-12 21:12:48 +01:00
|
|
|
#ifdef KVM_CAP_SET_GUEST_DEBUG
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INIT(&s->kvm_sw_breakpoints);
|
2009-03-12 21:12:48 +01:00
|
|
|
#endif
|
2011-01-04 09:32:13 +01:00
|
|
|
for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
|
2008-11-05 17:29:27 +01:00
|
|
|
s->slots[i].slot = i;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
s->vmfd = -1;
|
2009-12-02 12:24:42 +01:00
|
|
|
s->fd = qemu_open("/dev/kvm", O_RDWR);
|
2008-11-05 17:29:27 +01:00
|
|
|
if (s->fd == -1) {
|
|
|
|
fprintf(stderr, "Could not access KVM kernel module: %m\n");
|
|
|
|
ret = -errno;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
|
|
|
|
if (ret < KVM_API_VERSION) {
|
2011-01-04 09:32:13 +01:00
|
|
|
if (ret > 0) {
|
2008-11-05 17:29:27 +01:00
|
|
|
ret = -EINVAL;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
fprintf(stderr, "kvm version too old\n");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret > KVM_API_VERSION) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
fprintf(stderr, "kvm version not supported\n");
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
|
2010-04-01 18:42:37 +02:00
|
|
|
if (s->vmfd < 0) {
|
|
|
|
#ifdef TARGET_S390X
|
|
|
|
fprintf(stderr, "Please add the 'switch_amode' kernel parameter to "
|
|
|
|
"your host kernel command line\n");
|
|
|
|
#endif
|
2008-11-05 17:29:27 +01:00
|
|
|
goto err;
|
2010-04-01 18:42:37 +02:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2011-01-21 21:48:17 +01:00
|
|
|
missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
|
|
|
|
if (!missing_cap) {
|
|
|
|
missing_cap =
|
|
|
|
kvm_check_extension_list(s, kvm_arch_required_capabilities);
|
2008-11-05 17:29:27 +01:00
|
|
|
}
|
2011-01-21 21:48:17 +01:00
|
|
|
if (missing_cap) {
|
2009-05-08 22:33:24 +02:00
|
|
|
ret = -EINVAL;
|
2011-01-21 21:48:17 +01:00
|
|
|
fprintf(stderr, "kvm does not support %s\n%s",
|
|
|
|
missing_cap->name, upgrade_note);
|
2008-12-09 20:59:09 +01:00
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2009-05-08 22:33:24 +02:00
|
|
|
s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
|
2008-12-09 21:09:57 +01:00
|
|
|
|
2009-05-01 20:42:15 +02:00
|
|
|
s->broken_set_mem_region = 1;
|
|
|
|
#ifdef KVM_CAP_JOIN_MEMORY_REGIONS_WORKS
|
2010-12-10 08:52:36 +01:00
|
|
|
ret = kvm_check_extension(s, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
|
2009-05-01 20:42:15 +02:00
|
|
|
if (ret > 0) {
|
|
|
|
s->broken_set_mem_region = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2009-11-25 00:33:03 +01:00
|
|
|
s->vcpu_events = 0;
|
|
|
|
#ifdef KVM_CAP_VCPU_EVENTS
|
|
|
|
s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
|
|
|
|
#endif
|
|
|
|
|
2010-03-01 19:10:29 +01:00
|
|
|
s->robust_singlestep = 0;
|
|
|
|
#ifdef KVM_CAP_X86_ROBUST_SINGLESTEP
|
|
|
|
s->robust_singlestep =
|
|
|
|
kvm_check_extension(s, KVM_CAP_X86_ROBUST_SINGLESTEP);
|
|
|
|
#endif
|
|
|
|
|
2010-03-12 15:20:49 +01:00
|
|
|
s->debugregs = 0;
|
|
|
|
#ifdef KVM_CAP_DEBUGREGS
|
|
|
|
s->debugregs = kvm_check_extension(s, KVM_CAP_DEBUGREGS);
|
|
|
|
#endif
|
|
|
|
|
2010-06-17 11:53:07 +02:00
|
|
|
s->xsave = 0;
|
|
|
|
#ifdef KVM_CAP_XSAVE
|
|
|
|
s->xsave = kvm_check_extension(s, KVM_CAP_XSAVE);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
s->xcrs = 0;
|
|
|
|
#ifdef KVM_CAP_XCRS
|
|
|
|
s->xcrs = kvm_check_extension(s, KVM_CAP_XCRS);
|
|
|
|
#endif
|
|
|
|
|
2011-01-21 21:48:16 +01:00
|
|
|
ret = kvm_arch_init(s);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (ret < 0) {
|
2008-11-05 17:29:27 +01:00
|
|
|
goto err;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
|
|
|
|
kvm_state = s;
|
2010-01-27 21:07:21 +01:00
|
|
|
cpu_register_phys_memory_client(&kvm_cpu_phys_memory_client);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2011-01-10 12:50:05 +01:00
|
|
|
s->many_ioeventfds = kvm_check_many_ioeventfds();
|
|
|
|
|
2011-04-13 01:32:56 +02:00
|
|
|
cpu_interrupt_handler = kvm_handle_interrupt;
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
if (s) {
|
2011-01-04 09:32:13 +01:00
|
|
|
if (s->vmfd != -1) {
|
2008-11-05 17:29:27 +01:00
|
|
|
close(s->vmfd);
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
|
|
|
if (s->fd != -1) {
|
2008-11-05 17:29:27 +01:00
|
|
|
close(s->fd);
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
}
|
|
|
|
qemu_free(s);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-02-01 22:16:01 +01:00
|
|
|
static void kvm_handle_io(uint16_t port, void *data, int direction, int size,
|
|
|
|
uint32_t count)
|
2008-11-05 17:29:27 +01:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint8_t *ptr = data;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
if (direction == KVM_EXIT_IO_IN) {
|
|
|
|
switch (size) {
|
|
|
|
case 1:
|
2009-09-20 18:05:47 +02:00
|
|
|
stb_p(ptr, cpu_inb(port));
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
case 2:
|
2009-09-20 18:05:47 +02:00
|
|
|
stw_p(ptr, cpu_inw(port));
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
case 4:
|
2009-09-20 18:05:47 +02:00
|
|
|
stl_p(ptr, cpu_inl(port));
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
switch (size) {
|
|
|
|
case 1:
|
2009-09-20 18:05:47 +02:00
|
|
|
cpu_outb(port, ldub_p(ptr));
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
case 2:
|
2009-09-20 18:05:47 +02:00
|
|
|
cpu_outw(port, lduw_p(ptr));
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
case 4:
|
2009-09-20 18:05:47 +02:00
|
|
|
cpu_outl(port, ldl_p(ptr));
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr += size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-23 17:37:11 +01:00
|
|
|
#ifdef KVM_CAP_INTERNAL_ERROR_DATA
|
2011-01-21 21:48:06 +01:00
|
|
|
static int kvm_handle_internal_error(CPUState *env, struct kvm_run *run)
|
2010-03-23 17:37:11 +01:00
|
|
|
{
|
2011-01-21 21:48:07 +01:00
|
|
|
fprintf(stderr, "KVM internal error.");
|
2010-03-23 17:37:11 +01:00
|
|
|
if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) {
|
|
|
|
int i;
|
|
|
|
|
2011-01-21 21:48:07 +01:00
|
|
|
fprintf(stderr, " Suberror: %d\n", run->internal.suberror);
|
2010-03-23 17:37:11 +01:00
|
|
|
for (i = 0; i < run->internal.ndata; ++i) {
|
|
|
|
fprintf(stderr, "extra data[%d]: %"PRIx64"\n",
|
|
|
|
i, (uint64_t)run->internal.data[i]);
|
|
|
|
}
|
2011-01-21 21:48:07 +01:00
|
|
|
} else {
|
|
|
|
fprintf(stderr, "\n");
|
2010-03-23 17:37:11 +01:00
|
|
|
}
|
|
|
|
if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {
|
|
|
|
fprintf(stderr, "emulation failure\n");
|
2011-01-04 09:32:13 +01:00
|
|
|
if (!kvm_arch_stop_on_emulation_error(env)) {
|
2011-01-21 21:48:08 +01:00
|
|
|
cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE);
|
2011-03-15 12:26:27 +01:00
|
|
|
return EXCP_INTERRUPT;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2010-03-23 17:37:11 +01:00
|
|
|
}
|
|
|
|
/* FIXME: Should trigger a qmp message to let management know
|
|
|
|
* something went wrong.
|
|
|
|
*/
|
2011-01-21 21:48:06 +01:00
|
|
|
return -1;
|
2010-03-23 17:37:11 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-01-26 12:21:16 +01:00
|
|
|
void kvm_flush_coalesced_mmio_buffer(void)
|
2008-12-09 21:09:57 +01:00
|
|
|
{
|
|
|
|
KVMState *s = kvm_state;
|
2010-01-26 12:21:16 +01:00
|
|
|
if (s->coalesced_mmio_ring) {
|
|
|
|
struct kvm_coalesced_mmio_ring *ring = s->coalesced_mmio_ring;
|
2008-12-09 21:09:57 +01:00
|
|
|
while (ring->first != ring->last) {
|
|
|
|
struct kvm_coalesced_mmio *ent;
|
|
|
|
|
|
|
|
ent = &ring->coalesced_mmio[ring->first];
|
|
|
|
|
|
|
|
cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
|
2010-02-22 17:57:54 +01:00
|
|
|
smp_wmb();
|
2008-12-09 21:09:57 +01:00
|
|
|
ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-04 14:45:23 +02:00
|
|
|
static void do_kvm_cpu_synchronize_state(void *_env)
|
2009-08-17 22:19:53 +02:00
|
|
|
{
|
2010-05-04 14:45:23 +02:00
|
|
|
CPUState *env = _env;
|
|
|
|
|
2010-02-03 21:17:05 +01:00
|
|
|
if (!env->kvm_vcpu_dirty) {
|
2009-08-17 22:19:53 +02:00
|
|
|
kvm_arch_get_registers(env);
|
2010-02-03 21:17:05 +01:00
|
|
|
env->kvm_vcpu_dirty = 1;
|
2009-08-17 22:19:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-04 14:45:23 +02:00
|
|
|
void kvm_cpu_synchronize_state(CPUState *env)
|
|
|
|
{
|
2011-01-04 09:32:13 +01:00
|
|
|
if (!env->kvm_vcpu_dirty) {
|
2010-05-04 14:45:23 +02:00
|
|
|
run_on_cpu(env, do_kvm_cpu_synchronize_state, env);
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2010-05-04 14:45:23 +02:00
|
|
|
}
|
|
|
|
|
2010-03-01 19:10:30 +01:00
|
|
|
void kvm_cpu_synchronize_post_reset(CPUState *env)
|
|
|
|
{
|
|
|
|
kvm_arch_put_registers(env, KVM_PUT_RESET_STATE);
|
|
|
|
env->kvm_vcpu_dirty = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void kvm_cpu_synchronize_post_init(CPUState *env)
|
|
|
|
{
|
|
|
|
kvm_arch_put_registers(env, KVM_PUT_FULL_STATE);
|
|
|
|
env->kvm_vcpu_dirty = 0;
|
|
|
|
}
|
|
|
|
|
2008-11-05 17:29:27 +01:00
|
|
|
int kvm_cpu_exec(CPUState *env)
|
|
|
|
{
|
|
|
|
struct kvm_run *run = env->kvm_run;
|
2011-03-15 12:26:25 +01:00
|
|
|
int ret, run_ret;
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("kvm_cpu_exec()\n");
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2011-03-02 08:56:13 +01:00
|
|
|
if (kvm_arch_process_async_events(env)) {
|
2011-02-01 22:16:00 +01:00
|
|
|
env->exit_request = 0;
|
2011-02-07 12:19:18 +01:00
|
|
|
return EXCP_HLT;
|
2011-02-01 22:16:00 +01:00
|
|
|
}
|
2010-05-04 14:45:27 +02:00
|
|
|
|
2011-02-07 12:19:18 +01:00
|
|
|
cpu_single_env = env;
|
|
|
|
|
2011-02-01 22:16:00 +01:00
|
|
|
do {
|
2010-02-03 21:17:05 +01:00
|
|
|
if (env->kvm_vcpu_dirty) {
|
2010-03-01 19:10:30 +01:00
|
|
|
kvm_arch_put_registers(env, KVM_PUT_RUNTIME_STATE);
|
2010-02-03 21:17:05 +01:00
|
|
|
env->kvm_vcpu_dirty = 0;
|
2009-08-17 22:19:53 +02:00
|
|
|
}
|
|
|
|
|
2009-05-30 10:01:45 +02:00
|
|
|
kvm_arch_pre_run(env, run);
|
2011-02-01 22:16:00 +01:00
|
|
|
if (env->exit_request) {
|
|
|
|
DPRINTF("interrupt exit requested\n");
|
|
|
|
/*
|
|
|
|
* KVM requires us to reenter the kernel after IO exits to complete
|
|
|
|
* instruction emulation. This self-signal will ensure that we
|
|
|
|
* leave ASAP again.
|
|
|
|
*/
|
|
|
|
qemu_cpu_kick_self();
|
|
|
|
}
|
2010-05-04 14:45:19 +02:00
|
|
|
cpu_single_env = NULL;
|
2009-10-07 21:38:03 +02:00
|
|
|
qemu_mutex_unlock_iothread();
|
2011-02-01 22:16:00 +01:00
|
|
|
|
2011-03-15 12:26:25 +01:00
|
|
|
run_ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
|
2011-02-01 22:16:00 +01:00
|
|
|
|
2009-10-07 21:38:03 +02:00
|
|
|
qemu_mutex_lock_iothread();
|
2010-05-04 14:45:19 +02:00
|
|
|
cpu_single_env = env;
|
2008-11-05 17:29:27 +01:00
|
|
|
kvm_arch_post_run(env, run);
|
|
|
|
|
2011-01-21 21:48:19 +01:00
|
|
|
kvm_flush_coalesced_mmio_buffer();
|
|
|
|
|
2011-03-15 12:26:25 +01:00
|
|
|
if (run_ret < 0) {
|
2011-03-15 12:26:26 +01:00
|
|
|
if (run_ret == -EINTR || run_ret == -EAGAIN) {
|
|
|
|
DPRINTF("io window exit\n");
|
2011-03-15 12:26:27 +01:00
|
|
|
ret = EXCP_INTERRUPT;
|
2011-03-15 12:26:26 +01:00
|
|
|
break;
|
|
|
|
}
|
2011-03-15 12:26:25 +01:00
|
|
|
DPRINTF("kvm run failed %s\n", strerror(-run_ret));
|
2008-11-05 17:29:27 +01:00
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (run->exit_reason) {
|
|
|
|
case KVM_EXIT_IO:
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("handle_io\n");
|
2011-02-01 22:16:01 +01:00
|
|
|
kvm_handle_io(run->io.port,
|
|
|
|
(uint8_t *)run + run->io.data_offset,
|
|
|
|
run->io.direction,
|
|
|
|
run->io.size,
|
|
|
|
run->io.count);
|
2011-03-15 12:26:27 +01:00
|
|
|
ret = 0;
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
case KVM_EXIT_MMIO:
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("handle_mmio\n");
|
2008-11-05 17:29:27 +01:00
|
|
|
cpu_physical_memory_rw(run->mmio.phys_addr,
|
|
|
|
run->mmio.data,
|
|
|
|
run->mmio.len,
|
|
|
|
run->mmio.is_write);
|
2011-03-15 12:26:27 +01:00
|
|
|
ret = 0;
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
case KVM_EXIT_IRQ_WINDOW_OPEN:
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("irq_window_open\n");
|
2011-03-15 12:26:27 +01:00
|
|
|
ret = EXCP_INTERRUPT;
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
case KVM_EXIT_SHUTDOWN:
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("shutdown\n");
|
2008-11-05 17:29:27 +01:00
|
|
|
qemu_system_reset_request();
|
2011-03-15 12:26:27 +01:00
|
|
|
ret = EXCP_INTERRUPT;
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
|
|
|
case KVM_EXIT_UNKNOWN:
|
2011-01-21 21:48:07 +01:00
|
|
|
fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
|
|
|
|
(uint64_t)run->hw.hardware_exit_reason);
|
2011-01-21 21:48:06 +01:00
|
|
|
ret = -1;
|
2008-11-05 17:29:27 +01:00
|
|
|
break;
|
2010-03-23 17:37:11 +01:00
|
|
|
#ifdef KVM_CAP_INTERNAL_ERROR_DATA
|
|
|
|
case KVM_EXIT_INTERNAL_ERROR:
|
2011-01-21 21:48:06 +01:00
|
|
|
ret = kvm_handle_internal_error(env, run);
|
2010-03-23 17:37:11 +01:00
|
|
|
break;
|
|
|
|
#endif
|
2008-11-05 17:29:27 +01:00
|
|
|
default:
|
2010-04-18 16:22:14 +02:00
|
|
|
DPRINTF("kvm_arch_handle_exit\n");
|
2008-11-05 17:29:27 +01:00
|
|
|
ret = kvm_arch_handle_exit(env, run);
|
|
|
|
break;
|
|
|
|
}
|
2011-03-15 12:26:27 +01:00
|
|
|
} while (ret == 0);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2011-01-21 21:48:06 +01:00
|
|
|
if (ret < 0) {
|
2011-01-21 21:48:08 +01:00
|
|
|
cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE);
|
2011-02-09 16:29:40 +01:00
|
|
|
vm_stop(VMSTOP_PANIC);
|
2008-11-10 16:55:14 +01:00
|
|
|
}
|
|
|
|
|
2011-02-07 12:19:18 +01:00
|
|
|
env->exit_request = 0;
|
|
|
|
cpu_single_env = NULL;
|
2008-11-05 17:29:27 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
int kvm_ioctl(KVMState *s, int type, ...)
|
2008-11-05 17:29:27 +01:00
|
|
|
{
|
|
|
|
int ret;
|
2008-11-13 20:21:00 +01:00
|
|
|
void *arg;
|
|
|
|
va_list ap;
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
va_start(ap, type);
|
|
|
|
arg = va_arg(ap, void *);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
ret = ioctl(s->fd, type, arg);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (ret == -1) {
|
2008-11-05 17:29:27 +01:00
|
|
|
ret = -errno;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
int kvm_vm_ioctl(KVMState *s, int type, ...)
|
2008-11-05 17:29:27 +01:00
|
|
|
{
|
|
|
|
int ret;
|
2008-11-13 20:21:00 +01:00
|
|
|
void *arg;
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, type);
|
|
|
|
arg = va_arg(ap, void *);
|
|
|
|
va_end(ap);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
ret = ioctl(s->vmfd, type, arg);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (ret == -1) {
|
2008-11-05 17:29:27 +01:00
|
|
|
ret = -errno;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
int kvm_vcpu_ioctl(CPUState *env, int type, ...)
|
2008-11-05 17:29:27 +01:00
|
|
|
{
|
|
|
|
int ret;
|
2008-11-13 20:21:00 +01:00
|
|
|
void *arg;
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, type);
|
|
|
|
arg = va_arg(ap, void *);
|
|
|
|
va_end(ap);
|
2008-11-05 17:29:27 +01:00
|
|
|
|
2008-11-13 20:21:00 +01:00
|
|
|
ret = ioctl(env->kvm_fd, type, arg);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (ret == -1) {
|
2008-11-05 17:29:27 +01:00
|
|
|
ret = -errno;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2008-11-05 17:29:27 +01:00
|
|
|
return ret;
|
|
|
|
}
|
2008-12-04 21:33:06 +01:00
|
|
|
|
|
|
|
int kvm_has_sync_mmu(void)
|
|
|
|
{
|
2011-01-21 21:48:17 +01:00
|
|
|
return kvm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);
|
2008-12-04 21:33:06 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2009-11-25 00:33:03 +01:00
|
|
|
int kvm_has_vcpu_events(void)
|
|
|
|
{
|
|
|
|
return kvm_state->vcpu_events;
|
|
|
|
}
|
|
|
|
|
2010-03-01 19:10:29 +01:00
|
|
|
int kvm_has_robust_singlestep(void)
|
|
|
|
{
|
|
|
|
return kvm_state->robust_singlestep;
|
|
|
|
}
|
|
|
|
|
2010-03-12 15:20:49 +01:00
|
|
|
int kvm_has_debugregs(void)
|
|
|
|
{
|
|
|
|
return kvm_state->debugregs;
|
|
|
|
}
|
|
|
|
|
2010-06-17 11:53:07 +02:00
|
|
|
int kvm_has_xsave(void)
|
|
|
|
{
|
|
|
|
return kvm_state->xsave;
|
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_has_xcrs(void)
|
|
|
|
{
|
|
|
|
return kvm_state->xcrs;
|
|
|
|
}
|
|
|
|
|
2011-01-10 12:50:05 +01:00
|
|
|
int kvm_has_many_ioeventfds(void)
|
|
|
|
{
|
|
|
|
if (!kvm_enabled()) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return kvm_state->many_ioeventfds;
|
|
|
|
}
|
|
|
|
|
2009-04-26 18:03:40 +02:00
|
|
|
void kvm_setup_guest_memory(void *start, size_t size)
|
|
|
|
{
|
|
|
|
if (!kvm_has_sync_mmu()) {
|
2010-09-25 13:26:05 +02:00
|
|
|
int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK);
|
2009-04-26 18:03:40 +02:00
|
|
|
|
|
|
|
if (ret) {
|
2010-09-25 13:26:05 +02:00
|
|
|
perror("qemu_madvise");
|
|
|
|
fprintf(stderr,
|
|
|
|
"Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
|
2009-04-26 18:03:40 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-12 21:12:48 +01:00
|
|
|
#ifdef KVM_CAP_SET_GUEST_DEBUG
|
|
|
|
struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
|
|
|
|
target_ulong pc)
|
|
|
|
{
|
|
|
|
struct kvm_sw_breakpoint *bp;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) {
|
2011-01-04 09:32:13 +01:00
|
|
|
if (bp->pc == pc) {
|
2009-03-12 21:12:48 +01:00
|
|
|
return bp;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_sw_breakpoints_active(CPUState *env)
|
|
|
|
{
|
2009-09-12 09:36:22 +02:00
|
|
|
return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints);
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
|
2009-07-16 23:55:28 +02:00
|
|
|
struct kvm_set_guest_debug_data {
|
|
|
|
struct kvm_guest_debug dbg;
|
|
|
|
CPUState *env;
|
|
|
|
int err;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void kvm_invoke_set_guest_debug(void *data)
|
|
|
|
{
|
|
|
|
struct kvm_set_guest_debug_data *dbg_data = data;
|
2009-09-17 20:05:58 +02:00
|
|
|
CPUState *env = dbg_data->env;
|
|
|
|
|
|
|
|
dbg_data->err = kvm_vcpu_ioctl(env, KVM_SET_GUEST_DEBUG, &dbg_data->dbg);
|
2009-07-16 23:55:28 +02:00
|
|
|
}
|
|
|
|
|
2009-03-12 21:12:48 +01:00
|
|
|
int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
|
|
|
|
{
|
2009-07-16 23:55:28 +02:00
|
|
|
struct kvm_set_guest_debug_data data;
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2010-03-01 19:10:29 +01:00
|
|
|
data.dbg.control = reinject_trap;
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2010-03-01 19:10:29 +01:00
|
|
|
if (env->singlestep_enabled) {
|
|
|
|
data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
|
|
|
|
}
|
2009-07-16 23:55:28 +02:00
|
|
|
kvm_arch_update_guest_debug(env, &data.dbg);
|
|
|
|
data.env = env;
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2010-05-20 00:28:45 +02:00
|
|
|
run_on_cpu(env, kvm_invoke_set_guest_debug, &data);
|
2009-07-16 23:55:28 +02:00
|
|
|
return data.err;
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
|
|
|
|
target_ulong len, int type)
|
|
|
|
{
|
|
|
|
struct kvm_sw_breakpoint *bp;
|
|
|
|
CPUState *env;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (type == GDB_BREAKPOINT_SW) {
|
|
|
|
bp = kvm_find_sw_breakpoint(current_env, addr);
|
|
|
|
if (bp) {
|
|
|
|
bp->use_count++;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
|
2011-01-04 09:32:13 +01:00
|
|
|
if (!bp) {
|
2009-03-12 21:12:48 +01:00
|
|
|
return -ENOMEM;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
|
|
|
|
bp->pc = addr;
|
|
|
|
bp->use_count = 1;
|
|
|
|
err = kvm_arch_insert_sw_breakpoint(current_env, bp);
|
|
|
|
if (err) {
|
|
|
|
free(bp);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_INSERT_HEAD(¤t_env->kvm_state->kvm_sw_breakpoints,
|
2009-03-12 21:12:48 +01:00
|
|
|
bp, entry);
|
|
|
|
} else {
|
|
|
|
err = kvm_arch_insert_hw_breakpoint(addr, len, type);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (err) {
|
2009-03-12 21:12:48 +01:00
|
|
|
return err;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
for (env = first_cpu; env != NULL; env = env->next_cpu) {
|
|
|
|
err = kvm_update_guest_debug(env, 0);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (err) {
|
2009-03-12 21:12:48 +01:00
|
|
|
return err;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
|
|
|
|
target_ulong len, int type)
|
|
|
|
{
|
|
|
|
struct kvm_sw_breakpoint *bp;
|
|
|
|
CPUState *env;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (type == GDB_BREAKPOINT_SW) {
|
|
|
|
bp = kvm_find_sw_breakpoint(current_env, addr);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (!bp) {
|
2009-03-12 21:12:48 +01:00
|
|
|
return -ENOENT;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
|
|
|
|
if (bp->use_count > 1) {
|
|
|
|
bp->use_count--;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = kvm_arch_remove_sw_breakpoint(current_env, bp);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (err) {
|
2009-03-12 21:12:48 +01:00
|
|
|
return err;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_REMOVE(¤t_env->kvm_state->kvm_sw_breakpoints, bp, entry);
|
2009-03-12 21:12:48 +01:00
|
|
|
qemu_free(bp);
|
|
|
|
} else {
|
|
|
|
err = kvm_arch_remove_hw_breakpoint(addr, len, type);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (err) {
|
2009-03-12 21:12:48 +01:00
|
|
|
return err;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
for (env = first_cpu; env != NULL; env = env->next_cpu) {
|
|
|
|
err = kvm_update_guest_debug(env, 0);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (err) {
|
2009-03-12 21:12:48 +01:00
|
|
|
return err;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void kvm_remove_all_breakpoints(CPUState *current_env)
|
|
|
|
{
|
|
|
|
struct kvm_sw_breakpoint *bp, *next;
|
|
|
|
KVMState *s = current_env->kvm_state;
|
|
|
|
CPUState *env;
|
|
|
|
|
2009-09-12 09:36:22 +02:00
|
|
|
QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
|
2009-03-12 21:12:48 +01:00
|
|
|
if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
|
|
|
|
/* Try harder to find a CPU that currently sees the breakpoint. */
|
|
|
|
for (env = first_cpu; env != NULL; env = env->next_cpu) {
|
2011-01-04 09:32:13 +01:00
|
|
|
if (kvm_arch_remove_sw_breakpoint(env, bp) == 0) {
|
2009-03-12 21:12:48 +01:00
|
|
|
break;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kvm_arch_remove_all_hw_breakpoints();
|
|
|
|
|
2011-01-04 09:32:13 +01:00
|
|
|
for (env = first_cpu; env != NULL; env = env->next_cpu) {
|
2009-03-12 21:12:48 +01:00
|
|
|
kvm_update_guest_debug(env, 0);
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2009-03-12 21:12:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
#else /* !KVM_CAP_SET_GUEST_DEBUG */
|
|
|
|
|
|
|
|
int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
|
|
|
|
target_ulong len, int type)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
|
|
|
|
target_ulong len, int type)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void kvm_remove_all_breakpoints(CPUState *current_env)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* !KVM_CAP_SET_GUEST_DEBUG */
|
2010-02-17 23:14:42 +01:00
|
|
|
|
|
|
|
int kvm_set_signal_mask(CPUState *env, const sigset_t *sigset)
|
|
|
|
{
|
|
|
|
struct kvm_signal_mask *sigmask;
|
|
|
|
int r;
|
|
|
|
|
2011-01-04 09:32:13 +01:00
|
|
|
if (!sigset) {
|
2010-02-17 23:14:42 +01:00
|
|
|
return kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, NULL);
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2010-02-17 23:14:42 +01:00
|
|
|
|
|
|
|
sigmask = qemu_malloc(sizeof(*sigmask) + sizeof(*sigset));
|
|
|
|
|
|
|
|
sigmask->len = 8;
|
|
|
|
memcpy(sigmask->sigset, sigset, sizeof(*sigset));
|
|
|
|
r = kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, sigmask);
|
|
|
|
free(sigmask);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
2010-03-17 12:07:54 +01:00
|
|
|
|
2010-07-27 02:10:59 +02:00
|
|
|
int kvm_set_ioeventfd_mmio_long(int fd, uint32_t addr, uint32_t val, bool assign)
|
|
|
|
{
|
|
|
|
#ifdef KVM_IOEVENTFD
|
|
|
|
int ret;
|
|
|
|
struct kvm_ioeventfd iofd;
|
|
|
|
|
|
|
|
iofd.datamatch = val;
|
|
|
|
iofd.addr = addr;
|
|
|
|
iofd.len = 4;
|
|
|
|
iofd.flags = KVM_IOEVENTFD_FLAG_DATAMATCH;
|
|
|
|
iofd.fd = fd;
|
|
|
|
|
|
|
|
if (!kvm_enabled()) {
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!assign) {
|
|
|
|
iofd.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &iofd);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
return -ENOSYS;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2010-03-17 12:07:54 +01:00
|
|
|
int kvm_set_ioeventfd_pio_word(int fd, uint16_t addr, uint16_t val, bool assign)
|
|
|
|
{
|
2010-04-19 20:59:30 +02:00
|
|
|
#ifdef KVM_IOEVENTFD
|
2010-03-17 12:07:54 +01:00
|
|
|
struct kvm_ioeventfd kick = {
|
|
|
|
.datamatch = val,
|
|
|
|
.addr = addr,
|
|
|
|
.len = 2,
|
|
|
|
.flags = KVM_IOEVENTFD_FLAG_DATAMATCH | KVM_IOEVENTFD_FLAG_PIO,
|
|
|
|
.fd = fd,
|
|
|
|
};
|
|
|
|
int r;
|
2011-01-04 09:32:13 +01:00
|
|
|
if (!kvm_enabled()) {
|
2010-03-17 12:07:54 +01:00
|
|
|
return -ENOSYS;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
|
|
|
if (!assign) {
|
2010-03-17 12:07:54 +01:00
|
|
|
kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2010-03-17 12:07:54 +01:00
|
|
|
r = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
|
2011-01-04 09:32:13 +01:00
|
|
|
if (r < 0) {
|
2010-03-17 12:07:54 +01:00
|
|
|
return r;
|
2011-01-04 09:32:13 +01:00
|
|
|
}
|
2010-03-17 12:07:54 +01:00
|
|
|
return 0;
|
2010-04-19 20:59:30 +02:00
|
|
|
#else
|
|
|
|
return -ENOSYS;
|
2010-03-17 12:07:54 +01:00
|
|
|
#endif
|
2010-04-19 20:59:30 +02:00
|
|
|
}
|
2011-02-01 22:15:51 +01:00
|
|
|
|
|
|
|
int kvm_on_sigbus_vcpu(CPUState *env, int code, void *addr)
|
|
|
|
{
|
|
|
|
return kvm_arch_on_sigbus_vcpu(env, code, addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
int kvm_on_sigbus(int code, void *addr)
|
|
|
|
{
|
|
|
|
return kvm_arch_on_sigbus(code, addr);
|
|
|
|
}
|