blob: 37b99c75109429a749127a2cda6dd8579943f1ce [file] [log] [blame]
aliguori05330442008-11-05 16:29:27 +00001/*
2 * QEMU KVM support
3 *
4 * Copyright IBM, Corp. 2008
aliguori5832d1f2008-11-24 19:36:26 +00005 * Red Hat, Inc. 2008
aliguori05330442008-11-05 16:29:27 +00006 *
7 * Authors:
8 * Anthony Liguori <aliguori@us.ibm.com>
aliguori5832d1f2008-11-24 19:36:26 +00009 * Glauber Costa <gcosta@redhat.com>
aliguori05330442008-11-05 16:29:27 +000010 *
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>
aliguori984b5182008-11-13 19:21:00 +000019#include <stdarg.h>
aliguori05330442008-11-05 16:29:27 +000020
21#include <linux/kvm.h>
22
23#include "qemu-common.h"
Marcelo Tosatti85199472010-02-22 13:57:54 -030024#include "qemu-barrier.h"
aliguori05330442008-11-05 16:29:27 +000025#include "sysemu.h"
Jan Kiszkad33a1812009-05-02 00:29:37 +020026#include "hw/hw.h"
aliguorie22a25c2009-03-12 20:12:48 +000027#include "gdbstub.h"
aliguori05330442008-11-05 16:29:27 +000028#include "kvm.h"
Marcelo Tosatti8369e012010-04-23 14:04:14 -030029#include "bswap.h"
aliguori05330442008-11-05 16:29:27 +000030
aliguorif65ed4c2008-12-09 20:09:57 +000031/* KVM uses PAGE_SIZE in it's definition of COALESCED_MMIO_MAX */
32#define PAGE_SIZE TARGET_PAGE_SIZE
33
aliguori05330442008-11-05 16:29:27 +000034//#define DEBUG_KVM
35
36#ifdef DEBUG_KVM
Blue Swirl8c0d5772010-04-18 14:22:14 +000037#define DPRINTF(fmt, ...) \
aliguori05330442008-11-05 16:29:27 +000038 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
39#else
Blue Swirl8c0d5772010-04-18 14:22:14 +000040#define DPRINTF(fmt, ...) \
aliguori05330442008-11-05 16:29:27 +000041 do { } while (0)
42#endif
43
aliguori34fc6432008-11-19 17:41:58 +000044typedef struct KVMSlot
45{
Anthony Liguoric227f092009-10-01 16:12:16 -050046 target_phys_addr_t start_addr;
47 ram_addr_t memory_size;
48 ram_addr_t phys_offset;
aliguori34fc6432008-11-19 17:41:58 +000049 int slot;
50 int flags;
51} KVMSlot;
aliguori05330442008-11-05 16:29:27 +000052
aliguori5832d1f2008-11-24 19:36:26 +000053typedef struct kvm_dirty_log KVMDirtyLog;
54
aliguori05330442008-11-05 16:29:27 +000055struct KVMState
56{
57 KVMSlot slots[32];
58 int fd;
59 int vmfd;
aliguorif65ed4c2008-12-09 20:09:57 +000060 int coalesced_mmio;
Sheng Yang62a27442010-01-26 19:21:16 +080061#ifdef KVM_CAP_COALESCED_MMIO
62 struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
63#endif
Jan Kiszkae69917e2009-05-01 20:42:15 +020064 int broken_set_mem_region;
Jan Kiszka4495d6a2009-05-01 20:52:46 +020065 int migration_log;
Jan Kiszkaa0fb0022009-11-25 00:33:03 +010066 int vcpu_events;
Jan Kiszkab0b1d692010-03-01 19:10:29 +010067 int robust_singlestep;
Jan Kiszkaff44f1a2010-03-12 15:20:49 +010068 int debugregs;
aliguorie22a25c2009-03-12 20:12:48 +000069#ifdef KVM_CAP_SET_GUEST_DEBUG
70 struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
71#endif
Glauber Costa6f725c12009-07-21 12:26:58 -030072 int irqchip_in_kernel;
73 int pit_in_kernel;
Sheng Yangf1665b22010-06-17 17:53:07 +080074 int xsave, xcrs;
aliguori05330442008-11-05 16:29:27 +000075};
76
77static KVMState *kvm_state;
78
79static KVMSlot *kvm_alloc_slot(KVMState *s)
80{
81 int i;
82
83 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
aliguori62d60e82008-11-18 15:41:18 +000084 /* KVM private memory slots */
85 if (i >= 8 && i < 12)
86 continue;
aliguori05330442008-11-05 16:29:27 +000087 if (s->slots[i].memory_size == 0)
88 return &s->slots[i];
89 }
90
aliguorid3f8d372009-04-17 14:26:29 +000091 fprintf(stderr, "%s: no free slot available\n", __func__);
92 abort();
93}
94
95static KVMSlot *kvm_lookup_matching_slot(KVMState *s,
Anthony Liguoric227f092009-10-01 16:12:16 -050096 target_phys_addr_t start_addr,
97 target_phys_addr_t end_addr)
aliguorid3f8d372009-04-17 14:26:29 +000098{
99 int i;
100
101 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
102 KVMSlot *mem = &s->slots[i];
103
104 if (start_addr == mem->start_addr &&
105 end_addr == mem->start_addr + mem->memory_size) {
106 return mem;
107 }
108 }
109
aliguori05330442008-11-05 16:29:27 +0000110 return NULL;
111}
112
aliguori6152e2a2009-04-17 14:26:33 +0000113/*
114 * Find overlapping slot with lowest start address
115 */
116static KVMSlot *kvm_lookup_overlapping_slot(KVMState *s,
Anthony Liguoric227f092009-10-01 16:12:16 -0500117 target_phys_addr_t start_addr,
118 target_phys_addr_t end_addr)
aliguori05330442008-11-05 16:29:27 +0000119{
aliguori6152e2a2009-04-17 14:26:33 +0000120 KVMSlot *found = NULL;
aliguori05330442008-11-05 16:29:27 +0000121 int i;
122
123 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
124 KVMSlot *mem = &s->slots[i];
125
aliguori6152e2a2009-04-17 14:26:33 +0000126 if (mem->memory_size == 0 ||
127 (found && found->start_addr < mem->start_addr)) {
128 continue;
129 }
130
131 if (end_addr > mem->start_addr &&
132 start_addr < mem->start_addr + mem->memory_size) {
133 found = mem;
134 }
aliguori05330442008-11-05 16:29:27 +0000135 }
136
aliguori6152e2a2009-04-17 14:26:33 +0000137 return found;
aliguori05330442008-11-05 16:29:27 +0000138}
139
Huang Ying983dfc32010-10-11 15:31:20 -0300140int kvm_physical_memory_addr_from_ram(KVMState *s, ram_addr_t ram_addr,
141 target_phys_addr_t *phys_addr)
142{
143 int i;
144
145 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
146 KVMSlot *mem = &s->slots[i];
147
148 if (ram_addr >= mem->phys_offset &&
149 ram_addr < mem->phys_offset + mem->memory_size) {
150 *phys_addr = mem->start_addr + (ram_addr - mem->phys_offset);
151 return 1;
152 }
153 }
154
155 return 0;
156}
157
aliguori5832d1f2008-11-24 19:36:26 +0000158static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
159{
160 struct kvm_userspace_memory_region mem;
161
162 mem.slot = slot->slot;
163 mem.guest_phys_addr = slot->start_addr;
164 mem.memory_size = slot->memory_size;
pbrook5579c7f2009-04-11 14:47:08 +0000165 mem.userspace_addr = (unsigned long)qemu_get_ram_ptr(slot->phys_offset);
aliguori5832d1f2008-11-24 19:36:26 +0000166 mem.flags = slot->flags;
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200167 if (s->migration_log) {
168 mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
169 }
aliguori5832d1f2008-11-24 19:36:26 +0000170 return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
171}
172
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200173static void kvm_reset_vcpu(void *opaque)
174{
175 CPUState *env = opaque;
176
Jan Kiszkacaa5af02009-11-06 19:39:24 +0100177 kvm_arch_reset_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200178}
aliguori5832d1f2008-11-24 19:36:26 +0000179
Glauber Costa6f725c12009-07-21 12:26:58 -0300180int kvm_irqchip_in_kernel(void)
181{
182 return kvm_state->irqchip_in_kernel;
183}
184
185int kvm_pit_in_kernel(void)
186{
187 return kvm_state->pit_in_kernel;
188}
189
190
aliguori05330442008-11-05 16:29:27 +0000191int kvm_init_vcpu(CPUState *env)
192{
193 KVMState *s = kvm_state;
194 long mmap_size;
195 int ret;
196
Blue Swirl8c0d5772010-04-18 14:22:14 +0000197 DPRINTF("kvm_init_vcpu\n");
aliguori05330442008-11-05 16:29:27 +0000198
aliguori984b5182008-11-13 19:21:00 +0000199 ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
aliguori05330442008-11-05 16:29:27 +0000200 if (ret < 0) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000201 DPRINTF("kvm_create_vcpu failed\n");
aliguori05330442008-11-05 16:29:27 +0000202 goto err;
203 }
204
205 env->kvm_fd = ret;
206 env->kvm_state = s;
207
208 mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
209 if (mmap_size < 0) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000210 DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
aliguori05330442008-11-05 16:29:27 +0000211 goto err;
212 }
213
214 env->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
215 env->kvm_fd, 0);
216 if (env->kvm_run == MAP_FAILED) {
217 ret = -errno;
Blue Swirl8c0d5772010-04-18 14:22:14 +0000218 DPRINTF("mmap'ing vcpu state failed\n");
aliguori05330442008-11-05 16:29:27 +0000219 goto err;
220 }
221
Sheng Yang62a27442010-01-26 19:21:16 +0800222#ifdef KVM_CAP_COALESCED_MMIO
223 if (s->coalesced_mmio && !s->coalesced_mmio_ring)
224 s->coalesced_mmio_ring = (void *) env->kvm_run +
225 s->coalesced_mmio * PAGE_SIZE;
226#endif
227
aliguori05330442008-11-05 16:29:27 +0000228 ret = kvm_arch_init_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200229 if (ret == 0) {
Jan Kiszkaa08d4362009-06-27 09:25:07 +0200230 qemu_register_reset(kvm_reset_vcpu, env);
Jan Kiszkacaa5af02009-11-06 19:39:24 +0100231 kvm_arch_reset_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200232 }
aliguori05330442008-11-05 16:29:27 +0000233err:
234 return ret;
235}
236
aliguori5832d1f2008-11-24 19:36:26 +0000237/*
238 * dirty pages logging control
239 */
Anthony Liguoric227f092009-10-01 16:12:16 -0500240static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,
241 ram_addr_t size, int flags, int mask)
aliguori5832d1f2008-11-24 19:36:26 +0000242{
243 KVMState *s = kvm_state;
aliguorid3f8d372009-04-17 14:26:29 +0000244 KVMSlot *mem = kvm_lookup_matching_slot(s, phys_addr, phys_addr + size);
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200245 int old_flags;
246
aliguori5832d1f2008-11-24 19:36:26 +0000247 if (mem == NULL) {
aliguorid3f8d372009-04-17 14:26:29 +0000248 fprintf(stderr, "BUG: %s: invalid parameters " TARGET_FMT_plx "-"
249 TARGET_FMT_plx "\n", __func__, phys_addr,
Anthony Liguoric227f092009-10-01 16:12:16 -0500250 (target_phys_addr_t)(phys_addr + size - 1));
aliguori5832d1f2008-11-24 19:36:26 +0000251 return -EINVAL;
252 }
253
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200254 old_flags = mem->flags;
aliguori5832d1f2008-11-24 19:36:26 +0000255
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200256 flags = (mem->flags & ~mask) | flags;
aliguori5832d1f2008-11-24 19:36:26 +0000257 mem->flags = flags;
258
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200259 /* If nothing changed effectively, no need to issue ioctl */
260 if (s->migration_log) {
261 flags |= KVM_MEM_LOG_DIRTY_PAGES;
262 }
263 if (flags == old_flags) {
264 return 0;
265 }
266
aliguori5832d1f2008-11-24 19:36:26 +0000267 return kvm_set_user_memory_region(s, mem);
268}
269
Anthony Liguoric227f092009-10-01 16:12:16 -0500270int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t size)
aliguori5832d1f2008-11-24 19:36:26 +0000271{
aliguorid3f8d372009-04-17 14:26:29 +0000272 return kvm_dirty_pages_log_change(phys_addr, size,
aliguori5832d1f2008-11-24 19:36:26 +0000273 KVM_MEM_LOG_DIRTY_PAGES,
274 KVM_MEM_LOG_DIRTY_PAGES);
275}
276
Anthony Liguoric227f092009-10-01 16:12:16 -0500277int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t size)
aliguori5832d1f2008-11-24 19:36:26 +0000278{
aliguorid3f8d372009-04-17 14:26:29 +0000279 return kvm_dirty_pages_log_change(phys_addr, size,
aliguori5832d1f2008-11-24 19:36:26 +0000280 0,
281 KVM_MEM_LOG_DIRTY_PAGES);
282}
283
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200284static int kvm_set_migration_log(int enable)
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200285{
286 KVMState *s = kvm_state;
287 KVMSlot *mem;
288 int i, err;
289
290 s->migration_log = enable;
291
292 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
293 mem = &s->slots[i];
294
Alex Williamson70fedd72010-07-14 13:36:49 -0600295 if (!mem->memory_size) {
296 continue;
297 }
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200298 if (!!(mem->flags & KVM_MEM_LOG_DIRTY_PAGES) == enable) {
299 continue;
300 }
301 err = kvm_set_user_memory_region(s, mem);
302 if (err) {
303 return err;
304 }
305 }
306 return 0;
307}
308
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300309/* get kvm's dirty pages bitmap and update qemu's */
310static int kvm_get_dirty_pages_log_range(unsigned long start_addr,
311 unsigned long *bitmap,
312 unsigned long offset,
313 unsigned long mem_size)
Alexander Graf96c16062009-07-27 12:49:56 +0200314{
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300315 unsigned int i, j;
316 unsigned long page_number, addr, addr1, c;
317 ram_addr_t ram_addr;
318 unsigned int len = ((mem_size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) /
319 HOST_LONG_BITS;
320
321 /*
322 * bitmap-traveling is faster than memory-traveling (for addr...)
323 * especially when most of the memory is not dirty.
324 */
325 for (i = 0; i < len; i++) {
326 if (bitmap[i] != 0) {
327 c = leul_to_cpu(bitmap[i]);
328 do {
329 j = ffsl(c) - 1;
330 c &= ~(1ul << j);
331 page_number = i * HOST_LONG_BITS + j;
332 addr1 = page_number * TARGET_PAGE_SIZE;
333 addr = offset + addr1;
334 ram_addr = cpu_get_physical_page_desc(addr);
335 cpu_physical_memory_set_dirty(ram_addr);
336 } while (c != 0);
337 }
338 }
339 return 0;
Alexander Graf96c16062009-07-27 12:49:56 +0200340}
341
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300342#define ALIGN(x, y) (((x)+(y)-1) & ~((y)-1))
343
aliguori5832d1f2008-11-24 19:36:26 +0000344/**
345 * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
346 * This function updates qemu's dirty bitmap using cpu_physical_memory_set_dirty().
347 * This means all bits are set to dirty.
348 *
aliguorid3f8d372009-04-17 14:26:29 +0000349 * @start_add: start of logged region.
aliguori5832d1f2008-11-24 19:36:26 +0000350 * @end_addr: end of logged region.
351 */
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200352static int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
353 target_phys_addr_t end_addr)
aliguori5832d1f2008-11-24 19:36:26 +0000354{
355 KVMState *s = kvm_state;
Jan Kiszka151f7742009-05-01 20:52:47 +0200356 unsigned long size, allocated_size = 0;
Jan Kiszka151f7742009-05-01 20:52:47 +0200357 KVMDirtyLog d;
358 KVMSlot *mem;
359 int ret = 0;
aliguori5832d1f2008-11-24 19:36:26 +0000360
Jan Kiszka151f7742009-05-01 20:52:47 +0200361 d.dirty_bitmap = NULL;
362 while (start_addr < end_addr) {
363 mem = kvm_lookup_overlapping_slot(s, start_addr, end_addr);
364 if (mem == NULL) {
365 break;
366 }
367
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300368 size = ALIGN(((mem->memory_size) >> TARGET_PAGE_BITS), HOST_LONG_BITS) / 8;
Jan Kiszka151f7742009-05-01 20:52:47 +0200369 if (!d.dirty_bitmap) {
370 d.dirty_bitmap = qemu_malloc(size);
371 } else if (size > allocated_size) {
372 d.dirty_bitmap = qemu_realloc(d.dirty_bitmap, size);
373 }
374 allocated_size = size;
375 memset(d.dirty_bitmap, 0, allocated_size);
376
377 d.slot = mem->slot;
378
Anthony Liguori6e489f32009-07-27 15:23:59 -0500379 if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000380 DPRINTF("ioctl failed %d\n", errno);
Jan Kiszka151f7742009-05-01 20:52:47 +0200381 ret = -1;
382 break;
383 }
384
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300385 kvm_get_dirty_pages_log_range(mem->start_addr, d.dirty_bitmap,
386 mem->start_addr, mem->memory_size);
387 start_addr = mem->start_addr + mem->memory_size;
aliguori5832d1f2008-11-24 19:36:26 +0000388 }
aliguori5832d1f2008-11-24 19:36:26 +0000389 qemu_free(d.dirty_bitmap);
Jan Kiszka151f7742009-05-01 20:52:47 +0200390
391 return ret;
aliguori5832d1f2008-11-24 19:36:26 +0000392}
393
Anthony Liguoric227f092009-10-01 16:12:16 -0500394int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
aliguorif65ed4c2008-12-09 20:09:57 +0000395{
396 int ret = -ENOSYS;
397#ifdef KVM_CAP_COALESCED_MMIO
398 KVMState *s = kvm_state;
399
400 if (s->coalesced_mmio) {
401 struct kvm_coalesced_mmio_zone zone;
402
403 zone.addr = start;
404 zone.size = size;
405
406 ret = kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
407 }
408#endif
409
410 return ret;
411}
412
Anthony Liguoric227f092009-10-01 16:12:16 -0500413int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
aliguorif65ed4c2008-12-09 20:09:57 +0000414{
415 int ret = -ENOSYS;
416#ifdef KVM_CAP_COALESCED_MMIO
417 KVMState *s = kvm_state;
418
419 if (s->coalesced_mmio) {
420 struct kvm_coalesced_mmio_zone zone;
421
422 zone.addr = start;
423 zone.size = size;
424
425 ret = kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
426 }
427#endif
428
429 return ret;
430}
431
Anthony Liguoriad7b8b32009-05-08 15:33:24 -0500432int kvm_check_extension(KVMState *s, unsigned int extension)
433{
434 int ret;
435
436 ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
437 if (ret < 0) {
438 ret = 0;
439 }
440
441 return ret;
442}
443
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200444static void kvm_set_phys_mem(target_phys_addr_t start_addr,
445 ram_addr_t size,
446 ram_addr_t phys_offset)
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200447{
448 KVMState *s = kvm_state;
449 ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
450 KVMSlot *mem, old;
451 int err;
452
Gleb Natapov14542fe2010-07-28 18:13:23 +0300453 /* kvm works in page size chunks, but the function may be called
454 with sub-page size and unaligned start address. */
455 size = TARGET_PAGE_ALIGN(size);
456 start_addr = TARGET_PAGE_ALIGN(start_addr);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200457
458 /* KVM does not support read-only slots */
459 phys_offset &= ~IO_MEM_ROM;
460
461 while (1) {
462 mem = kvm_lookup_overlapping_slot(s, start_addr, start_addr + size);
463 if (!mem) {
464 break;
465 }
466
467 if (flags < IO_MEM_UNASSIGNED && start_addr >= mem->start_addr &&
468 (start_addr + size <= mem->start_addr + mem->memory_size) &&
469 (phys_offset - start_addr == mem->phys_offset - mem->start_addr)) {
470 /* The new slot fits into the existing one and comes with
471 * identical parameters - nothing to be done. */
472 return;
473 }
474
475 old = *mem;
476
477 /* unregister the overlapping slot */
478 mem->memory_size = 0;
479 err = kvm_set_user_memory_region(s, mem);
480 if (err) {
481 fprintf(stderr, "%s: error unregistering overlapping slot: %s\n",
482 __func__, strerror(-err));
483 abort();
484 }
485
486 /* Workaround for older KVM versions: we can't join slots, even not by
487 * unregistering the previous ones and then registering the larger
488 * slot. We have to maintain the existing fragmentation. Sigh.
489 *
490 * This workaround assumes that the new slot starts at the same
491 * address as the first existing one. If not or if some overlapping
492 * slot comes around later, we will fail (not seen in practice so far)
493 * - and actually require a recent KVM version. */
494 if (s->broken_set_mem_region &&
495 old.start_addr == start_addr && old.memory_size < size &&
496 flags < IO_MEM_UNASSIGNED) {
497 mem = kvm_alloc_slot(s);
498 mem->memory_size = old.memory_size;
499 mem->start_addr = old.start_addr;
500 mem->phys_offset = old.phys_offset;
501 mem->flags = 0;
502
503 err = kvm_set_user_memory_region(s, mem);
504 if (err) {
505 fprintf(stderr, "%s: error updating slot: %s\n", __func__,
506 strerror(-err));
507 abort();
508 }
509
510 start_addr += old.memory_size;
511 phys_offset += old.memory_size;
512 size -= old.memory_size;
513 continue;
514 }
515
516 /* register prefix slot */
517 if (old.start_addr < start_addr) {
518 mem = kvm_alloc_slot(s);
519 mem->memory_size = start_addr - old.start_addr;
520 mem->start_addr = old.start_addr;
521 mem->phys_offset = old.phys_offset;
522 mem->flags = 0;
523
524 err = kvm_set_user_memory_region(s, mem);
525 if (err) {
526 fprintf(stderr, "%s: error registering prefix slot: %s\n",
527 __func__, strerror(-err));
528 abort();
529 }
530 }
531
532 /* register suffix slot */
533 if (old.start_addr + old.memory_size > start_addr + size) {
534 ram_addr_t size_delta;
535
536 mem = kvm_alloc_slot(s);
537 mem->start_addr = start_addr + size;
538 size_delta = mem->start_addr - old.start_addr;
539 mem->memory_size = old.memory_size - size_delta;
540 mem->phys_offset = old.phys_offset + size_delta;
541 mem->flags = 0;
542
543 err = kvm_set_user_memory_region(s, mem);
544 if (err) {
545 fprintf(stderr, "%s: error registering suffix slot: %s\n",
546 __func__, strerror(-err));
547 abort();
548 }
549 }
550 }
551
552 /* in case the KVM bug workaround already "consumed" the new slot */
553 if (!size)
554 return;
555
556 /* KVM does not need to know about this memory */
557 if (flags >= IO_MEM_UNASSIGNED)
558 return;
559
560 mem = kvm_alloc_slot(s);
561 mem->memory_size = size;
562 mem->start_addr = start_addr;
563 mem->phys_offset = phys_offset;
564 mem->flags = 0;
565
566 err = kvm_set_user_memory_region(s, mem);
567 if (err) {
568 fprintf(stderr, "%s: error registering slot: %s\n", __func__,
569 strerror(-err));
570 abort();
571 }
572}
573
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200574static void kvm_client_set_memory(struct CPUPhysMemoryClient *client,
575 target_phys_addr_t start_addr,
576 ram_addr_t size,
577 ram_addr_t phys_offset)
578{
579 kvm_set_phys_mem(start_addr, size, phys_offset);
580}
581
582static int kvm_client_sync_dirty_bitmap(struct CPUPhysMemoryClient *client,
583 target_phys_addr_t start_addr,
584 target_phys_addr_t end_addr)
585{
586 return kvm_physical_sync_dirty_bitmap(start_addr, end_addr);
587}
588
589static int kvm_client_migration_log(struct CPUPhysMemoryClient *client,
590 int enable)
591{
592 return kvm_set_migration_log(enable);
593}
594
595static CPUPhysMemoryClient kvm_cpu_phys_memory_client = {
596 .set_memory = kvm_client_set_memory,
597 .sync_dirty_bitmap = kvm_client_sync_dirty_bitmap,
598 .migration_log = kvm_client_migration_log,
599};
600
aliguori05330442008-11-05 16:29:27 +0000601int kvm_init(int smp_cpus)
602{
Jan Kiszka168ccc12009-06-07 11:30:25 +0200603 static const char upgrade_note[] =
604 "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
605 "(see http://sourceforge.net/projects/kvm).\n";
aliguori05330442008-11-05 16:29:27 +0000606 KVMState *s;
607 int ret;
608 int i;
609
aliguori05330442008-11-05 16:29:27 +0000610 s = qemu_mallocz(sizeof(KVMState));
aliguori05330442008-11-05 16:29:27 +0000611
aliguorie22a25c2009-03-12 20:12:48 +0000612#ifdef KVM_CAP_SET_GUEST_DEBUG
Blue Swirl72cf2d42009-09-12 07:36:22 +0000613 QTAILQ_INIT(&s->kvm_sw_breakpoints);
aliguorie22a25c2009-03-12 20:12:48 +0000614#endif
aliguori05330442008-11-05 16:29:27 +0000615 for (i = 0; i < ARRAY_SIZE(s->slots); i++)
616 s->slots[i].slot = i;
617
618 s->vmfd = -1;
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100619 s->fd = qemu_open("/dev/kvm", O_RDWR);
aliguori05330442008-11-05 16:29:27 +0000620 if (s->fd == -1) {
621 fprintf(stderr, "Could not access KVM kernel module: %m\n");
622 ret = -errno;
623 goto err;
624 }
625
626 ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
627 if (ret < KVM_API_VERSION) {
628 if (ret > 0)
629 ret = -EINVAL;
630 fprintf(stderr, "kvm version too old\n");
631 goto err;
632 }
633
634 if (ret > KVM_API_VERSION) {
635 ret = -EINVAL;
636 fprintf(stderr, "kvm version not supported\n");
637 goto err;
638 }
639
640 s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
Alexander Graf0104dca2010-04-01 18:42:37 +0200641 if (s->vmfd < 0) {
642#ifdef TARGET_S390X
643 fprintf(stderr, "Please add the 'switch_amode' kernel parameter to "
644 "your host kernel command line\n");
645#endif
aliguori05330442008-11-05 16:29:27 +0000646 goto err;
Alexander Graf0104dca2010-04-01 18:42:37 +0200647 }
aliguori05330442008-11-05 16:29:27 +0000648
649 /* initially, KVM allocated its own memory and we had to jump through
650 * hooks to make phys_ram_base point to this. Modern versions of KVM
pbrook5579c7f2009-04-11 14:47:08 +0000651 * just use a user allocated buffer so we can use regular pages
aliguori05330442008-11-05 16:29:27 +0000652 * unmodified. Make sure we have a sufficiently modern version of KVM.
653 */
Anthony Liguoriad7b8b32009-05-08 15:33:24 -0500654 if (!kvm_check_extension(s, KVM_CAP_USER_MEMORY)) {
655 ret = -EINVAL;
Jan Kiszka168ccc12009-06-07 11:30:25 +0200656 fprintf(stderr, "kvm does not support KVM_CAP_USER_MEMORY\n%s",
657 upgrade_note);
aliguori05330442008-11-05 16:29:27 +0000658 goto err;
659 }
660
aliguorid85dc282008-12-09 19:59:09 +0000661 /* There was a nasty bug in < kvm-80 that prevents memory slots from being
662 * destroyed properly. Since we rely on this capability, refuse to work
663 * with any kernel without this capability. */
Anthony Liguoriad7b8b32009-05-08 15:33:24 -0500664 if (!kvm_check_extension(s, KVM_CAP_DESTROY_MEMORY_REGION_WORKS)) {
665 ret = -EINVAL;
aliguorid85dc282008-12-09 19:59:09 +0000666
667 fprintf(stderr,
Jan Kiszka168ccc12009-06-07 11:30:25 +0200668 "KVM kernel module broken (DESTROY_MEMORY_REGION).\n%s",
669 upgrade_note);
aliguorid85dc282008-12-09 19:59:09 +0000670 goto err;
671 }
672
Sheng Yang62a27442010-01-26 19:21:16 +0800673 s->coalesced_mmio = 0;
aliguorif65ed4c2008-12-09 20:09:57 +0000674#ifdef KVM_CAP_COALESCED_MMIO
Anthony Liguoriad7b8b32009-05-08 15:33:24 -0500675 s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
Sheng Yang62a27442010-01-26 19:21:16 +0800676 s->coalesced_mmio_ring = NULL;
aliguorif65ed4c2008-12-09 20:09:57 +0000677#endif
678
Jan Kiszkae69917e2009-05-01 20:42:15 +0200679 s->broken_set_mem_region = 1;
680#ifdef KVM_CAP_JOIN_MEMORY_REGIONS_WORKS
681 ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
682 if (ret > 0) {
683 s->broken_set_mem_region = 0;
684 }
685#endif
686
Jan Kiszkaa0fb0022009-11-25 00:33:03 +0100687 s->vcpu_events = 0;
688#ifdef KVM_CAP_VCPU_EVENTS
689 s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
690#endif
691
Jan Kiszkab0b1d692010-03-01 19:10:29 +0100692 s->robust_singlestep = 0;
693#ifdef KVM_CAP_X86_ROBUST_SINGLESTEP
694 s->robust_singlestep =
695 kvm_check_extension(s, KVM_CAP_X86_ROBUST_SINGLESTEP);
696#endif
697
Jan Kiszkaff44f1a2010-03-12 15:20:49 +0100698 s->debugregs = 0;
699#ifdef KVM_CAP_DEBUGREGS
700 s->debugregs = kvm_check_extension(s, KVM_CAP_DEBUGREGS);
701#endif
702
Sheng Yangf1665b22010-06-17 17:53:07 +0800703 s->xsave = 0;
704#ifdef KVM_CAP_XSAVE
705 s->xsave = kvm_check_extension(s, KVM_CAP_XSAVE);
706#endif
707
708 s->xcrs = 0;
709#ifdef KVM_CAP_XCRS
710 s->xcrs = kvm_check_extension(s, KVM_CAP_XCRS);
711#endif
712
aliguori05330442008-11-05 16:29:27 +0000713 ret = kvm_arch_init(s, smp_cpus);
714 if (ret < 0)
715 goto err;
716
717 kvm_state = s;
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200718 cpu_register_phys_memory_client(&kvm_cpu_phys_memory_client);
aliguori05330442008-11-05 16:29:27 +0000719
720 return 0;
721
722err:
723 if (s) {
724 if (s->vmfd != -1)
725 close(s->vmfd);
726 if (s->fd != -1)
727 close(s->fd);
728 }
729 qemu_free(s);
730
731 return ret;
732}
733
Blue Swirlafcea8c2009-09-20 16:05:47 +0000734static int kvm_handle_io(uint16_t port, void *data, int direction, int size,
735 uint32_t count)
aliguori05330442008-11-05 16:29:27 +0000736{
737 int i;
738 uint8_t *ptr = data;
739
740 for (i = 0; i < count; i++) {
741 if (direction == KVM_EXIT_IO_IN) {
742 switch (size) {
743 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000744 stb_p(ptr, cpu_inb(port));
aliguori05330442008-11-05 16:29:27 +0000745 break;
746 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000747 stw_p(ptr, cpu_inw(port));
aliguori05330442008-11-05 16:29:27 +0000748 break;
749 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000750 stl_p(ptr, cpu_inl(port));
aliguori05330442008-11-05 16:29:27 +0000751 break;
752 }
753 } else {
754 switch (size) {
755 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000756 cpu_outb(port, ldub_p(ptr));
aliguori05330442008-11-05 16:29:27 +0000757 break;
758 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000759 cpu_outw(port, lduw_p(ptr));
aliguori05330442008-11-05 16:29:27 +0000760 break;
761 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000762 cpu_outl(port, ldl_p(ptr));
aliguori05330442008-11-05 16:29:27 +0000763 break;
764 }
765 }
766
767 ptr += size;
768 }
769
770 return 1;
771}
772
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300773#ifdef KVM_CAP_INTERNAL_ERROR_DATA
774static void kvm_handle_internal_error(CPUState *env, struct kvm_run *run)
775{
776
777 if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) {
778 int i;
779
780 fprintf(stderr, "KVM internal error. Suberror: %d\n",
781 run->internal.suberror);
782
783 for (i = 0; i < run->internal.ndata; ++i) {
784 fprintf(stderr, "extra data[%d]: %"PRIx64"\n",
785 i, (uint64_t)run->internal.data[i]);
786 }
787 }
788 cpu_dump_state(env, stderr, fprintf, 0);
789 if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {
790 fprintf(stderr, "emulation failure\n");
Gleb Natapov4513d922010-05-10 11:21:34 +0300791 if (!kvm_arch_stop_on_emulation_error(env))
792 return;
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300793 }
794 /* FIXME: Should trigger a qmp message to let management know
795 * something went wrong.
796 */
797 vm_stop(0);
798}
799#endif
800
Sheng Yang62a27442010-01-26 19:21:16 +0800801void kvm_flush_coalesced_mmio_buffer(void)
aliguorif65ed4c2008-12-09 20:09:57 +0000802{
803#ifdef KVM_CAP_COALESCED_MMIO
804 KVMState *s = kvm_state;
Sheng Yang62a27442010-01-26 19:21:16 +0800805 if (s->coalesced_mmio_ring) {
806 struct kvm_coalesced_mmio_ring *ring = s->coalesced_mmio_ring;
aliguorif65ed4c2008-12-09 20:09:57 +0000807 while (ring->first != ring->last) {
808 struct kvm_coalesced_mmio *ent;
809
810 ent = &ring->coalesced_mmio[ring->first];
811
812 cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
Marcelo Tosatti85199472010-02-22 13:57:54 -0300813 smp_wmb();
aliguorif65ed4c2008-12-09 20:09:57 +0000814 ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
815 }
816 }
817#endif
818}
819
Jan Kiszka2705d562010-05-04 09:45:23 -0300820static void do_kvm_cpu_synchronize_state(void *_env)
Avi Kivity4c0960c2009-08-17 23:19:53 +0300821{
Jan Kiszka2705d562010-05-04 09:45:23 -0300822 CPUState *env = _env;
823
Jan Kiszka9ded2742010-02-03 21:17:05 +0100824 if (!env->kvm_vcpu_dirty) {
Avi Kivity4c0960c2009-08-17 23:19:53 +0300825 kvm_arch_get_registers(env);
Jan Kiszka9ded2742010-02-03 21:17:05 +0100826 env->kvm_vcpu_dirty = 1;
Avi Kivity4c0960c2009-08-17 23:19:53 +0300827 }
828}
829
Jan Kiszka2705d562010-05-04 09:45:23 -0300830void kvm_cpu_synchronize_state(CPUState *env)
831{
832 if (!env->kvm_vcpu_dirty)
833 run_on_cpu(env, do_kvm_cpu_synchronize_state, env);
834}
835
Jan Kiszkaea375f92010-03-01 19:10:30 +0100836void kvm_cpu_synchronize_post_reset(CPUState *env)
837{
838 kvm_arch_put_registers(env, KVM_PUT_RESET_STATE);
839 env->kvm_vcpu_dirty = 0;
840}
841
842void kvm_cpu_synchronize_post_init(CPUState *env)
843{
844 kvm_arch_put_registers(env, KVM_PUT_FULL_STATE);
845 env->kvm_vcpu_dirty = 0;
846}
847
aliguori05330442008-11-05 16:29:27 +0000848int kvm_cpu_exec(CPUState *env)
849{
850 struct kvm_run *run = env->kvm_run;
851 int ret;
852
Blue Swirl8c0d5772010-04-18 14:22:14 +0000853 DPRINTF("kvm_cpu_exec()\n");
aliguori05330442008-11-05 16:29:27 +0000854
855 do {
Marcelo Tosatti6312b922010-02-17 20:14:43 -0200856#ifndef CONFIG_IOTHREAD
aurel32be214e62009-03-06 21:48:00 +0000857 if (env->exit_request) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000858 DPRINTF("interrupt exit requested\n");
aliguori05330442008-11-05 16:29:27 +0000859 ret = 0;
860 break;
861 }
Marcelo Tosatti6312b922010-02-17 20:14:43 -0200862#endif
aliguori05330442008-11-05 16:29:27 +0000863
Marcelo Tosatti0af691d2010-05-04 09:45:27 -0300864 if (kvm_arch_process_irqchip_events(env)) {
865 ret = 0;
866 break;
867 }
868
Jan Kiszka9ded2742010-02-03 21:17:05 +0100869 if (env->kvm_vcpu_dirty) {
Jan Kiszkaea375f92010-03-01 19:10:30 +0100870 kvm_arch_put_registers(env, KVM_PUT_RUNTIME_STATE);
Jan Kiszka9ded2742010-02-03 21:17:05 +0100871 env->kvm_vcpu_dirty = 0;
Avi Kivity4c0960c2009-08-17 23:19:53 +0300872 }
873
Jan Kiszka8c14c172009-05-30 10:01:45 +0200874 kvm_arch_pre_run(env, run);
Marcelo Tosatti273faf12010-05-04 09:45:19 -0300875 cpu_single_env = NULL;
Glauber Costad549db52009-10-07 16:38:03 -0300876 qemu_mutex_unlock_iothread();
aliguori05330442008-11-05 16:29:27 +0000877 ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
Glauber Costad549db52009-10-07 16:38:03 -0300878 qemu_mutex_lock_iothread();
Marcelo Tosatti273faf12010-05-04 09:45:19 -0300879 cpu_single_env = env;
aliguori05330442008-11-05 16:29:27 +0000880 kvm_arch_post_run(env, run);
881
882 if (ret == -EINTR || ret == -EAGAIN) {
Marcelo Tosatticc84de92010-02-17 20:14:42 -0200883 cpu_exit(env);
Blue Swirl8c0d5772010-04-18 14:22:14 +0000884 DPRINTF("io window exit\n");
aliguori05330442008-11-05 16:29:27 +0000885 ret = 0;
886 break;
887 }
888
889 if (ret < 0) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000890 DPRINTF("kvm run failed %s\n", strerror(-ret));
aliguori05330442008-11-05 16:29:27 +0000891 abort();
892 }
893
Sheng Yang62a27442010-01-26 19:21:16 +0800894 kvm_flush_coalesced_mmio_buffer();
aliguorif65ed4c2008-12-09 20:09:57 +0000895
aliguori05330442008-11-05 16:29:27 +0000896 ret = 0; /* exit loop */
897 switch (run->exit_reason) {
898 case KVM_EXIT_IO:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000899 DPRINTF("handle_io\n");
Blue Swirlafcea8c2009-09-20 16:05:47 +0000900 ret = kvm_handle_io(run->io.port,
aliguori05330442008-11-05 16:29:27 +0000901 (uint8_t *)run + run->io.data_offset,
902 run->io.direction,
903 run->io.size,
904 run->io.count);
905 break;
906 case KVM_EXIT_MMIO:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000907 DPRINTF("handle_mmio\n");
aliguori05330442008-11-05 16:29:27 +0000908 cpu_physical_memory_rw(run->mmio.phys_addr,
909 run->mmio.data,
910 run->mmio.len,
911 run->mmio.is_write);
912 ret = 1;
913 break;
914 case KVM_EXIT_IRQ_WINDOW_OPEN:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000915 DPRINTF("irq_window_open\n");
aliguori05330442008-11-05 16:29:27 +0000916 break;
917 case KVM_EXIT_SHUTDOWN:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000918 DPRINTF("shutdown\n");
aliguori05330442008-11-05 16:29:27 +0000919 qemu_system_reset_request();
920 ret = 1;
921 break;
922 case KVM_EXIT_UNKNOWN:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000923 DPRINTF("kvm_exit_unknown\n");
aliguori05330442008-11-05 16:29:27 +0000924 break;
925 case KVM_EXIT_FAIL_ENTRY:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000926 DPRINTF("kvm_exit_fail_entry\n");
aliguori05330442008-11-05 16:29:27 +0000927 break;
928 case KVM_EXIT_EXCEPTION:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000929 DPRINTF("kvm_exit_exception\n");
aliguori05330442008-11-05 16:29:27 +0000930 break;
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300931#ifdef KVM_CAP_INTERNAL_ERROR_DATA
932 case KVM_EXIT_INTERNAL_ERROR:
933 kvm_handle_internal_error(env, run);
934 break;
935#endif
aliguori05330442008-11-05 16:29:27 +0000936 case KVM_EXIT_DEBUG:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000937 DPRINTF("kvm_exit_debug\n");
aliguorie22a25c2009-03-12 20:12:48 +0000938#ifdef KVM_CAP_SET_GUEST_DEBUG
939 if (kvm_arch_debug(&run->debug.arch)) {
aliguorie22a25c2009-03-12 20:12:48 +0000940 env->exception_index = EXCP_DEBUG;
941 return 0;
942 }
943 /* re-enter, this exception was guest-internal */
944 ret = 1;
945#endif /* KVM_CAP_SET_GUEST_DEBUG */
aliguori05330442008-11-05 16:29:27 +0000946 break;
947 default:
Blue Swirl8c0d5772010-04-18 14:22:14 +0000948 DPRINTF("kvm_arch_handle_exit\n");
aliguori05330442008-11-05 16:29:27 +0000949 ret = kvm_arch_handle_exit(env, run);
950 break;
951 }
952 } while (ret > 0);
953
aurel32be214e62009-03-06 21:48:00 +0000954 if (env->exit_request) {
955 env->exit_request = 0;
aliguoribecfc392008-11-10 15:55:14 +0000956 env->exception_index = EXCP_INTERRUPT;
957 }
958
aliguori05330442008-11-05 16:29:27 +0000959 return ret;
960}
961
aliguori984b5182008-11-13 19:21:00 +0000962int kvm_ioctl(KVMState *s, int type, ...)
aliguori05330442008-11-05 16:29:27 +0000963{
964 int ret;
aliguori984b5182008-11-13 19:21:00 +0000965 void *arg;
966 va_list ap;
aliguori05330442008-11-05 16:29:27 +0000967
aliguori984b5182008-11-13 19:21:00 +0000968 va_start(ap, type);
969 arg = va_arg(ap, void *);
970 va_end(ap);
971
972 ret = ioctl(s->fd, type, arg);
aliguori05330442008-11-05 16:29:27 +0000973 if (ret == -1)
974 ret = -errno;
975
976 return ret;
977}
978
aliguori984b5182008-11-13 19:21:00 +0000979int kvm_vm_ioctl(KVMState *s, int type, ...)
aliguori05330442008-11-05 16:29:27 +0000980{
981 int ret;
aliguori984b5182008-11-13 19:21:00 +0000982 void *arg;
983 va_list ap;
aliguori05330442008-11-05 16:29:27 +0000984
aliguori984b5182008-11-13 19:21:00 +0000985 va_start(ap, type);
986 arg = va_arg(ap, void *);
987 va_end(ap);
988
989 ret = ioctl(s->vmfd, type, arg);
aliguori05330442008-11-05 16:29:27 +0000990 if (ret == -1)
991 ret = -errno;
992
993 return ret;
994}
995
aliguori984b5182008-11-13 19:21:00 +0000996int kvm_vcpu_ioctl(CPUState *env, int type, ...)
aliguori05330442008-11-05 16:29:27 +0000997{
998 int ret;
aliguori984b5182008-11-13 19:21:00 +0000999 void *arg;
1000 va_list ap;
aliguori05330442008-11-05 16:29:27 +00001001
aliguori984b5182008-11-13 19:21:00 +00001002 va_start(ap, type);
1003 arg = va_arg(ap, void *);
1004 va_end(ap);
1005
1006 ret = ioctl(env->kvm_fd, type, arg);
aliguori05330442008-11-05 16:29:27 +00001007 if (ret == -1)
1008 ret = -errno;
1009
1010 return ret;
1011}
aliguoribd322082008-12-04 20:33:06 +00001012
1013int kvm_has_sync_mmu(void)
1014{
aurel32a9c11522008-12-18 22:42:51 +00001015#ifdef KVM_CAP_SYNC_MMU
aliguoribd322082008-12-04 20:33:06 +00001016 KVMState *s = kvm_state;
1017
Anthony Liguoriad7b8b32009-05-08 15:33:24 -05001018 return kvm_check_extension(s, KVM_CAP_SYNC_MMU);
1019#else
aliguoribd322082008-12-04 20:33:06 +00001020 return 0;
Anthony Liguoriad7b8b32009-05-08 15:33:24 -05001021#endif
aliguoribd322082008-12-04 20:33:06 +00001022}
aliguorie22a25c2009-03-12 20:12:48 +00001023
Jan Kiszkaa0fb0022009-11-25 00:33:03 +01001024int kvm_has_vcpu_events(void)
1025{
1026 return kvm_state->vcpu_events;
1027}
1028
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001029int kvm_has_robust_singlestep(void)
1030{
1031 return kvm_state->robust_singlestep;
1032}
1033
Jan Kiszkaff44f1a2010-03-12 15:20:49 +01001034int kvm_has_debugregs(void)
1035{
1036 return kvm_state->debugregs;
1037}
1038
Sheng Yangf1665b22010-06-17 17:53:07 +08001039int kvm_has_xsave(void)
1040{
1041 return kvm_state->xsave;
1042}
1043
1044int kvm_has_xcrs(void)
1045{
1046 return kvm_state->xcrs;
1047}
1048
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001049void kvm_setup_guest_memory(void *start, size_t size)
1050{
1051 if (!kvm_has_sync_mmu()) {
Andreas Färbere78815a2010-09-25 11:26:05 +00001052 int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK);
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001053
1054 if (ret) {
Andreas Färbere78815a2010-09-25 11:26:05 +00001055 perror("qemu_madvise");
1056 fprintf(stderr,
1057 "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001058 exit(1);
1059 }
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001060 }
1061}
1062
aliguorie22a25c2009-03-12 20:12:48 +00001063#ifdef KVM_CAP_SET_GUEST_DEBUG
1064struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
1065 target_ulong pc)
1066{
1067 struct kvm_sw_breakpoint *bp;
1068
Blue Swirl72cf2d42009-09-12 07:36:22 +00001069 QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) {
aliguorie22a25c2009-03-12 20:12:48 +00001070 if (bp->pc == pc)
1071 return bp;
1072 }
1073 return NULL;
1074}
1075
1076int kvm_sw_breakpoints_active(CPUState *env)
1077{
Blue Swirl72cf2d42009-09-12 07:36:22 +00001078 return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints);
aliguorie22a25c2009-03-12 20:12:48 +00001079}
1080
Glauber Costa452e4752009-07-16 17:55:28 -04001081struct kvm_set_guest_debug_data {
1082 struct kvm_guest_debug dbg;
1083 CPUState *env;
1084 int err;
1085};
1086
1087static void kvm_invoke_set_guest_debug(void *data)
1088{
1089 struct kvm_set_guest_debug_data *dbg_data = data;
Jan Kiszkab3807722009-09-17 20:05:58 +02001090 CPUState *env = dbg_data->env;
1091
Jan Kiszkab3807722009-09-17 20:05:58 +02001092 dbg_data->err = kvm_vcpu_ioctl(env, KVM_SET_GUEST_DEBUG, &dbg_data->dbg);
Glauber Costa452e4752009-07-16 17:55:28 -04001093}
1094
aliguorie22a25c2009-03-12 20:12:48 +00001095int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
1096{
Glauber Costa452e4752009-07-16 17:55:28 -04001097 struct kvm_set_guest_debug_data data;
aliguorie22a25c2009-03-12 20:12:48 +00001098
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001099 data.dbg.control = reinject_trap;
aliguorie22a25c2009-03-12 20:12:48 +00001100
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001101 if (env->singlestep_enabled) {
1102 data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
1103 }
Glauber Costa452e4752009-07-16 17:55:28 -04001104 kvm_arch_update_guest_debug(env, &data.dbg);
Glauber Costa452e4752009-07-16 17:55:28 -04001105 data.env = env;
aliguorie22a25c2009-03-12 20:12:48 +00001106
Jan Kiszkabe41cbe2010-05-20 00:28:45 +02001107 run_on_cpu(env, kvm_invoke_set_guest_debug, &data);
Glauber Costa452e4752009-07-16 17:55:28 -04001108 return data.err;
aliguorie22a25c2009-03-12 20:12:48 +00001109}
1110
1111int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
1112 target_ulong len, int type)
1113{
1114 struct kvm_sw_breakpoint *bp;
1115 CPUState *env;
1116 int err;
1117
1118 if (type == GDB_BREAKPOINT_SW) {
1119 bp = kvm_find_sw_breakpoint(current_env, addr);
1120 if (bp) {
1121 bp->use_count++;
1122 return 0;
1123 }
1124
1125 bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
1126 if (!bp)
1127 return -ENOMEM;
1128
1129 bp->pc = addr;
1130 bp->use_count = 1;
1131 err = kvm_arch_insert_sw_breakpoint(current_env, bp);
1132 if (err) {
1133 free(bp);
1134 return err;
1135 }
1136
Blue Swirl72cf2d42009-09-12 07:36:22 +00001137 QTAILQ_INSERT_HEAD(&current_env->kvm_state->kvm_sw_breakpoints,
aliguorie22a25c2009-03-12 20:12:48 +00001138 bp, entry);
1139 } else {
1140 err = kvm_arch_insert_hw_breakpoint(addr, len, type);
1141 if (err)
1142 return err;
1143 }
1144
1145 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1146 err = kvm_update_guest_debug(env, 0);
1147 if (err)
1148 return err;
1149 }
1150 return 0;
1151}
1152
1153int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
1154 target_ulong len, int type)
1155{
1156 struct kvm_sw_breakpoint *bp;
1157 CPUState *env;
1158 int err;
1159
1160 if (type == GDB_BREAKPOINT_SW) {
1161 bp = kvm_find_sw_breakpoint(current_env, addr);
1162 if (!bp)
1163 return -ENOENT;
1164
1165 if (bp->use_count > 1) {
1166 bp->use_count--;
1167 return 0;
1168 }
1169
1170 err = kvm_arch_remove_sw_breakpoint(current_env, bp);
1171 if (err)
1172 return err;
1173
Blue Swirl72cf2d42009-09-12 07:36:22 +00001174 QTAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry);
aliguorie22a25c2009-03-12 20:12:48 +00001175 qemu_free(bp);
1176 } else {
1177 err = kvm_arch_remove_hw_breakpoint(addr, len, type);
1178 if (err)
1179 return err;
1180 }
1181
1182 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1183 err = kvm_update_guest_debug(env, 0);
1184 if (err)
1185 return err;
1186 }
1187 return 0;
1188}
1189
1190void kvm_remove_all_breakpoints(CPUState *current_env)
1191{
1192 struct kvm_sw_breakpoint *bp, *next;
1193 KVMState *s = current_env->kvm_state;
1194 CPUState *env;
1195
Blue Swirl72cf2d42009-09-12 07:36:22 +00001196 QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
aliguorie22a25c2009-03-12 20:12:48 +00001197 if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
1198 /* Try harder to find a CPU that currently sees the breakpoint. */
1199 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1200 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0)
1201 break;
1202 }
1203 }
1204 }
1205 kvm_arch_remove_all_hw_breakpoints();
1206
1207 for (env = first_cpu; env != NULL; env = env->next_cpu)
1208 kvm_update_guest_debug(env, 0);
1209}
1210
1211#else /* !KVM_CAP_SET_GUEST_DEBUG */
1212
1213int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
1214{
1215 return -EINVAL;
1216}
1217
1218int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
1219 target_ulong len, int type)
1220{
1221 return -EINVAL;
1222}
1223
1224int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
1225 target_ulong len, int type)
1226{
1227 return -EINVAL;
1228}
1229
1230void kvm_remove_all_breakpoints(CPUState *current_env)
1231{
1232}
1233#endif /* !KVM_CAP_SET_GUEST_DEBUG */
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001234
1235int kvm_set_signal_mask(CPUState *env, const sigset_t *sigset)
1236{
1237 struct kvm_signal_mask *sigmask;
1238 int r;
1239
1240 if (!sigset)
1241 return kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, NULL);
1242
1243 sigmask = qemu_malloc(sizeof(*sigmask) + sizeof(*sigset));
1244
1245 sigmask->len = 8;
1246 memcpy(sigmask->sigset, sigset, sizeof(*sigset));
1247 r = kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, sigmask);
1248 free(sigmask);
1249
1250 return r;
1251}
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001252
Cam Macdonell44f1a3d2010-07-26 18:10:59 -06001253int kvm_set_ioeventfd_mmio_long(int fd, uint32_t addr, uint32_t val, bool assign)
1254{
1255#ifdef KVM_IOEVENTFD
1256 int ret;
1257 struct kvm_ioeventfd iofd;
1258
1259 iofd.datamatch = val;
1260 iofd.addr = addr;
1261 iofd.len = 4;
1262 iofd.flags = KVM_IOEVENTFD_FLAG_DATAMATCH;
1263 iofd.fd = fd;
1264
1265 if (!kvm_enabled()) {
1266 return -ENOSYS;
1267 }
1268
1269 if (!assign) {
1270 iofd.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
1271 }
1272
1273 ret = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &iofd);
1274
1275 if (ret < 0) {
1276 return -errno;
1277 }
1278
1279 return 0;
1280#else
1281 return -ENOSYS;
1282#endif
1283}
1284
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001285int kvm_set_ioeventfd_pio_word(int fd, uint16_t addr, uint16_t val, bool assign)
1286{
Paolo Bonzini98c85732010-04-19 18:59:30 +00001287#ifdef KVM_IOEVENTFD
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001288 struct kvm_ioeventfd kick = {
1289 .datamatch = val,
1290 .addr = addr,
1291 .len = 2,
1292 .flags = KVM_IOEVENTFD_FLAG_DATAMATCH | KVM_IOEVENTFD_FLAG_PIO,
1293 .fd = fd,
1294 };
1295 int r;
1296 if (!kvm_enabled())
1297 return -ENOSYS;
1298 if (!assign)
1299 kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
1300 r = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
1301 if (r < 0)
1302 return r;
1303 return 0;
Paolo Bonzini98c85732010-04-19 18:59:30 +00001304#else
1305 return -ENOSYS;
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001306#endif
Paolo Bonzini98c85732010-04-19 18:59:30 +00001307}