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