blob: 9e84d35e94be70227d635cd49b78d8d71a055077 [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"
Avi Kivitya01672d2011-12-18 14:06:05 +020030#include "memory.h"
aliguori05330442008-11-05 16:29:27 +000031
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +020032/* This check must be after config-host.h is included */
33#ifdef CONFIG_EVENTFD
34#include <sys/eventfd.h>
35#endif
36
aliguorif65ed4c2008-12-09 20:09:57 +000037/* KVM uses PAGE_SIZE in it's definition of COALESCED_MMIO_MAX */
38#define PAGE_SIZE TARGET_PAGE_SIZE
39
aliguori05330442008-11-05 16:29:27 +000040//#define DEBUG_KVM
41
42#ifdef DEBUG_KVM
Blue Swirl8c0d5772010-04-18 14:22:14 +000043#define DPRINTF(fmt, ...) \
aliguori05330442008-11-05 16:29:27 +000044 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
45#else
Blue Swirl8c0d5772010-04-18 14:22:14 +000046#define DPRINTF(fmt, ...) \
aliguori05330442008-11-05 16:29:27 +000047 do { } while (0)
48#endif
49
aliguori34fc6432008-11-19 17:41:58 +000050typedef struct KVMSlot
51{
Anthony Liguoric227f092009-10-01 16:12:16 -050052 target_phys_addr_t start_addr;
53 ram_addr_t memory_size;
Avi Kivity9f213ed2011-12-15 19:55:26 +020054 void *ram;
aliguori34fc6432008-11-19 17:41:58 +000055 int slot;
56 int flags;
57} KVMSlot;
aliguori05330442008-11-05 16:29:27 +000058
aliguori5832d1f2008-11-24 19:36:26 +000059typedef struct kvm_dirty_log KVMDirtyLog;
60
aliguori05330442008-11-05 16:29:27 +000061struct KVMState
62{
63 KVMSlot slots[32];
64 int fd;
65 int vmfd;
aliguorif65ed4c2008-12-09 20:09:57 +000066 int coalesced_mmio;
Sheng Yang62a27442010-01-26 19:21:16 +080067 struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
Avi Kivity1cae88b2011-10-18 19:43:12 +020068 bool coalesced_flush_in_progress;
Jan Kiszkae69917e2009-05-01 20:42:15 +020069 int broken_set_mem_region;
Jan Kiszka4495d6a2009-05-01 20:52:46 +020070 int migration_log;
Jan Kiszkaa0fb0022009-11-25 00:33:03 +010071 int vcpu_events;
Jan Kiszkab0b1d692010-03-01 19:10:29 +010072 int robust_singlestep;
Jan Kiszkaff44f1a2010-03-12 15:20:49 +010073 int debugregs;
aliguorie22a25c2009-03-12 20:12:48 +000074#ifdef KVM_CAP_SET_GUEST_DEBUG
75 struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
76#endif
Glauber Costa6f725c12009-07-21 12:26:58 -030077 int irqchip_in_kernel;
78 int pit_in_kernel;
Sheng Yangf1665b22010-06-17 17:53:07 +080079 int xsave, xcrs;
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +020080 int many_ioeventfds;
aliguori05330442008-11-05 16:29:27 +000081};
82
Jan Kiszka6a7af8c2011-02-07 12:19:25 +010083KVMState *kvm_state;
aliguori05330442008-11-05 16:29:27 +000084
Jan Kiszka94a8d392011-01-21 21:48:17 +010085static const KVMCapabilityInfo kvm_required_capabilites[] = {
86 KVM_CAP_INFO(USER_MEMORY),
87 KVM_CAP_INFO(DESTROY_MEMORY_REGION_WORKS),
88 KVM_CAP_LAST_INFO
89};
90
aliguori05330442008-11-05 16:29:27 +000091static KVMSlot *kvm_alloc_slot(KVMState *s)
92{
93 int i;
94
95 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
Jan Kiszkaa426e122011-01-04 09:32:13 +010096 if (s->slots[i].memory_size == 0) {
aliguori05330442008-11-05 16:29:27 +000097 return &s->slots[i];
Jan Kiszkaa426e122011-01-04 09:32:13 +010098 }
aliguori05330442008-11-05 16:29:27 +000099 }
100
aliguorid3f8d372009-04-17 14:26:29 +0000101 fprintf(stderr, "%s: no free slot available\n", __func__);
102 abort();
103}
104
105static KVMSlot *kvm_lookup_matching_slot(KVMState *s,
Anthony Liguoric227f092009-10-01 16:12:16 -0500106 target_phys_addr_t start_addr,
107 target_phys_addr_t end_addr)
aliguorid3f8d372009-04-17 14:26:29 +0000108{
109 int i;
110
111 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
112 KVMSlot *mem = &s->slots[i];
113
114 if (start_addr == mem->start_addr &&
115 end_addr == mem->start_addr + mem->memory_size) {
116 return mem;
117 }
118 }
119
aliguori05330442008-11-05 16:29:27 +0000120 return NULL;
121}
122
aliguori6152e2a2009-04-17 14:26:33 +0000123/*
124 * Find overlapping slot with lowest start address
125 */
126static KVMSlot *kvm_lookup_overlapping_slot(KVMState *s,
Anthony Liguoric227f092009-10-01 16:12:16 -0500127 target_phys_addr_t start_addr,
128 target_phys_addr_t end_addr)
aliguori05330442008-11-05 16:29:27 +0000129{
aliguori6152e2a2009-04-17 14:26:33 +0000130 KVMSlot *found = NULL;
aliguori05330442008-11-05 16:29:27 +0000131 int i;
132
133 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
134 KVMSlot *mem = &s->slots[i];
135
aliguori6152e2a2009-04-17 14:26:33 +0000136 if (mem->memory_size == 0 ||
137 (found && found->start_addr < mem->start_addr)) {
138 continue;
139 }
140
141 if (end_addr > mem->start_addr &&
142 start_addr < mem->start_addr + mem->memory_size) {
143 found = mem;
144 }
aliguori05330442008-11-05 16:29:27 +0000145 }
146
aliguori6152e2a2009-04-17 14:26:33 +0000147 return found;
aliguori05330442008-11-05 16:29:27 +0000148}
149
Avi Kivity9f213ed2011-12-15 19:55:26 +0200150int kvm_physical_memory_addr_from_host(KVMState *s, void *ram,
151 target_phys_addr_t *phys_addr)
Huang Ying983dfc32010-10-11 15:31:20 -0300152{
153 int i;
154
155 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
156 KVMSlot *mem = &s->slots[i];
157
Avi Kivity9f213ed2011-12-15 19:55:26 +0200158 if (ram >= mem->ram && ram < mem->ram + mem->memory_size) {
159 *phys_addr = mem->start_addr + (ram - mem->ram);
Huang Ying983dfc32010-10-11 15:31:20 -0300160 return 1;
161 }
162 }
163
164 return 0;
165}
166
aliguori5832d1f2008-11-24 19:36:26 +0000167static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
168{
169 struct kvm_userspace_memory_region mem;
170
171 mem.slot = slot->slot;
172 mem.guest_phys_addr = slot->start_addr;
173 mem.memory_size = slot->memory_size;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200174 mem.userspace_addr = (unsigned long)slot->ram;
aliguori5832d1f2008-11-24 19:36:26 +0000175 mem.flags = slot->flags;
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200176 if (s->migration_log) {
177 mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
178 }
aliguori5832d1f2008-11-24 19:36:26 +0000179 return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
180}
181
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200182static void kvm_reset_vcpu(void *opaque)
183{
184 CPUState *env = opaque;
185
Jan Kiszkacaa5af02009-11-06 19:39:24 +0100186 kvm_arch_reset_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200187}
aliguori5832d1f2008-11-24 19:36:26 +0000188
Glauber Costa6f725c12009-07-21 12:26:58 -0300189int kvm_irqchip_in_kernel(void)
190{
191 return kvm_state->irqchip_in_kernel;
192}
193
194int kvm_pit_in_kernel(void)
195{
196 return kvm_state->pit_in_kernel;
197}
198
aliguori05330442008-11-05 16:29:27 +0000199int kvm_init_vcpu(CPUState *env)
200{
201 KVMState *s = kvm_state;
202 long mmap_size;
203 int ret;
204
Blue Swirl8c0d5772010-04-18 14:22:14 +0000205 DPRINTF("kvm_init_vcpu\n");
aliguori05330442008-11-05 16:29:27 +0000206
aliguori984b5182008-11-13 19:21:00 +0000207 ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
aliguori05330442008-11-05 16:29:27 +0000208 if (ret < 0) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000209 DPRINTF("kvm_create_vcpu failed\n");
aliguori05330442008-11-05 16:29:27 +0000210 goto err;
211 }
212
213 env->kvm_fd = ret;
214 env->kvm_state = s;
Jan Kiszkad841b6c2011-03-15 12:26:20 +0100215 env->kvm_vcpu_dirty = 1;
aliguori05330442008-11-05 16:29:27 +0000216
217 mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
218 if (mmap_size < 0) {
Jan Kiszka748a6802011-02-01 22:15:48 +0100219 ret = mmap_size;
Blue Swirl8c0d5772010-04-18 14:22:14 +0000220 DPRINTF("KVM_GET_VCPU_MMAP_SIZE failed\n");
aliguori05330442008-11-05 16:29:27 +0000221 goto err;
222 }
223
224 env->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
225 env->kvm_fd, 0);
226 if (env->kvm_run == MAP_FAILED) {
227 ret = -errno;
Blue Swirl8c0d5772010-04-18 14:22:14 +0000228 DPRINTF("mmap'ing vcpu state failed\n");
aliguori05330442008-11-05 16:29:27 +0000229 goto err;
230 }
231
Jan Kiszkaa426e122011-01-04 09:32:13 +0100232 if (s->coalesced_mmio && !s->coalesced_mmio_ring) {
233 s->coalesced_mmio_ring =
234 (void *)env->kvm_run + s->coalesced_mmio * PAGE_SIZE;
235 }
Sheng Yang62a27442010-01-26 19:21:16 +0800236
aliguori05330442008-11-05 16:29:27 +0000237 ret = kvm_arch_init_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200238 if (ret == 0) {
Jan Kiszkaa08d4362009-06-27 09:25:07 +0200239 qemu_register_reset(kvm_reset_vcpu, env);
Jan Kiszkacaa5af02009-11-06 19:39:24 +0100240 kvm_arch_reset_vcpu(env);
Jan Kiszka8d2ba1f2009-06-27 09:24:58 +0200241 }
aliguori05330442008-11-05 16:29:27 +0000242err:
243 return ret;
244}
245
aliguori5832d1f2008-11-24 19:36:26 +0000246/*
247 * dirty pages logging control
248 */
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300249
250static int kvm_mem_flags(KVMState *s, bool log_dirty)
251{
252 return log_dirty ? KVM_MEM_LOG_DIRTY_PAGES : 0;
253}
254
255static int kvm_slot_dirty_pages_log_change(KVMSlot *mem, bool log_dirty)
aliguori5832d1f2008-11-24 19:36:26 +0000256{
257 KVMState *s = kvm_state;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300258 int flags, mask = KVM_MEM_LOG_DIRTY_PAGES;
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200259 int old_flags;
260
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200261 old_flags = mem->flags;
aliguori5832d1f2008-11-24 19:36:26 +0000262
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300263 flags = (mem->flags & ~mask) | kvm_mem_flags(s, log_dirty);
aliguori5832d1f2008-11-24 19:36:26 +0000264 mem->flags = flags;
265
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200266 /* If nothing changed effectively, no need to issue ioctl */
267 if (s->migration_log) {
268 flags |= KVM_MEM_LOG_DIRTY_PAGES;
269 }
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300270
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200271 if (flags == old_flags) {
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300272 return 0;
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200273 }
274
aliguori5832d1f2008-11-24 19:36:26 +0000275 return kvm_set_user_memory_region(s, mem);
276}
277
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300278static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,
279 ram_addr_t size, bool log_dirty)
280{
281 KVMState *s = kvm_state;
282 KVMSlot *mem = kvm_lookup_matching_slot(s, phys_addr, phys_addr + size);
283
284 if (mem == NULL) {
285 fprintf(stderr, "BUG: %s: invalid parameters " TARGET_FMT_plx "-"
286 TARGET_FMT_plx "\n", __func__, phys_addr,
287 (target_phys_addr_t)(phys_addr + size - 1));
288 return -EINVAL;
289 }
290 return kvm_slot_dirty_pages_log_change(mem, log_dirty);
291}
292
Avi Kivitya01672d2011-12-18 14:06:05 +0200293static void kvm_log_start(MemoryListener *listener,
294 MemoryRegionSection *section)
aliguori5832d1f2008-11-24 19:36:26 +0000295{
Avi Kivitya01672d2011-12-18 14:06:05 +0200296 int r;
297
298 r = kvm_dirty_pages_log_change(section->offset_within_address_space,
299 section->size, true);
300 if (r < 0) {
301 abort();
302 }
aliguori5832d1f2008-11-24 19:36:26 +0000303}
304
Avi Kivitya01672d2011-12-18 14:06:05 +0200305static void kvm_log_stop(MemoryListener *listener,
306 MemoryRegionSection *section)
aliguori5832d1f2008-11-24 19:36:26 +0000307{
Avi Kivitya01672d2011-12-18 14:06:05 +0200308 int r;
309
310 r = kvm_dirty_pages_log_change(section->offset_within_address_space,
311 section->size, false);
312 if (r < 0) {
313 abort();
314 }
aliguori5832d1f2008-11-24 19:36:26 +0000315}
316
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200317static int kvm_set_migration_log(int enable)
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200318{
319 KVMState *s = kvm_state;
320 KVMSlot *mem;
321 int i, err;
322
323 s->migration_log = enable;
324
325 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
326 mem = &s->slots[i];
327
Alex Williamson70fedd72010-07-14 13:36:49 -0600328 if (!mem->memory_size) {
329 continue;
330 }
Jan Kiszka4495d6a2009-05-01 20:52:46 +0200331 if (!!(mem->flags & KVM_MEM_LOG_DIRTY_PAGES) == enable) {
332 continue;
333 }
334 err = kvm_set_user_memory_region(s, mem);
335 if (err) {
336 return err;
337 }
338 }
339 return 0;
340}
341
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300342/* get kvm's dirty pages bitmap and update qemu's */
Avi Kivityffcde122011-12-19 13:18:13 +0200343static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section,
344 unsigned long *bitmap)
Alexander Graf96c16062009-07-27 12:49:56 +0200345{
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300346 unsigned int i, j;
Benjamin Herrenschmidtaa90fec2012-01-11 19:46:21 +0000347 unsigned long page_number, c;
348 target_phys_addr_t addr, addr1;
Avi Kivityffcde122011-12-19 13:18:13 +0200349 unsigned int len = ((section->size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) / HOST_LONG_BITS;
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300350
351 /*
352 * bitmap-traveling is faster than memory-traveling (for addr...)
353 * especially when most of the memory is not dirty.
354 */
355 for (i = 0; i < len; i++) {
356 if (bitmap[i] != 0) {
357 c = leul_to_cpu(bitmap[i]);
358 do {
359 j = ffsl(c) - 1;
360 c &= ~(1ul << j);
361 page_number = i * HOST_LONG_BITS + j;
362 addr1 = page_number * TARGET_PAGE_SIZE;
Avi Kivityffcde122011-12-19 13:18:13 +0200363 addr = section->offset_within_region + addr1;
364 memory_region_set_dirty(section->mr, addr);
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300365 } while (c != 0);
366 }
367 }
368 return 0;
Alexander Graf96c16062009-07-27 12:49:56 +0200369}
370
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300371#define ALIGN(x, y) (((x)+(y)-1) & ~((y)-1))
372
aliguori5832d1f2008-11-24 19:36:26 +0000373/**
374 * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
375 * This function updates qemu's dirty bitmap using cpu_physical_memory_set_dirty().
376 * This means all bits are set to dirty.
377 *
aliguorid3f8d372009-04-17 14:26:29 +0000378 * @start_add: start of logged region.
aliguori5832d1f2008-11-24 19:36:26 +0000379 * @end_addr: end of logged region.
380 */
Avi Kivityffcde122011-12-19 13:18:13 +0200381static int kvm_physical_sync_dirty_bitmap(MemoryRegionSection *section)
aliguori5832d1f2008-11-24 19:36:26 +0000382{
383 KVMState *s = kvm_state;
Jan Kiszka151f7742009-05-01 20:52:47 +0200384 unsigned long size, allocated_size = 0;
Jan Kiszka151f7742009-05-01 20:52:47 +0200385 KVMDirtyLog d;
386 KVMSlot *mem;
387 int ret = 0;
Avi Kivityffcde122011-12-19 13:18:13 +0200388 target_phys_addr_t start_addr = section->offset_within_address_space;
389 target_phys_addr_t end_addr = start_addr + section->size;
aliguori5832d1f2008-11-24 19:36:26 +0000390
Jan Kiszka151f7742009-05-01 20:52:47 +0200391 d.dirty_bitmap = NULL;
392 while (start_addr < end_addr) {
393 mem = kvm_lookup_overlapping_slot(s, start_addr, end_addr);
394 if (mem == NULL) {
395 break;
396 }
397
Michael Tokarev51b0c602011-04-26 20:13:49 +0400398 /* XXX bad kernel interface alert
399 * For dirty bitmap, kernel allocates array of size aligned to
400 * bits-per-long. But for case when the kernel is 64bits and
401 * the userspace is 32bits, userspace can't align to the same
402 * bits-per-long, since sizeof(long) is different between kernel
403 * and user space. This way, userspace will provide buffer which
404 * may be 4 bytes less than the kernel will use, resulting in
405 * userspace memory corruption (which is not detectable by valgrind
406 * too, in most cases).
407 * So for now, let's align to 64 instead of HOST_LONG_BITS here, in
408 * a hope that sizeof(long) wont become >8 any time soon.
409 */
410 size = ALIGN(((mem->memory_size) >> TARGET_PAGE_BITS),
411 /*HOST_LONG_BITS*/ 64) / 8;
Jan Kiszka151f7742009-05-01 20:52:47 +0200412 if (!d.dirty_bitmap) {
Anthony Liguori7267c092011-08-20 22:09:37 -0500413 d.dirty_bitmap = g_malloc(size);
Jan Kiszka151f7742009-05-01 20:52:47 +0200414 } else if (size > allocated_size) {
Anthony Liguori7267c092011-08-20 22:09:37 -0500415 d.dirty_bitmap = g_realloc(d.dirty_bitmap, size);
Jan Kiszka151f7742009-05-01 20:52:47 +0200416 }
417 allocated_size = size;
418 memset(d.dirty_bitmap, 0, allocated_size);
419
420 d.slot = mem->slot;
421
Anthony Liguori6e489f32009-07-27 15:23:59 -0500422 if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
Blue Swirl8c0d5772010-04-18 14:22:14 +0000423 DPRINTF("ioctl failed %d\n", errno);
Jan Kiszka151f7742009-05-01 20:52:47 +0200424 ret = -1;
425 break;
426 }
427
Avi Kivityffcde122011-12-19 13:18:13 +0200428 kvm_get_dirty_pages_log_range(section, d.dirty_bitmap);
Marcelo Tosatti8369e012010-04-23 14:04:14 -0300429 start_addr = mem->start_addr + mem->memory_size;
aliguori5832d1f2008-11-24 19:36:26 +0000430 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500431 g_free(d.dirty_bitmap);
Jan Kiszka151f7742009-05-01 20:52:47 +0200432
433 return ret;
aliguori5832d1f2008-11-24 19:36:26 +0000434}
435
Anthony Liguoric227f092009-10-01 16:12:16 -0500436int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
aliguorif65ed4c2008-12-09 20:09:57 +0000437{
438 int ret = -ENOSYS;
aliguorif65ed4c2008-12-09 20:09:57 +0000439 KVMState *s = kvm_state;
440
441 if (s->coalesced_mmio) {
442 struct kvm_coalesced_mmio_zone zone;
443
444 zone.addr = start;
445 zone.size = size;
446
447 ret = kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
448 }
aliguorif65ed4c2008-12-09 20:09:57 +0000449
450 return ret;
451}
452
Anthony Liguoric227f092009-10-01 16:12:16 -0500453int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
aliguorif65ed4c2008-12-09 20:09:57 +0000454{
455 int ret = -ENOSYS;
aliguorif65ed4c2008-12-09 20:09:57 +0000456 KVMState *s = kvm_state;
457
458 if (s->coalesced_mmio) {
459 struct kvm_coalesced_mmio_zone zone;
460
461 zone.addr = start;
462 zone.size = size;
463
464 ret = kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
465 }
aliguorif65ed4c2008-12-09 20:09:57 +0000466
467 return ret;
468}
469
Anthony Liguoriad7b8b32009-05-08 15:33:24 -0500470int kvm_check_extension(KVMState *s, unsigned int extension)
471{
472 int ret;
473
474 ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
475 if (ret < 0) {
476 ret = 0;
477 }
478
479 return ret;
480}
481
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +0200482static int kvm_check_many_ioeventfds(void)
483{
Stefan Hajnoczid0dcac82011-01-25 16:17:14 +0000484 /* Userspace can use ioeventfd for io notification. This requires a host
485 * that supports eventfd(2) and an I/O thread; since eventfd does not
486 * support SIGIO it cannot interrupt the vcpu.
487 *
488 * Older kernels have a 6 device limit on the KVM io bus. Find out so we
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +0200489 * can avoid creating too many ioeventfds.
490 */
Anthony Liguori12d45362011-08-22 08:24:58 -0500491#if defined(CONFIG_EVENTFD)
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +0200492 int ioeventfds[7];
493 int i, ret = 0;
494 for (i = 0; i < ARRAY_SIZE(ioeventfds); i++) {
495 ioeventfds[i] = eventfd(0, EFD_CLOEXEC);
496 if (ioeventfds[i] < 0) {
497 break;
498 }
499 ret = kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, true);
500 if (ret < 0) {
501 close(ioeventfds[i]);
502 break;
503 }
504 }
505
506 /* Decide whether many devices are supported or not */
507 ret = i == ARRAY_SIZE(ioeventfds);
508
509 while (i-- > 0) {
510 kvm_set_ioeventfd_pio_word(ioeventfds[i], 0, i, false);
511 close(ioeventfds[i]);
512 }
513 return ret;
514#else
515 return 0;
516#endif
517}
518
Jan Kiszka94a8d392011-01-21 21:48:17 +0100519static const KVMCapabilityInfo *
520kvm_check_extension_list(KVMState *s, const KVMCapabilityInfo *list)
521{
522 while (list->name) {
523 if (!kvm_check_extension(s, list->value)) {
524 return list;
525 }
526 list++;
527 }
528 return NULL;
529}
530
Avi Kivitya01672d2011-12-18 14:06:05 +0200531static void kvm_set_phys_mem(MemoryRegionSection *section, bool add)
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200532{
533 KVMState *s = kvm_state;
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200534 KVMSlot *mem, old;
535 int err;
Avi Kivitya01672d2011-12-18 14:06:05 +0200536 MemoryRegion *mr = section->mr;
537 bool log_dirty = memory_region_is_logging(mr);
538 target_phys_addr_t start_addr = section->offset_within_address_space;
539 ram_addr_t size = section->size;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200540 void *ram = NULL;
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200541
Gleb Natapov14542fe2010-07-28 18:13:23 +0300542 /* kvm works in page size chunks, but the function may be called
543 with sub-page size and unaligned start address. */
544 size = TARGET_PAGE_ALIGN(size);
545 start_addr = TARGET_PAGE_ALIGN(start_addr);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200546
Avi Kivitya01672d2011-12-18 14:06:05 +0200547 if (!memory_region_is_ram(mr)) {
548 return;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200549 }
550
Avi Kivitya01672d2011-12-18 14:06:05 +0200551 ram = memory_region_get_ram_ptr(mr) + section->offset_within_region;
552
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200553 while (1) {
554 mem = kvm_lookup_overlapping_slot(s, start_addr, start_addr + size);
555 if (!mem) {
556 break;
557 }
558
Avi Kivitya01672d2011-12-18 14:06:05 +0200559 if (add && start_addr >= mem->start_addr &&
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200560 (start_addr + size <= mem->start_addr + mem->memory_size) &&
Avi Kivity9f213ed2011-12-15 19:55:26 +0200561 (ram - start_addr == mem->ram - mem->start_addr)) {
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200562 /* The new slot fits into the existing one and comes with
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300563 * identical parameters - update flags and done. */
564 kvm_slot_dirty_pages_log_change(mem, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200565 return;
566 }
567
568 old = *mem;
569
Avi Kivity3fbffb62012-01-15 16:13:59 +0200570 if (mem->flags & KVM_MEM_LOG_DIRTY_PAGES) {
571 kvm_physical_sync_dirty_bitmap(section);
572 }
573
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200574 /* unregister the overlapping slot */
575 mem->memory_size = 0;
576 err = kvm_set_user_memory_region(s, mem);
577 if (err) {
578 fprintf(stderr, "%s: error unregistering overlapping slot: %s\n",
579 __func__, strerror(-err));
580 abort();
581 }
582
583 /* Workaround for older KVM versions: we can't join slots, even not by
584 * unregistering the previous ones and then registering the larger
585 * slot. We have to maintain the existing fragmentation. Sigh.
586 *
587 * This workaround assumes that the new slot starts at the same
588 * address as the first existing one. If not or if some overlapping
589 * slot comes around later, we will fail (not seen in practice so far)
590 * - and actually require a recent KVM version. */
591 if (s->broken_set_mem_region &&
Avi Kivitya01672d2011-12-18 14:06:05 +0200592 old.start_addr == start_addr && old.memory_size < size && add) {
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200593 mem = kvm_alloc_slot(s);
594 mem->memory_size = old.memory_size;
595 mem->start_addr = old.start_addr;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200596 mem->ram = old.ram;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300597 mem->flags = kvm_mem_flags(s, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200598
599 err = kvm_set_user_memory_region(s, mem);
600 if (err) {
601 fprintf(stderr, "%s: error updating slot: %s\n", __func__,
602 strerror(-err));
603 abort();
604 }
605
606 start_addr += old.memory_size;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200607 ram += old.memory_size;
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200608 size -= old.memory_size;
609 continue;
610 }
611
612 /* register prefix slot */
613 if (old.start_addr < start_addr) {
614 mem = kvm_alloc_slot(s);
615 mem->memory_size = start_addr - old.start_addr;
616 mem->start_addr = old.start_addr;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200617 mem->ram = old.ram;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300618 mem->flags = kvm_mem_flags(s, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200619
620 err = kvm_set_user_memory_region(s, mem);
621 if (err) {
622 fprintf(stderr, "%s: error registering prefix slot: %s\n",
623 __func__, strerror(-err));
Alexander Grafd4d68682011-04-16 10:15:11 +0200624#ifdef TARGET_PPC
625 fprintf(stderr, "%s: This is probably because your kernel's " \
626 "PAGE_SIZE is too big. Please try to use 4k " \
627 "PAGE_SIZE!\n", __func__);
628#endif
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200629 abort();
630 }
631 }
632
633 /* register suffix slot */
634 if (old.start_addr + old.memory_size > start_addr + size) {
635 ram_addr_t size_delta;
636
637 mem = kvm_alloc_slot(s);
638 mem->start_addr = start_addr + size;
639 size_delta = mem->start_addr - old.start_addr;
640 mem->memory_size = old.memory_size - size_delta;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200641 mem->ram = old.ram + size_delta;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300642 mem->flags = kvm_mem_flags(s, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200643
644 err = kvm_set_user_memory_region(s, mem);
645 if (err) {
646 fprintf(stderr, "%s: error registering suffix slot: %s\n",
647 __func__, strerror(-err));
648 abort();
649 }
650 }
651 }
652
653 /* in case the KVM bug workaround already "consumed" the new slot */
Jan Kiszkaa426e122011-01-04 09:32:13 +0100654 if (!size) {
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200655 return;
Jan Kiszkaa426e122011-01-04 09:32:13 +0100656 }
Avi Kivitya01672d2011-12-18 14:06:05 +0200657 if (!add) {
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200658 return;
Jan Kiszkaa426e122011-01-04 09:32:13 +0100659 }
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200660 mem = kvm_alloc_slot(s);
661 mem->memory_size = size;
662 mem->start_addr = start_addr;
Avi Kivity9f213ed2011-12-15 19:55:26 +0200663 mem->ram = ram;
Michael S. Tsirkin25254bb2011-04-06 22:09:54 +0300664 mem->flags = kvm_mem_flags(s, log_dirty);
Michael S. Tsirkin46dbef62010-01-27 22:07:08 +0200665
666 err = kvm_set_user_memory_region(s, mem);
667 if (err) {
668 fprintf(stderr, "%s: error registering slot: %s\n", __func__,
669 strerror(-err));
670 abort();
671 }
672}
673
Avi Kivitya01672d2011-12-18 14:06:05 +0200674static void kvm_region_add(MemoryListener *listener,
675 MemoryRegionSection *section)
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200676{
Avi Kivitya01672d2011-12-18 14:06:05 +0200677 kvm_set_phys_mem(section, true);
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200678}
679
Avi Kivitya01672d2011-12-18 14:06:05 +0200680static void kvm_region_del(MemoryListener *listener,
681 MemoryRegionSection *section)
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200682{
Avi Kivitya01672d2011-12-18 14:06:05 +0200683 kvm_set_phys_mem(section, false);
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200684}
685
Avi Kivitya01672d2011-12-18 14:06:05 +0200686static void kvm_log_sync(MemoryListener *listener,
687 MemoryRegionSection *section)
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200688{
Avi Kivitya01672d2011-12-18 14:06:05 +0200689 int r;
690
Avi Kivityffcde122011-12-19 13:18:13 +0200691 r = kvm_physical_sync_dirty_bitmap(section);
Avi Kivitya01672d2011-12-18 14:06:05 +0200692 if (r < 0) {
693 abort();
694 }
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200695}
696
Avi Kivitya01672d2011-12-18 14:06:05 +0200697static void kvm_log_global_start(struct MemoryListener *listener)
698{
699 int r;
700
701 r = kvm_set_migration_log(1);
702 assert(r >= 0);
703}
704
705static void kvm_log_global_stop(struct MemoryListener *listener)
706{
707 int r;
708
709 r = kvm_set_migration_log(0);
710 assert(r >= 0);
711}
712
713static MemoryListener kvm_memory_listener = {
714 .region_add = kvm_region_add,
715 .region_del = kvm_region_del,
Anthony PERARDe5896b12011-02-07 12:19:23 +0100716 .log_start = kvm_log_start,
717 .log_stop = kvm_log_stop,
Avi Kivitya01672d2011-12-18 14:06:05 +0200718 .log_sync = kvm_log_sync,
719 .log_global_start = kvm_log_global_start,
720 .log_global_stop = kvm_log_global_stop,
Michael S. Tsirkin7b8f3b72010-01-27 22:07:21 +0200721};
722
Jan Kiszkaaa7f74d2011-04-13 01:32:56 +0200723static void kvm_handle_interrupt(CPUState *env, int mask)
724{
725 env->interrupt_request |= mask;
726
727 if (!qemu_cpu_is_self(env)) {
728 qemu_cpu_kick(env);
729 }
730}
731
Jan Kiszkacad1e282011-01-21 21:48:16 +0100732int kvm_init(void)
aliguori05330442008-11-05 16:29:27 +0000733{
Jan Kiszka168ccc12009-06-07 11:30:25 +0200734 static const char upgrade_note[] =
735 "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
736 "(see http://sourceforge.net/projects/kvm).\n";
aliguori05330442008-11-05 16:29:27 +0000737 KVMState *s;
Jan Kiszka94a8d392011-01-21 21:48:17 +0100738 const KVMCapabilityInfo *missing_cap;
aliguori05330442008-11-05 16:29:27 +0000739 int ret;
740 int i;
741
Anthony Liguori7267c092011-08-20 22:09:37 -0500742 s = g_malloc0(sizeof(KVMState));
aliguori05330442008-11-05 16:29:27 +0000743
aliguorie22a25c2009-03-12 20:12:48 +0000744#ifdef KVM_CAP_SET_GUEST_DEBUG
Blue Swirl72cf2d42009-09-12 07:36:22 +0000745 QTAILQ_INIT(&s->kvm_sw_breakpoints);
aliguorie22a25c2009-03-12 20:12:48 +0000746#endif
Jan Kiszkaa426e122011-01-04 09:32:13 +0100747 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
aliguori05330442008-11-05 16:29:27 +0000748 s->slots[i].slot = i;
Jan Kiszkaa426e122011-01-04 09:32:13 +0100749 }
aliguori05330442008-11-05 16:29:27 +0000750 s->vmfd = -1;
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100751 s->fd = qemu_open("/dev/kvm", O_RDWR);
aliguori05330442008-11-05 16:29:27 +0000752 if (s->fd == -1) {
753 fprintf(stderr, "Could not access KVM kernel module: %m\n");
754 ret = -errno;
755 goto err;
756 }
757
758 ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
759 if (ret < KVM_API_VERSION) {
Jan Kiszkaa426e122011-01-04 09:32:13 +0100760 if (ret > 0) {
aliguori05330442008-11-05 16:29:27 +0000761 ret = -EINVAL;
Jan Kiszkaa426e122011-01-04 09:32:13 +0100762 }
aliguori05330442008-11-05 16:29:27 +0000763 fprintf(stderr, "kvm version too old\n");
764 goto err;
765 }
766
767 if (ret > KVM_API_VERSION) {
768 ret = -EINVAL;
769 fprintf(stderr, "kvm version not supported\n");
770 goto err;
771 }
772
773 s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
Alexander Graf0104dca2010-04-01 18:42:37 +0200774 if (s->vmfd < 0) {
775#ifdef TARGET_S390X
776 fprintf(stderr, "Please add the 'switch_amode' kernel parameter to "
777 "your host kernel command line\n");
778#endif
Xu He Jiedb9eae12011-10-27 10:15:13 +0800779 ret = s->vmfd;
aliguori05330442008-11-05 16:29:27 +0000780 goto err;
Alexander Graf0104dca2010-04-01 18:42:37 +0200781 }
aliguori05330442008-11-05 16:29:27 +0000782
Jan Kiszka94a8d392011-01-21 21:48:17 +0100783 missing_cap = kvm_check_extension_list(s, kvm_required_capabilites);
784 if (!missing_cap) {
785 missing_cap =
786 kvm_check_extension_list(s, kvm_arch_required_capabilities);
787 }
788 if (missing_cap) {
Anthony Liguoriad7b8b32009-05-08 15:33:24 -0500789 ret = -EINVAL;
Jan Kiszka94a8d392011-01-21 21:48:17 +0100790 fprintf(stderr, "kvm does not support %s\n%s",
791 missing_cap->name, upgrade_note);
aliguori05330442008-11-05 16:29:27 +0000792 goto err;
793 }
794
Anthony Liguoriad7b8b32009-05-08 15:33:24 -0500795 s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
aliguorif65ed4c2008-12-09 20:09:57 +0000796
Jan Kiszkae69917e2009-05-01 20:42:15 +0200797 s->broken_set_mem_region = 1;
Lai Jiangshan14a09512010-12-10 15:52:36 +0800798 ret = kvm_check_extension(s, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
Jan Kiszkae69917e2009-05-01 20:42:15 +0200799 if (ret > 0) {
800 s->broken_set_mem_region = 0;
801 }
Jan Kiszkae69917e2009-05-01 20:42:15 +0200802
Jan Kiszkaa0fb0022009-11-25 00:33:03 +0100803#ifdef KVM_CAP_VCPU_EVENTS
804 s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
805#endif
806
Jan Kiszkab0b1d692010-03-01 19:10:29 +0100807 s->robust_singlestep =
808 kvm_check_extension(s, KVM_CAP_X86_ROBUST_SINGLESTEP);
Jan Kiszkab0b1d692010-03-01 19:10:29 +0100809
Jan Kiszkaff44f1a2010-03-12 15:20:49 +0100810#ifdef KVM_CAP_DEBUGREGS
811 s->debugregs = kvm_check_extension(s, KVM_CAP_DEBUGREGS);
812#endif
813
Sheng Yangf1665b22010-06-17 17:53:07 +0800814#ifdef KVM_CAP_XSAVE
815 s->xsave = kvm_check_extension(s, KVM_CAP_XSAVE);
816#endif
817
Sheng Yangf1665b22010-06-17 17:53:07 +0800818#ifdef KVM_CAP_XCRS
819 s->xcrs = kvm_check_extension(s, KVM_CAP_XCRS);
820#endif
821
Jan Kiszkacad1e282011-01-21 21:48:16 +0100822 ret = kvm_arch_init(s);
Jan Kiszkaa426e122011-01-04 09:32:13 +0100823 if (ret < 0) {
aliguori05330442008-11-05 16:29:27 +0000824 goto err;
Jan Kiszkaa426e122011-01-04 09:32:13 +0100825 }
aliguori05330442008-11-05 16:29:27 +0000826
827 kvm_state = s;
Avi Kivitya01672d2011-12-18 14:06:05 +0200828 memory_listener_register(&kvm_memory_listener);
aliguori05330442008-11-05 16:29:27 +0000829
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +0200830 s->many_ioeventfds = kvm_check_many_ioeventfds();
831
Jan Kiszkaaa7f74d2011-04-13 01:32:56 +0200832 cpu_interrupt_handler = kvm_handle_interrupt;
833
aliguori05330442008-11-05 16:29:27 +0000834 return 0;
835
836err:
837 if (s) {
Xu He Jiedb9eae12011-10-27 10:15:13 +0800838 if (s->vmfd >= 0) {
aliguori05330442008-11-05 16:29:27 +0000839 close(s->vmfd);
Jan Kiszkaa426e122011-01-04 09:32:13 +0100840 }
841 if (s->fd != -1) {
aliguori05330442008-11-05 16:29:27 +0000842 close(s->fd);
Jan Kiszkaa426e122011-01-04 09:32:13 +0100843 }
aliguori05330442008-11-05 16:29:27 +0000844 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500845 g_free(s);
aliguori05330442008-11-05 16:29:27 +0000846
847 return ret;
848}
849
Jan Kiszkab30e93e2011-02-01 22:16:01 +0100850static void kvm_handle_io(uint16_t port, void *data, int direction, int size,
851 uint32_t count)
aliguori05330442008-11-05 16:29:27 +0000852{
853 int i;
854 uint8_t *ptr = data;
855
856 for (i = 0; i < count; i++) {
857 if (direction == KVM_EXIT_IO_IN) {
858 switch (size) {
859 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000860 stb_p(ptr, cpu_inb(port));
aliguori05330442008-11-05 16:29:27 +0000861 break;
862 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000863 stw_p(ptr, cpu_inw(port));
aliguori05330442008-11-05 16:29:27 +0000864 break;
865 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000866 stl_p(ptr, cpu_inl(port));
aliguori05330442008-11-05 16:29:27 +0000867 break;
868 }
869 } else {
870 switch (size) {
871 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000872 cpu_outb(port, ldub_p(ptr));
aliguori05330442008-11-05 16:29:27 +0000873 break;
874 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000875 cpu_outw(port, lduw_p(ptr));
aliguori05330442008-11-05 16:29:27 +0000876 break;
877 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +0000878 cpu_outl(port, ldl_p(ptr));
aliguori05330442008-11-05 16:29:27 +0000879 break;
880 }
881 }
882
883 ptr += size;
884 }
aliguori05330442008-11-05 16:29:27 +0000885}
886
Jan Kiszka73aaec42011-01-21 21:48:06 +0100887static int kvm_handle_internal_error(CPUState *env, struct kvm_run *run)
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300888{
Jan Kiszkabb44e0d2011-01-21 21:48:07 +0100889 fprintf(stderr, "KVM internal error.");
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300890 if (kvm_check_extension(kvm_state, KVM_CAP_INTERNAL_ERROR_DATA)) {
891 int i;
892
Jan Kiszkabb44e0d2011-01-21 21:48:07 +0100893 fprintf(stderr, " Suberror: %d\n", run->internal.suberror);
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300894 for (i = 0; i < run->internal.ndata; ++i) {
895 fprintf(stderr, "extra data[%d]: %"PRIx64"\n",
896 i, (uint64_t)run->internal.data[i]);
897 }
Jan Kiszkabb44e0d2011-01-21 21:48:07 +0100898 } else {
899 fprintf(stderr, "\n");
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300900 }
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300901 if (run->internal.suberror == KVM_INTERNAL_ERROR_EMULATION) {
902 fprintf(stderr, "emulation failure\n");
Jan Kiszkaa426e122011-01-04 09:32:13 +0100903 if (!kvm_arch_stop_on_emulation_error(env)) {
Jan Kiszkaf5c848e2011-01-21 21:48:08 +0100904 cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE);
Jan Kiszkad73cd8f2011-03-15 12:26:27 +0100905 return EXCP_INTERRUPT;
Jan Kiszkaa426e122011-01-04 09:32:13 +0100906 }
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300907 }
908 /* FIXME: Should trigger a qmp message to let management know
909 * something went wrong.
910 */
Jan Kiszka73aaec42011-01-21 21:48:06 +0100911 return -1;
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300912}
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -0300913
Sheng Yang62a27442010-01-26 19:21:16 +0800914void kvm_flush_coalesced_mmio_buffer(void)
aliguorif65ed4c2008-12-09 20:09:57 +0000915{
aliguorif65ed4c2008-12-09 20:09:57 +0000916 KVMState *s = kvm_state;
Avi Kivity1cae88b2011-10-18 19:43:12 +0200917
918 if (s->coalesced_flush_in_progress) {
919 return;
920 }
921
922 s->coalesced_flush_in_progress = true;
923
Sheng Yang62a27442010-01-26 19:21:16 +0800924 if (s->coalesced_mmio_ring) {
925 struct kvm_coalesced_mmio_ring *ring = s->coalesced_mmio_ring;
aliguorif65ed4c2008-12-09 20:09:57 +0000926 while (ring->first != ring->last) {
927 struct kvm_coalesced_mmio *ent;
928
929 ent = &ring->coalesced_mmio[ring->first];
930
931 cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
Marcelo Tosatti85199472010-02-22 13:57:54 -0300932 smp_wmb();
aliguorif65ed4c2008-12-09 20:09:57 +0000933 ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
934 }
935 }
Avi Kivity1cae88b2011-10-18 19:43:12 +0200936
937 s->coalesced_flush_in_progress = false;
aliguorif65ed4c2008-12-09 20:09:57 +0000938}
939
Jan Kiszka2705d562010-05-04 09:45:23 -0300940static void do_kvm_cpu_synchronize_state(void *_env)
Avi Kivity4c0960c2009-08-17 23:19:53 +0300941{
Jan Kiszka2705d562010-05-04 09:45:23 -0300942 CPUState *env = _env;
943
Jan Kiszka9ded2742010-02-03 21:17:05 +0100944 if (!env->kvm_vcpu_dirty) {
Avi Kivity4c0960c2009-08-17 23:19:53 +0300945 kvm_arch_get_registers(env);
Jan Kiszka9ded2742010-02-03 21:17:05 +0100946 env->kvm_vcpu_dirty = 1;
Avi Kivity4c0960c2009-08-17 23:19:53 +0300947 }
948}
949
Jan Kiszka2705d562010-05-04 09:45:23 -0300950void kvm_cpu_synchronize_state(CPUState *env)
951{
Jan Kiszkaa426e122011-01-04 09:32:13 +0100952 if (!env->kvm_vcpu_dirty) {
Jan Kiszka2705d562010-05-04 09:45:23 -0300953 run_on_cpu(env, do_kvm_cpu_synchronize_state, env);
Jan Kiszkaa426e122011-01-04 09:32:13 +0100954 }
Jan Kiszka2705d562010-05-04 09:45:23 -0300955}
956
Jan Kiszkaea375f92010-03-01 19:10:30 +0100957void kvm_cpu_synchronize_post_reset(CPUState *env)
958{
959 kvm_arch_put_registers(env, KVM_PUT_RESET_STATE);
960 env->kvm_vcpu_dirty = 0;
961}
962
963void kvm_cpu_synchronize_post_init(CPUState *env)
964{
965 kvm_arch_put_registers(env, KVM_PUT_FULL_STATE);
966 env->kvm_vcpu_dirty = 0;
967}
968
aliguori05330442008-11-05 16:29:27 +0000969int kvm_cpu_exec(CPUState *env)
970{
971 struct kvm_run *run = env->kvm_run;
Jan Kiszka7cbb5332011-03-15 12:26:25 +0100972 int ret, run_ret;
aliguori05330442008-11-05 16:29:27 +0000973
Blue Swirl8c0d5772010-04-18 14:22:14 +0000974 DPRINTF("kvm_cpu_exec()\n");
aliguori05330442008-11-05 16:29:27 +0000975
Jan Kiszka99036862011-03-02 08:56:13 +0100976 if (kvm_arch_process_async_events(env)) {
Jan Kiszka9ccfac92011-02-01 22:16:00 +0100977 env->exit_request = 0;
Jan Kiszka6792a572011-02-07 12:19:18 +0100978 return EXCP_HLT;
Jan Kiszka9ccfac92011-02-01 22:16:00 +0100979 }
980
Jan Kiszka6792a572011-02-07 12:19:18 +0100981 cpu_single_env = env;
982
aliguori05330442008-11-05 16:29:27 +0000983 do {
Jan Kiszka9ded2742010-02-03 21:17:05 +0100984 if (env->kvm_vcpu_dirty) {
Jan Kiszkaea375f92010-03-01 19:10:30 +0100985 kvm_arch_put_registers(env, KVM_PUT_RUNTIME_STATE);
Jan Kiszka9ded2742010-02-03 21:17:05 +0100986 env->kvm_vcpu_dirty = 0;
Avi Kivity4c0960c2009-08-17 23:19:53 +0300987 }
988
Jan Kiszka8c14c172009-05-30 10:01:45 +0200989 kvm_arch_pre_run(env, run);
Jan Kiszka9ccfac92011-02-01 22:16:00 +0100990 if (env->exit_request) {
991 DPRINTF("interrupt exit requested\n");
992 /*
993 * KVM requires us to reenter the kernel after IO exits to complete
994 * instruction emulation. This self-signal will ensure that we
995 * leave ASAP again.
996 */
997 qemu_cpu_kick_self();
998 }
Marcelo Tosatti273faf12010-05-04 09:45:19 -0300999 cpu_single_env = NULL;
Glauber Costad549db52009-10-07 16:38:03 -03001000 qemu_mutex_unlock_iothread();
Jan Kiszka9ccfac92011-02-01 22:16:00 +01001001
Jan Kiszka7cbb5332011-03-15 12:26:25 +01001002 run_ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
Jan Kiszka9ccfac92011-02-01 22:16:00 +01001003
Glauber Costad549db52009-10-07 16:38:03 -03001004 qemu_mutex_lock_iothread();
Marcelo Tosatti273faf12010-05-04 09:45:19 -03001005 cpu_single_env = env;
aliguori05330442008-11-05 16:29:27 +00001006 kvm_arch_post_run(env, run);
1007
Jan Kiszkab0c883b2011-01-21 21:48:19 +01001008 kvm_flush_coalesced_mmio_buffer();
1009
Jan Kiszka7cbb5332011-03-15 12:26:25 +01001010 if (run_ret < 0) {
Jan Kiszkadc77d342011-03-15 12:26:26 +01001011 if (run_ret == -EINTR || run_ret == -EAGAIN) {
1012 DPRINTF("io window exit\n");
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001013 ret = EXCP_INTERRUPT;
Jan Kiszkadc77d342011-03-15 12:26:26 +01001014 break;
1015 }
Michael Ellerman7b011fb2011-12-16 11:20:20 +11001016 fprintf(stderr, "error: kvm run failed %s\n",
1017 strerror(-run_ret));
aliguori05330442008-11-05 16:29:27 +00001018 abort();
1019 }
1020
aliguori05330442008-11-05 16:29:27 +00001021 switch (run->exit_reason) {
1022 case KVM_EXIT_IO:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001023 DPRINTF("handle_io\n");
Jan Kiszkab30e93e2011-02-01 22:16:01 +01001024 kvm_handle_io(run->io.port,
1025 (uint8_t *)run + run->io.data_offset,
1026 run->io.direction,
1027 run->io.size,
1028 run->io.count);
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001029 ret = 0;
aliguori05330442008-11-05 16:29:27 +00001030 break;
1031 case KVM_EXIT_MMIO:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001032 DPRINTF("handle_mmio\n");
aliguori05330442008-11-05 16:29:27 +00001033 cpu_physical_memory_rw(run->mmio.phys_addr,
1034 run->mmio.data,
1035 run->mmio.len,
1036 run->mmio.is_write);
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001037 ret = 0;
aliguori05330442008-11-05 16:29:27 +00001038 break;
1039 case KVM_EXIT_IRQ_WINDOW_OPEN:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001040 DPRINTF("irq_window_open\n");
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001041 ret = EXCP_INTERRUPT;
aliguori05330442008-11-05 16:29:27 +00001042 break;
1043 case KVM_EXIT_SHUTDOWN:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001044 DPRINTF("shutdown\n");
aliguori05330442008-11-05 16:29:27 +00001045 qemu_system_reset_request();
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001046 ret = EXCP_INTERRUPT;
aliguori05330442008-11-05 16:29:27 +00001047 break;
1048 case KVM_EXIT_UNKNOWN:
Jan Kiszkabb44e0d2011-01-21 21:48:07 +01001049 fprintf(stderr, "KVM: unknown exit, hardware reason %" PRIx64 "\n",
1050 (uint64_t)run->hw.hardware_exit_reason);
Jan Kiszka73aaec42011-01-21 21:48:06 +01001051 ret = -1;
aliguori05330442008-11-05 16:29:27 +00001052 break;
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001053 case KVM_EXIT_INTERNAL_ERROR:
Jan Kiszka73aaec42011-01-21 21:48:06 +01001054 ret = kvm_handle_internal_error(env, run);
Marcelo Tosatti7c80eef2010-03-23 13:37:11 -03001055 break;
aliguori05330442008-11-05 16:29:27 +00001056 default:
Blue Swirl8c0d5772010-04-18 14:22:14 +00001057 DPRINTF("kvm_arch_handle_exit\n");
aliguori05330442008-11-05 16:29:27 +00001058 ret = kvm_arch_handle_exit(env, run);
1059 break;
1060 }
Jan Kiszkad73cd8f2011-03-15 12:26:27 +01001061 } while (ret == 0);
aliguori05330442008-11-05 16:29:27 +00001062
Jan Kiszka73aaec42011-01-21 21:48:06 +01001063 if (ret < 0) {
Jan Kiszkaf5c848e2011-01-21 21:48:08 +01001064 cpu_dump_state(env, stderr, fprintf, CPU_DUMP_CODE);
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03001065 vm_stop(RUN_STATE_INTERNAL_ERROR);
Jan Kiszka73aaec42011-01-21 21:48:06 +01001066 }
aliguoribecfc392008-11-10 15:55:14 +00001067
Jan Kiszka6792a572011-02-07 12:19:18 +01001068 env->exit_request = 0;
1069 cpu_single_env = NULL;
aliguori05330442008-11-05 16:29:27 +00001070 return ret;
1071}
1072
aliguori984b5182008-11-13 19:21:00 +00001073int kvm_ioctl(KVMState *s, int type, ...)
aliguori05330442008-11-05 16:29:27 +00001074{
1075 int ret;
aliguori984b5182008-11-13 19:21:00 +00001076 void *arg;
1077 va_list ap;
aliguori05330442008-11-05 16:29:27 +00001078
aliguori984b5182008-11-13 19:21:00 +00001079 va_start(ap, type);
1080 arg = va_arg(ap, void *);
1081 va_end(ap);
1082
1083 ret = ioctl(s->fd, type, arg);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001084 if (ret == -1) {
aliguori05330442008-11-05 16:29:27 +00001085 ret = -errno;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001086 }
aliguori05330442008-11-05 16:29:27 +00001087 return ret;
1088}
1089
aliguori984b5182008-11-13 19:21:00 +00001090int kvm_vm_ioctl(KVMState *s, int type, ...)
aliguori05330442008-11-05 16:29:27 +00001091{
1092 int ret;
aliguori984b5182008-11-13 19:21:00 +00001093 void *arg;
1094 va_list ap;
aliguori05330442008-11-05 16:29:27 +00001095
aliguori984b5182008-11-13 19:21:00 +00001096 va_start(ap, type);
1097 arg = va_arg(ap, void *);
1098 va_end(ap);
1099
1100 ret = ioctl(s->vmfd, type, arg);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001101 if (ret == -1) {
aliguori05330442008-11-05 16:29:27 +00001102 ret = -errno;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001103 }
aliguori05330442008-11-05 16:29:27 +00001104 return ret;
1105}
1106
aliguori984b5182008-11-13 19:21:00 +00001107int kvm_vcpu_ioctl(CPUState *env, int type, ...)
aliguori05330442008-11-05 16:29:27 +00001108{
1109 int ret;
aliguori984b5182008-11-13 19:21:00 +00001110 void *arg;
1111 va_list ap;
aliguori05330442008-11-05 16:29:27 +00001112
aliguori984b5182008-11-13 19:21:00 +00001113 va_start(ap, type);
1114 arg = va_arg(ap, void *);
1115 va_end(ap);
1116
1117 ret = ioctl(env->kvm_fd, type, arg);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001118 if (ret == -1) {
aliguori05330442008-11-05 16:29:27 +00001119 ret = -errno;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001120 }
aliguori05330442008-11-05 16:29:27 +00001121 return ret;
1122}
aliguoribd322082008-12-04 20:33:06 +00001123
1124int kvm_has_sync_mmu(void)
1125{
Jan Kiszka94a8d392011-01-21 21:48:17 +01001126 return kvm_check_extension(kvm_state, KVM_CAP_SYNC_MMU);
aliguoribd322082008-12-04 20:33:06 +00001127}
aliguorie22a25c2009-03-12 20:12:48 +00001128
Jan Kiszkaa0fb0022009-11-25 00:33:03 +01001129int kvm_has_vcpu_events(void)
1130{
1131 return kvm_state->vcpu_events;
1132}
1133
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001134int kvm_has_robust_singlestep(void)
1135{
1136 return kvm_state->robust_singlestep;
1137}
1138
Jan Kiszkaff44f1a2010-03-12 15:20:49 +01001139int kvm_has_debugregs(void)
1140{
1141 return kvm_state->debugregs;
1142}
1143
Sheng Yangf1665b22010-06-17 17:53:07 +08001144int kvm_has_xsave(void)
1145{
1146 return kvm_state->xsave;
1147}
1148
1149int kvm_has_xcrs(void)
1150{
1151 return kvm_state->xcrs;
1152}
1153
Stefan Hajnoczid2f2b8a2011-01-10 13:50:05 +02001154int kvm_has_many_ioeventfds(void)
1155{
1156 if (!kvm_enabled()) {
1157 return 0;
1158 }
1159 return kvm_state->many_ioeventfds;
1160}
1161
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001162void kvm_setup_guest_memory(void *start, size_t size)
1163{
1164 if (!kvm_has_sync_mmu()) {
Andreas Färbere78815a2010-09-25 11:26:05 +00001165 int ret = qemu_madvise(start, size, QEMU_MADV_DONTFORK);
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001166
1167 if (ret) {
Andreas Färbere78815a2010-09-25 11:26:05 +00001168 perror("qemu_madvise");
1169 fprintf(stderr,
1170 "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001171 exit(1);
1172 }
Jan Kiszka6f0437e2009-04-26 18:03:40 +02001173 }
1174}
1175
aliguorie22a25c2009-03-12 20:12:48 +00001176#ifdef KVM_CAP_SET_GUEST_DEBUG
1177struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
1178 target_ulong pc)
1179{
1180 struct kvm_sw_breakpoint *bp;
1181
Blue Swirl72cf2d42009-09-12 07:36:22 +00001182 QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) {
Jan Kiszkaa426e122011-01-04 09:32:13 +01001183 if (bp->pc == pc) {
aliguorie22a25c2009-03-12 20:12:48 +00001184 return bp;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001185 }
aliguorie22a25c2009-03-12 20:12:48 +00001186 }
1187 return NULL;
1188}
1189
1190int kvm_sw_breakpoints_active(CPUState *env)
1191{
Blue Swirl72cf2d42009-09-12 07:36:22 +00001192 return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints);
aliguorie22a25c2009-03-12 20:12:48 +00001193}
1194
Glauber Costa452e4752009-07-16 17:55:28 -04001195struct kvm_set_guest_debug_data {
1196 struct kvm_guest_debug dbg;
1197 CPUState *env;
1198 int err;
1199};
1200
1201static void kvm_invoke_set_guest_debug(void *data)
1202{
1203 struct kvm_set_guest_debug_data *dbg_data = data;
Jan Kiszkab3807722009-09-17 20:05:58 +02001204 CPUState *env = dbg_data->env;
1205
Jan Kiszkab3807722009-09-17 20:05:58 +02001206 dbg_data->err = kvm_vcpu_ioctl(env, KVM_SET_GUEST_DEBUG, &dbg_data->dbg);
Glauber Costa452e4752009-07-16 17:55:28 -04001207}
1208
aliguorie22a25c2009-03-12 20:12:48 +00001209int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
1210{
Glauber Costa452e4752009-07-16 17:55:28 -04001211 struct kvm_set_guest_debug_data data;
aliguorie22a25c2009-03-12 20:12:48 +00001212
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001213 data.dbg.control = reinject_trap;
aliguorie22a25c2009-03-12 20:12:48 +00001214
Jan Kiszkab0b1d692010-03-01 19:10:29 +01001215 if (env->singlestep_enabled) {
1216 data.dbg.control |= KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
1217 }
Glauber Costa452e4752009-07-16 17:55:28 -04001218 kvm_arch_update_guest_debug(env, &data.dbg);
Glauber Costa452e4752009-07-16 17:55:28 -04001219 data.env = env;
aliguorie22a25c2009-03-12 20:12:48 +00001220
Jan Kiszkabe41cbe2010-05-20 00:28:45 +02001221 run_on_cpu(env, kvm_invoke_set_guest_debug, &data);
Glauber Costa452e4752009-07-16 17:55:28 -04001222 return data.err;
aliguorie22a25c2009-03-12 20:12:48 +00001223}
1224
1225int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
1226 target_ulong len, int type)
1227{
1228 struct kvm_sw_breakpoint *bp;
1229 CPUState *env;
1230 int err;
1231
1232 if (type == GDB_BREAKPOINT_SW) {
1233 bp = kvm_find_sw_breakpoint(current_env, addr);
1234 if (bp) {
1235 bp->use_count++;
1236 return 0;
1237 }
1238
Anthony Liguori7267c092011-08-20 22:09:37 -05001239 bp = g_malloc(sizeof(struct kvm_sw_breakpoint));
Jan Kiszkaa426e122011-01-04 09:32:13 +01001240 if (!bp) {
aliguorie22a25c2009-03-12 20:12:48 +00001241 return -ENOMEM;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001242 }
aliguorie22a25c2009-03-12 20:12:48 +00001243
1244 bp->pc = addr;
1245 bp->use_count = 1;
1246 err = kvm_arch_insert_sw_breakpoint(current_env, bp);
1247 if (err) {
Anthony Liguori7267c092011-08-20 22:09:37 -05001248 g_free(bp);
aliguorie22a25c2009-03-12 20:12:48 +00001249 return err;
1250 }
1251
Blue Swirl72cf2d42009-09-12 07:36:22 +00001252 QTAILQ_INSERT_HEAD(&current_env->kvm_state->kvm_sw_breakpoints,
aliguorie22a25c2009-03-12 20:12:48 +00001253 bp, entry);
1254 } else {
1255 err = kvm_arch_insert_hw_breakpoint(addr, len, type);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001256 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001257 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001258 }
aliguorie22a25c2009-03-12 20:12:48 +00001259 }
1260
1261 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1262 err = kvm_update_guest_debug(env, 0);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001263 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001264 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001265 }
aliguorie22a25c2009-03-12 20:12:48 +00001266 }
1267 return 0;
1268}
1269
1270int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
1271 target_ulong len, int type)
1272{
1273 struct kvm_sw_breakpoint *bp;
1274 CPUState *env;
1275 int err;
1276
1277 if (type == GDB_BREAKPOINT_SW) {
1278 bp = kvm_find_sw_breakpoint(current_env, addr);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001279 if (!bp) {
aliguorie22a25c2009-03-12 20:12:48 +00001280 return -ENOENT;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001281 }
aliguorie22a25c2009-03-12 20:12:48 +00001282
1283 if (bp->use_count > 1) {
1284 bp->use_count--;
1285 return 0;
1286 }
1287
1288 err = kvm_arch_remove_sw_breakpoint(current_env, bp);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001289 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001290 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001291 }
aliguorie22a25c2009-03-12 20:12:48 +00001292
Blue Swirl72cf2d42009-09-12 07:36:22 +00001293 QTAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry);
Anthony Liguori7267c092011-08-20 22:09:37 -05001294 g_free(bp);
aliguorie22a25c2009-03-12 20:12:48 +00001295 } else {
1296 err = kvm_arch_remove_hw_breakpoint(addr, len, type);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001297 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001298 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001299 }
aliguorie22a25c2009-03-12 20:12:48 +00001300 }
1301
1302 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1303 err = kvm_update_guest_debug(env, 0);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001304 if (err) {
aliguorie22a25c2009-03-12 20:12:48 +00001305 return err;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001306 }
aliguorie22a25c2009-03-12 20:12:48 +00001307 }
1308 return 0;
1309}
1310
1311void kvm_remove_all_breakpoints(CPUState *current_env)
1312{
1313 struct kvm_sw_breakpoint *bp, *next;
1314 KVMState *s = current_env->kvm_state;
1315 CPUState *env;
1316
Blue Swirl72cf2d42009-09-12 07:36:22 +00001317 QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
aliguorie22a25c2009-03-12 20:12:48 +00001318 if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
1319 /* Try harder to find a CPU that currently sees the breakpoint. */
1320 for (env = first_cpu; env != NULL; env = env->next_cpu) {
Jan Kiszkaa426e122011-01-04 09:32:13 +01001321 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0) {
aliguorie22a25c2009-03-12 20:12:48 +00001322 break;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001323 }
aliguorie22a25c2009-03-12 20:12:48 +00001324 }
1325 }
1326 }
1327 kvm_arch_remove_all_hw_breakpoints();
1328
Jan Kiszkaa426e122011-01-04 09:32:13 +01001329 for (env = first_cpu; env != NULL; env = env->next_cpu) {
aliguorie22a25c2009-03-12 20:12:48 +00001330 kvm_update_guest_debug(env, 0);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001331 }
aliguorie22a25c2009-03-12 20:12:48 +00001332}
1333
1334#else /* !KVM_CAP_SET_GUEST_DEBUG */
1335
1336int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
1337{
1338 return -EINVAL;
1339}
1340
1341int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
1342 target_ulong len, int type)
1343{
1344 return -EINVAL;
1345}
1346
1347int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
1348 target_ulong len, int type)
1349{
1350 return -EINVAL;
1351}
1352
1353void kvm_remove_all_breakpoints(CPUState *current_env)
1354{
1355}
1356#endif /* !KVM_CAP_SET_GUEST_DEBUG */
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001357
1358int kvm_set_signal_mask(CPUState *env, const sigset_t *sigset)
1359{
1360 struct kvm_signal_mask *sigmask;
1361 int r;
1362
Jan Kiszkaa426e122011-01-04 09:32:13 +01001363 if (!sigset) {
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001364 return kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, NULL);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001365 }
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001366
Anthony Liguori7267c092011-08-20 22:09:37 -05001367 sigmask = g_malloc(sizeof(*sigmask) + sizeof(*sigset));
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001368
1369 sigmask->len = 8;
1370 memcpy(sigmask->sigset, sigset, sizeof(*sigset));
1371 r = kvm_vcpu_ioctl(env, KVM_SET_SIGNAL_MASK, sigmask);
Anthony Liguori7267c092011-08-20 22:09:37 -05001372 g_free(sigmask);
Marcelo Tosatticc84de92010-02-17 20:14:42 -02001373
1374 return r;
1375}
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001376
Cam Macdonell44f1a3d2010-07-26 18:10:59 -06001377int kvm_set_ioeventfd_mmio_long(int fd, uint32_t addr, uint32_t val, bool assign)
1378{
Cam Macdonell44f1a3d2010-07-26 18:10:59 -06001379 int ret;
1380 struct kvm_ioeventfd iofd;
1381
1382 iofd.datamatch = val;
1383 iofd.addr = addr;
1384 iofd.len = 4;
1385 iofd.flags = KVM_IOEVENTFD_FLAG_DATAMATCH;
1386 iofd.fd = fd;
1387
1388 if (!kvm_enabled()) {
1389 return -ENOSYS;
1390 }
1391
1392 if (!assign) {
1393 iofd.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
1394 }
1395
1396 ret = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &iofd);
1397
1398 if (ret < 0) {
1399 return -errno;
1400 }
1401
1402 return 0;
Cam Macdonell44f1a3d2010-07-26 18:10:59 -06001403}
1404
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001405int kvm_set_ioeventfd_pio_word(int fd, uint16_t addr, uint16_t val, bool assign)
1406{
1407 struct kvm_ioeventfd kick = {
1408 .datamatch = val,
1409 .addr = addr,
1410 .len = 2,
1411 .flags = KVM_IOEVENTFD_FLAG_DATAMATCH | KVM_IOEVENTFD_FLAG_PIO,
1412 .fd = fd,
1413 };
1414 int r;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001415 if (!kvm_enabled()) {
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001416 return -ENOSYS;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001417 }
1418 if (!assign) {
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001419 kick.flags |= KVM_IOEVENTFD_FLAG_DEASSIGN;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001420 }
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001421 r = kvm_vm_ioctl(kvm_state, KVM_IOEVENTFD, &kick);
Jan Kiszkaa426e122011-01-04 09:32:13 +01001422 if (r < 0) {
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001423 return r;
Jan Kiszkaa426e122011-01-04 09:32:13 +01001424 }
Michael S. Tsirkinca821802010-03-17 13:07:54 +02001425 return 0;
Paolo Bonzini98c85732010-04-19 18:59:30 +00001426}
Jan Kiszkaa1b87fe2011-02-01 22:15:51 +01001427
1428int kvm_on_sigbus_vcpu(CPUState *env, int code, void *addr)
1429{
1430 return kvm_arch_on_sigbus_vcpu(env, code, addr);
1431}
1432
1433int kvm_on_sigbus(int code, void *addr)
1434{
1435 return kvm_arch_on_sigbus(code, addr);
1436}