eepro100: symbolic names for pci registers
[qemu/aliguori-queue.git] / kvm-all.c
blob15ec38e631f08301b1112c6a997a457fd6d8cba3
1 /*
2 * QEMU KVM support
4 * Copyright IBM, Corp. 2008
5 * Red Hat, Inc. 2008
7 * Authors:
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Glauber Costa <gcosta@redhat.com>
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.
16 #include <sys/types.h>
17 #include <sys/ioctl.h>
18 #include <sys/mman.h>
19 #include <stdarg.h>
21 #include <linux/kvm.h>
23 #include "qemu-common.h"
24 #include "sysemu.h"
25 #include "hw/hw.h"
26 #include "gdbstub.h"
27 #include "kvm.h"
29 /* KVM uses PAGE_SIZE in it's definition of COALESCED_MMIO_MAX */
30 #define PAGE_SIZE TARGET_PAGE_SIZE
32 //#define DEBUG_KVM
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
42 typedef struct KVMSlot
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;
51 typedef struct kvm_dirty_log KVMDirtyLog;
53 int kvm_allowed = 0;
55 struct KVMState
57 KVMSlot slots[32];
58 int fd;
59 int vmfd;
60 int regs_modified;
61 int coalesced_mmio;
62 int broken_set_mem_region;
63 int migration_log;
64 int vcpu_events;
65 #ifdef KVM_CAP_SET_GUEST_DEBUG
66 struct kvm_sw_breakpoint_head kvm_sw_breakpoints;
67 #endif
68 int irqchip_in_kernel;
69 int pit_in_kernel;
72 static KVMState *kvm_state;
74 static KVMSlot *kvm_alloc_slot(KVMState *s)
76 int i;
78 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
79 /* KVM private memory slots */
80 if (i >= 8 && i < 12)
81 continue;
82 if (s->slots[i].memory_size == 0)
83 return &s->slots[i];
86 fprintf(stderr, "%s: no free slot available\n", __func__);
87 abort();
90 static KVMSlot *kvm_lookup_matching_slot(KVMState *s,
91 target_phys_addr_t start_addr,
92 target_phys_addr_t end_addr)
94 int i;
96 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
97 KVMSlot *mem = &s->slots[i];
99 if (start_addr == mem->start_addr &&
100 end_addr == mem->start_addr + mem->memory_size) {
101 return mem;
105 return NULL;
109 * Find overlapping slot with lowest start address
111 static KVMSlot *kvm_lookup_overlapping_slot(KVMState *s,
112 target_phys_addr_t start_addr,
113 target_phys_addr_t end_addr)
115 KVMSlot *found = NULL;
116 int i;
118 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
119 KVMSlot *mem = &s->slots[i];
121 if (mem->memory_size == 0 ||
122 (found && found->start_addr < mem->start_addr)) {
123 continue;
126 if (end_addr > mem->start_addr &&
127 start_addr < mem->start_addr + mem->memory_size) {
128 found = mem;
132 return found;
135 static int kvm_set_user_memory_region(KVMState *s, KVMSlot *slot)
137 struct kvm_userspace_memory_region mem;
139 mem.slot = slot->slot;
140 mem.guest_phys_addr = slot->start_addr;
141 mem.memory_size = slot->memory_size;
142 mem.userspace_addr = (unsigned long)qemu_get_ram_ptr(slot->phys_offset);
143 mem.flags = slot->flags;
144 if (s->migration_log) {
145 mem.flags |= KVM_MEM_LOG_DIRTY_PAGES;
147 return kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, &mem);
150 static void kvm_reset_vcpu(void *opaque)
152 CPUState *env = opaque;
154 kvm_arch_reset_vcpu(env);
155 if (kvm_arch_put_registers(env)) {
156 fprintf(stderr, "Fatal: kvm vcpu reset failed\n");
157 abort();
161 int kvm_irqchip_in_kernel(void)
163 return kvm_state->irqchip_in_kernel;
166 int kvm_pit_in_kernel(void)
168 return kvm_state->pit_in_kernel;
172 int kvm_init_vcpu(CPUState *env)
174 KVMState *s = kvm_state;
175 long mmap_size;
176 int ret;
178 dprintf("kvm_init_vcpu\n");
180 ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
181 if (ret < 0) {
182 dprintf("kvm_create_vcpu failed\n");
183 goto err;
186 env->kvm_fd = ret;
187 env->kvm_state = s;
189 mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
190 if (mmap_size < 0) {
191 dprintf("KVM_GET_VCPU_MMAP_SIZE failed\n");
192 goto err;
195 env->kvm_run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED,
196 env->kvm_fd, 0);
197 if (env->kvm_run == MAP_FAILED) {
198 ret = -errno;
199 dprintf("mmap'ing vcpu state failed\n");
200 goto err;
203 ret = kvm_arch_init_vcpu(env);
204 if (ret == 0) {
205 qemu_register_reset(kvm_reset_vcpu, env);
206 kvm_arch_reset_vcpu(env);
207 ret = kvm_arch_put_registers(env);
209 err:
210 return ret;
214 * dirty pages logging control
216 static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr,
217 ram_addr_t size, int flags, int mask)
219 KVMState *s = kvm_state;
220 KVMSlot *mem = kvm_lookup_matching_slot(s, phys_addr, phys_addr + size);
221 int old_flags;
223 if (mem == NULL) {
224 fprintf(stderr, "BUG: %s: invalid parameters " TARGET_FMT_plx "-"
225 TARGET_FMT_plx "\n", __func__, phys_addr,
226 (target_phys_addr_t)(phys_addr + size - 1));
227 return -EINVAL;
230 old_flags = mem->flags;
232 flags = (mem->flags & ~mask) | flags;
233 mem->flags = flags;
235 /* If nothing changed effectively, no need to issue ioctl */
236 if (s->migration_log) {
237 flags |= KVM_MEM_LOG_DIRTY_PAGES;
239 if (flags == old_flags) {
240 return 0;
243 return kvm_set_user_memory_region(s, mem);
246 int kvm_log_start(target_phys_addr_t phys_addr, ram_addr_t size)
248 return kvm_dirty_pages_log_change(phys_addr, size,
249 KVM_MEM_LOG_DIRTY_PAGES,
250 KVM_MEM_LOG_DIRTY_PAGES);
253 int kvm_log_stop(target_phys_addr_t phys_addr, ram_addr_t size)
255 return kvm_dirty_pages_log_change(phys_addr, size,
257 KVM_MEM_LOG_DIRTY_PAGES);
260 int kvm_set_migration_log(int enable)
262 KVMState *s = kvm_state;
263 KVMSlot *mem;
264 int i, err;
266 s->migration_log = enable;
268 for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
269 mem = &s->slots[i];
271 if (!!(mem->flags & KVM_MEM_LOG_DIRTY_PAGES) == enable) {
272 continue;
274 err = kvm_set_user_memory_region(s, mem);
275 if (err) {
276 return err;
279 return 0;
282 static int test_le_bit(unsigned long nr, unsigned char *addr)
284 return (addr[nr >> 3] >> (nr & 7)) & 1;
288 * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
289 * This function updates qemu's dirty bitmap using cpu_physical_memory_set_dirty().
290 * This means all bits are set to dirty.
292 * @start_add: start of logged region.
293 * @end_addr: end of logged region.
295 int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr,
296 target_phys_addr_t end_addr)
298 KVMState *s = kvm_state;
299 unsigned long size, allocated_size = 0;
300 target_phys_addr_t phys_addr;
301 ram_addr_t addr;
302 KVMDirtyLog d;
303 KVMSlot *mem;
304 int ret = 0;
306 d.dirty_bitmap = NULL;
307 while (start_addr < end_addr) {
308 mem = kvm_lookup_overlapping_slot(s, start_addr, end_addr);
309 if (mem == NULL) {
310 break;
313 size = ((mem->memory_size >> TARGET_PAGE_BITS) + 7) / 8;
314 if (!d.dirty_bitmap) {
315 d.dirty_bitmap = qemu_malloc(size);
316 } else if (size > allocated_size) {
317 d.dirty_bitmap = qemu_realloc(d.dirty_bitmap, size);
319 allocated_size = size;
320 memset(d.dirty_bitmap, 0, allocated_size);
322 d.slot = mem->slot;
324 if (kvm_vm_ioctl(s, KVM_GET_DIRTY_LOG, &d) == -1) {
325 dprintf("ioctl failed %d\n", errno);
326 ret = -1;
327 break;
330 for (phys_addr = mem->start_addr, addr = mem->phys_offset;
331 phys_addr < mem->start_addr + mem->memory_size;
332 phys_addr += TARGET_PAGE_SIZE, addr += TARGET_PAGE_SIZE) {
333 unsigned char *bitmap = (unsigned char *)d.dirty_bitmap;
334 unsigned nr = (phys_addr - mem->start_addr) >> TARGET_PAGE_BITS;
336 if (test_le_bit(nr, bitmap)) {
337 cpu_physical_memory_set_dirty(addr);
340 start_addr = phys_addr;
342 qemu_free(d.dirty_bitmap);
344 return ret;
347 int kvm_coalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
349 int ret = -ENOSYS;
350 #ifdef KVM_CAP_COALESCED_MMIO
351 KVMState *s = kvm_state;
353 if (s->coalesced_mmio) {
354 struct kvm_coalesced_mmio_zone zone;
356 zone.addr = start;
357 zone.size = size;
359 ret = kvm_vm_ioctl(s, KVM_REGISTER_COALESCED_MMIO, &zone);
361 #endif
363 return ret;
366 int kvm_uncoalesce_mmio_region(target_phys_addr_t start, ram_addr_t size)
368 int ret = -ENOSYS;
369 #ifdef KVM_CAP_COALESCED_MMIO
370 KVMState *s = kvm_state;
372 if (s->coalesced_mmio) {
373 struct kvm_coalesced_mmio_zone zone;
375 zone.addr = start;
376 zone.size = size;
378 ret = kvm_vm_ioctl(s, KVM_UNREGISTER_COALESCED_MMIO, &zone);
380 #endif
382 return ret;
385 int kvm_check_extension(KVMState *s, unsigned int extension)
387 int ret;
389 ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, extension);
390 if (ret < 0) {
391 ret = 0;
394 return ret;
397 int kvm_init(int smp_cpus)
399 static const char upgrade_note[] =
400 "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
401 "(see http://sourceforge.net/projects/kvm).\n";
402 KVMState *s;
403 int ret;
404 int i;
406 if (smp_cpus > 1) {
407 fprintf(stderr, "No SMP KVM support, use '-smp 1'\n");
408 return -EINVAL;
411 s = qemu_mallocz(sizeof(KVMState));
413 #ifdef KVM_CAP_SET_GUEST_DEBUG
414 QTAILQ_INIT(&s->kvm_sw_breakpoints);
415 #endif
416 for (i = 0; i < ARRAY_SIZE(s->slots); i++)
417 s->slots[i].slot = i;
419 s->vmfd = -1;
420 s->fd = qemu_open("/dev/kvm", O_RDWR);
421 if (s->fd == -1) {
422 fprintf(stderr, "Could not access KVM kernel module: %m\n");
423 ret = -errno;
424 goto err;
427 ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
428 if (ret < KVM_API_VERSION) {
429 if (ret > 0)
430 ret = -EINVAL;
431 fprintf(stderr, "kvm version too old\n");
432 goto err;
435 if (ret > KVM_API_VERSION) {
436 ret = -EINVAL;
437 fprintf(stderr, "kvm version not supported\n");
438 goto err;
441 s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
442 if (s->vmfd < 0)
443 goto err;
445 /* initially, KVM allocated its own memory and we had to jump through
446 * hooks to make phys_ram_base point to this. Modern versions of KVM
447 * just use a user allocated buffer so we can use regular pages
448 * unmodified. Make sure we have a sufficiently modern version of KVM.
450 if (!kvm_check_extension(s, KVM_CAP_USER_MEMORY)) {
451 ret = -EINVAL;
452 fprintf(stderr, "kvm does not support KVM_CAP_USER_MEMORY\n%s",
453 upgrade_note);
454 goto err;
457 /* There was a nasty bug in < kvm-80 that prevents memory slots from being
458 * destroyed properly. Since we rely on this capability, refuse to work
459 * with any kernel without this capability. */
460 if (!kvm_check_extension(s, KVM_CAP_DESTROY_MEMORY_REGION_WORKS)) {
461 ret = -EINVAL;
463 fprintf(stderr,
464 "KVM kernel module broken (DESTROY_MEMORY_REGION).\n%s",
465 upgrade_note);
466 goto err;
469 #ifdef KVM_CAP_COALESCED_MMIO
470 s->coalesced_mmio = kvm_check_extension(s, KVM_CAP_COALESCED_MMIO);
471 #else
472 s->coalesced_mmio = 0;
473 #endif
475 s->broken_set_mem_region = 1;
476 #ifdef KVM_CAP_JOIN_MEMORY_REGIONS_WORKS
477 ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS);
478 if (ret > 0) {
479 s->broken_set_mem_region = 0;
481 #endif
483 s->vcpu_events = 0;
484 #ifdef KVM_CAP_VCPU_EVENTS
485 s->vcpu_events = kvm_check_extension(s, KVM_CAP_VCPU_EVENTS);
486 #endif
488 ret = kvm_arch_init(s, smp_cpus);
489 if (ret < 0)
490 goto err;
492 kvm_state = s;
494 return 0;
496 err:
497 if (s) {
498 if (s->vmfd != -1)
499 close(s->vmfd);
500 if (s->fd != -1)
501 close(s->fd);
503 qemu_free(s);
505 return ret;
508 static int kvm_handle_io(uint16_t port, void *data, int direction, int size,
509 uint32_t count)
511 int i;
512 uint8_t *ptr = data;
514 for (i = 0; i < count; i++) {
515 if (direction == KVM_EXIT_IO_IN) {
516 switch (size) {
517 case 1:
518 stb_p(ptr, cpu_inb(port));
519 break;
520 case 2:
521 stw_p(ptr, cpu_inw(port));
522 break;
523 case 4:
524 stl_p(ptr, cpu_inl(port));
525 break;
527 } else {
528 switch (size) {
529 case 1:
530 cpu_outb(port, ldub_p(ptr));
531 break;
532 case 2:
533 cpu_outw(port, lduw_p(ptr));
534 break;
535 case 4:
536 cpu_outl(port, ldl_p(ptr));
537 break;
541 ptr += size;
544 return 1;
547 static void kvm_run_coalesced_mmio(CPUState *env, struct kvm_run *run)
549 #ifdef KVM_CAP_COALESCED_MMIO
550 KVMState *s = kvm_state;
551 if (s->coalesced_mmio) {
552 struct kvm_coalesced_mmio_ring *ring;
554 ring = (void *)run + (s->coalesced_mmio * TARGET_PAGE_SIZE);
555 while (ring->first != ring->last) {
556 struct kvm_coalesced_mmio *ent;
558 ent = &ring->coalesced_mmio[ring->first];
560 cpu_physical_memory_write(ent->phys_addr, ent->data, ent->len);
561 /* FIXME smp_wmb() */
562 ring->first = (ring->first + 1) % KVM_COALESCED_MMIO_MAX;
565 #endif
568 void kvm_cpu_synchronize_state(CPUState *env)
570 if (!env->kvm_state->regs_modified) {
571 kvm_arch_get_registers(env);
572 env->kvm_state->regs_modified = 1;
576 int kvm_cpu_exec(CPUState *env)
578 struct kvm_run *run = env->kvm_run;
579 int ret;
581 dprintf("kvm_cpu_exec()\n");
583 do {
584 if (env->exit_request) {
585 dprintf("interrupt exit requested\n");
586 ret = 0;
587 break;
590 if (env->kvm_state->regs_modified) {
591 kvm_arch_put_registers(env);
592 env->kvm_state->regs_modified = 0;
595 kvm_arch_pre_run(env, run);
596 qemu_mutex_unlock_iothread();
597 ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
598 qemu_mutex_lock_iothread();
599 kvm_arch_post_run(env, run);
601 if (ret == -EINTR || ret == -EAGAIN) {
602 dprintf("io window exit\n");
603 ret = 0;
604 break;
607 if (ret < 0) {
608 dprintf("kvm run failed %s\n", strerror(-ret));
609 abort();
612 kvm_run_coalesced_mmio(env, run);
614 ret = 0; /* exit loop */
615 switch (run->exit_reason) {
616 case KVM_EXIT_IO:
617 dprintf("handle_io\n");
618 ret = kvm_handle_io(run->io.port,
619 (uint8_t *)run + run->io.data_offset,
620 run->io.direction,
621 run->io.size,
622 run->io.count);
623 break;
624 case KVM_EXIT_MMIO:
625 dprintf("handle_mmio\n");
626 cpu_physical_memory_rw(run->mmio.phys_addr,
627 run->mmio.data,
628 run->mmio.len,
629 run->mmio.is_write);
630 ret = 1;
631 break;
632 case KVM_EXIT_IRQ_WINDOW_OPEN:
633 dprintf("irq_window_open\n");
634 break;
635 case KVM_EXIT_SHUTDOWN:
636 dprintf("shutdown\n");
637 qemu_system_reset_request();
638 ret = 1;
639 break;
640 case KVM_EXIT_UNKNOWN:
641 dprintf("kvm_exit_unknown\n");
642 break;
643 case KVM_EXIT_FAIL_ENTRY:
644 dprintf("kvm_exit_fail_entry\n");
645 break;
646 case KVM_EXIT_EXCEPTION:
647 dprintf("kvm_exit_exception\n");
648 break;
649 case KVM_EXIT_DEBUG:
650 dprintf("kvm_exit_debug\n");
651 #ifdef KVM_CAP_SET_GUEST_DEBUG
652 if (kvm_arch_debug(&run->debug.arch)) {
653 gdb_set_stop_cpu(env);
654 vm_stop(EXCP_DEBUG);
655 env->exception_index = EXCP_DEBUG;
656 return 0;
658 /* re-enter, this exception was guest-internal */
659 ret = 1;
660 #endif /* KVM_CAP_SET_GUEST_DEBUG */
661 break;
662 default:
663 dprintf("kvm_arch_handle_exit\n");
664 ret = kvm_arch_handle_exit(env, run);
665 break;
667 } while (ret > 0);
669 if (env->exit_request) {
670 env->exit_request = 0;
671 env->exception_index = EXCP_INTERRUPT;
674 return ret;
677 void kvm_set_phys_mem(target_phys_addr_t start_addr,
678 ram_addr_t size,
679 ram_addr_t phys_offset)
681 KVMState *s = kvm_state;
682 ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
683 KVMSlot *mem, old;
684 int err;
686 if (start_addr & ~TARGET_PAGE_MASK) {
687 if (flags >= IO_MEM_UNASSIGNED) {
688 if (!kvm_lookup_overlapping_slot(s, start_addr,
689 start_addr + size)) {
690 return;
692 fprintf(stderr, "Unaligned split of a KVM memory slot\n");
693 } else {
694 fprintf(stderr, "Only page-aligned memory slots supported\n");
696 abort();
699 /* KVM does not support read-only slots */
700 phys_offset &= ~IO_MEM_ROM;
702 while (1) {
703 mem = kvm_lookup_overlapping_slot(s, start_addr, start_addr + size);
704 if (!mem) {
705 break;
708 if (flags < IO_MEM_UNASSIGNED && start_addr >= mem->start_addr &&
709 (start_addr + size <= mem->start_addr + mem->memory_size) &&
710 (phys_offset - start_addr == mem->phys_offset - mem->start_addr)) {
711 /* The new slot fits into the existing one and comes with
712 * identical parameters - nothing to be done. */
713 return;
716 old = *mem;
718 /* unregister the overlapping slot */
719 mem->memory_size = 0;
720 err = kvm_set_user_memory_region(s, mem);
721 if (err) {
722 fprintf(stderr, "%s: error unregistering overlapping slot: %s\n",
723 __func__, strerror(-err));
724 abort();
727 /* Workaround for older KVM versions: we can't join slots, even not by
728 * unregistering the previous ones and then registering the larger
729 * slot. We have to maintain the existing fragmentation. Sigh.
731 * This workaround assumes that the new slot starts at the same
732 * address as the first existing one. If not or if some overlapping
733 * slot comes around later, we will fail (not seen in practice so far)
734 * - and actually require a recent KVM version. */
735 if (s->broken_set_mem_region &&
736 old.start_addr == start_addr && old.memory_size < size &&
737 flags < IO_MEM_UNASSIGNED) {
738 mem = kvm_alloc_slot(s);
739 mem->memory_size = old.memory_size;
740 mem->start_addr = old.start_addr;
741 mem->phys_offset = old.phys_offset;
742 mem->flags = 0;
744 err = kvm_set_user_memory_region(s, mem);
745 if (err) {
746 fprintf(stderr, "%s: error updating slot: %s\n", __func__,
747 strerror(-err));
748 abort();
751 start_addr += old.memory_size;
752 phys_offset += old.memory_size;
753 size -= old.memory_size;
754 continue;
757 /* register prefix slot */
758 if (old.start_addr < start_addr) {
759 mem = kvm_alloc_slot(s);
760 mem->memory_size = start_addr - old.start_addr;
761 mem->start_addr = old.start_addr;
762 mem->phys_offset = old.phys_offset;
763 mem->flags = 0;
765 err = kvm_set_user_memory_region(s, mem);
766 if (err) {
767 fprintf(stderr, "%s: error registering prefix slot: %s\n",
768 __func__, strerror(-err));
769 abort();
773 /* register suffix slot */
774 if (old.start_addr + old.memory_size > start_addr + size) {
775 ram_addr_t size_delta;
777 mem = kvm_alloc_slot(s);
778 mem->start_addr = start_addr + size;
779 size_delta = mem->start_addr - old.start_addr;
780 mem->memory_size = old.memory_size - size_delta;
781 mem->phys_offset = old.phys_offset + size_delta;
782 mem->flags = 0;
784 err = kvm_set_user_memory_region(s, mem);
785 if (err) {
786 fprintf(stderr, "%s: error registering suffix slot: %s\n",
787 __func__, strerror(-err));
788 abort();
793 /* in case the KVM bug workaround already "consumed" the new slot */
794 if (!size)
795 return;
797 /* KVM does not need to know about this memory */
798 if (flags >= IO_MEM_UNASSIGNED)
799 return;
801 mem = kvm_alloc_slot(s);
802 mem->memory_size = size;
803 mem->start_addr = start_addr;
804 mem->phys_offset = phys_offset;
805 mem->flags = 0;
807 err = kvm_set_user_memory_region(s, mem);
808 if (err) {
809 fprintf(stderr, "%s: error registering slot: %s\n", __func__,
810 strerror(-err));
811 abort();
815 int kvm_ioctl(KVMState *s, int type, ...)
817 int ret;
818 void *arg;
819 va_list ap;
821 va_start(ap, type);
822 arg = va_arg(ap, void *);
823 va_end(ap);
825 ret = ioctl(s->fd, type, arg);
826 if (ret == -1)
827 ret = -errno;
829 return ret;
832 int kvm_vm_ioctl(KVMState *s, int type, ...)
834 int ret;
835 void *arg;
836 va_list ap;
838 va_start(ap, type);
839 arg = va_arg(ap, void *);
840 va_end(ap);
842 ret = ioctl(s->vmfd, type, arg);
843 if (ret == -1)
844 ret = -errno;
846 return ret;
849 int kvm_vcpu_ioctl(CPUState *env, int type, ...)
851 int ret;
852 void *arg;
853 va_list ap;
855 va_start(ap, type);
856 arg = va_arg(ap, void *);
857 va_end(ap);
859 ret = ioctl(env->kvm_fd, type, arg);
860 if (ret == -1)
861 ret = -errno;
863 return ret;
866 int kvm_has_sync_mmu(void)
868 #ifdef KVM_CAP_SYNC_MMU
869 KVMState *s = kvm_state;
871 return kvm_check_extension(s, KVM_CAP_SYNC_MMU);
872 #else
873 return 0;
874 #endif
877 int kvm_has_vcpu_events(void)
879 return kvm_state->vcpu_events;
882 void kvm_setup_guest_memory(void *start, size_t size)
884 if (!kvm_has_sync_mmu()) {
885 #ifdef MADV_DONTFORK
886 int ret = madvise(start, size, MADV_DONTFORK);
888 if (ret) {
889 perror("madvice");
890 exit(1);
892 #else
893 fprintf(stderr,
894 "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
895 exit(1);
896 #endif
900 #ifdef KVM_CAP_SET_GUEST_DEBUG
901 static void on_vcpu(CPUState *env, void (*func)(void *data), void *data)
903 #ifdef CONFIG_IOTHREAD
904 if (env == cpu_single_env) {
905 func(data);
906 return;
908 abort();
909 #else
910 func(data);
911 #endif
914 struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *env,
915 target_ulong pc)
917 struct kvm_sw_breakpoint *bp;
919 QTAILQ_FOREACH(bp, &env->kvm_state->kvm_sw_breakpoints, entry) {
920 if (bp->pc == pc)
921 return bp;
923 return NULL;
926 int kvm_sw_breakpoints_active(CPUState *env)
928 return !QTAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints);
931 struct kvm_set_guest_debug_data {
932 struct kvm_guest_debug dbg;
933 CPUState *env;
934 int err;
937 static void kvm_invoke_set_guest_debug(void *data)
939 struct kvm_set_guest_debug_data *dbg_data = data;
940 CPUState *env = dbg_data->env;
942 if (env->kvm_state->regs_modified) {
943 kvm_arch_put_registers(env);
944 env->kvm_state->regs_modified = 0;
946 dbg_data->err = kvm_vcpu_ioctl(env, KVM_SET_GUEST_DEBUG, &dbg_data->dbg);
949 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
951 struct kvm_set_guest_debug_data data;
953 data.dbg.control = 0;
954 if (env->singlestep_enabled)
955 data.dbg.control = KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_SINGLESTEP;
957 kvm_arch_update_guest_debug(env, &data.dbg);
958 data.dbg.control |= reinject_trap;
959 data.env = env;
961 on_vcpu(env, kvm_invoke_set_guest_debug, &data);
962 return data.err;
965 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
966 target_ulong len, int type)
968 struct kvm_sw_breakpoint *bp;
969 CPUState *env;
970 int err;
972 if (type == GDB_BREAKPOINT_SW) {
973 bp = kvm_find_sw_breakpoint(current_env, addr);
974 if (bp) {
975 bp->use_count++;
976 return 0;
979 bp = qemu_malloc(sizeof(struct kvm_sw_breakpoint));
980 if (!bp)
981 return -ENOMEM;
983 bp->pc = addr;
984 bp->use_count = 1;
985 err = kvm_arch_insert_sw_breakpoint(current_env, bp);
986 if (err) {
987 free(bp);
988 return err;
991 QTAILQ_INSERT_HEAD(&current_env->kvm_state->kvm_sw_breakpoints,
992 bp, entry);
993 } else {
994 err = kvm_arch_insert_hw_breakpoint(addr, len, type);
995 if (err)
996 return err;
999 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1000 err = kvm_update_guest_debug(env, 0);
1001 if (err)
1002 return err;
1004 return 0;
1007 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
1008 target_ulong len, int type)
1010 struct kvm_sw_breakpoint *bp;
1011 CPUState *env;
1012 int err;
1014 if (type == GDB_BREAKPOINT_SW) {
1015 bp = kvm_find_sw_breakpoint(current_env, addr);
1016 if (!bp)
1017 return -ENOENT;
1019 if (bp->use_count > 1) {
1020 bp->use_count--;
1021 return 0;
1024 err = kvm_arch_remove_sw_breakpoint(current_env, bp);
1025 if (err)
1026 return err;
1028 QTAILQ_REMOVE(&current_env->kvm_state->kvm_sw_breakpoints, bp, entry);
1029 qemu_free(bp);
1030 } else {
1031 err = kvm_arch_remove_hw_breakpoint(addr, len, type);
1032 if (err)
1033 return err;
1036 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1037 err = kvm_update_guest_debug(env, 0);
1038 if (err)
1039 return err;
1041 return 0;
1044 void kvm_remove_all_breakpoints(CPUState *current_env)
1046 struct kvm_sw_breakpoint *bp, *next;
1047 KVMState *s = current_env->kvm_state;
1048 CPUState *env;
1050 QTAILQ_FOREACH_SAFE(bp, &s->kvm_sw_breakpoints, entry, next) {
1051 if (kvm_arch_remove_sw_breakpoint(current_env, bp) != 0) {
1052 /* Try harder to find a CPU that currently sees the breakpoint. */
1053 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1054 if (kvm_arch_remove_sw_breakpoint(env, bp) == 0)
1055 break;
1059 kvm_arch_remove_all_hw_breakpoints();
1061 for (env = first_cpu; env != NULL; env = env->next_cpu)
1062 kvm_update_guest_debug(env, 0);
1065 #else /* !KVM_CAP_SET_GUEST_DEBUG */
1067 int kvm_update_guest_debug(CPUState *env, unsigned long reinject_trap)
1069 return -EINVAL;
1072 int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
1073 target_ulong len, int type)
1075 return -EINVAL;
1078 int kvm_remove_breakpoint(CPUState *current_env, target_ulong addr,
1079 target_ulong len, int type)
1081 return -EINVAL;
1084 void kvm_remove_all_breakpoints(CPUState *current_env)
1087 #endif /* !KVM_CAP_SET_GUEST_DEBUG */