4 * Copyright IBM, Corp. 2008
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>
21 #include <linux/kvm.h>
23 #include "qemu-common.h"
24 #include "qemu-barrier.h"
30 /* KVM uses PAGE_SIZE in it's definition of COALESCED_MMIO_MAX */
31 #define PAGE_SIZE TARGET_PAGE_SIZE
36 #define dprintf(fmt, ...) \
37 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
39 #define dprintf(fmt, ...) \
43 typedef struct KVMSlot
45 target_phys_addr_t start_addr
;
46 ram_addr_t memory_size
;
47 ram_addr_t phys_offset
;
52 typedef struct kvm_dirty_log KVMDirtyLog
;
62 #ifdef KVM_CAP_COALESCED_MMIO
63 struct kvm_coalesced_mmio_ring
*coalesced_mmio_ring
;
65 int broken_set_mem_region
;
68 int robust_singlestep
;
69 #ifdef KVM_CAP_SET_GUEST_DEBUG
70 struct kvm_sw_breakpoint_head kvm_sw_breakpoints
;
72 int irqchip_in_kernel
;
76 static KVMState
*kvm_state
;
78 static KVMSlot
*kvm_alloc_slot(KVMState
*s
)
82 for (i
= 0; i
< ARRAY_SIZE(s
->slots
); i
++) {
83 /* KVM private memory slots */
86 if (s
->slots
[i
].memory_size
== 0)
90 fprintf(stderr
, "%s: no free slot available\n", __func__
);
94 static KVMSlot
*kvm_lookup_matching_slot(KVMState
*s
,
95 target_phys_addr_t start_addr
,
96 target_phys_addr_t end_addr
)
100 for (i
= 0; i
< ARRAY_SIZE(s
->slots
); i
++) {
101 KVMSlot
*mem
= &s
->slots
[i
];
103 if (start_addr
== mem
->start_addr
&&
104 end_addr
== mem
->start_addr
+ mem
->memory_size
) {
113 * Find overlapping slot with lowest start address
115 static KVMSlot
*kvm_lookup_overlapping_slot(KVMState
*s
,
116 target_phys_addr_t start_addr
,
117 target_phys_addr_t end_addr
)
119 KVMSlot
*found
= NULL
;
122 for (i
= 0; i
< ARRAY_SIZE(s
->slots
); i
++) {
123 KVMSlot
*mem
= &s
->slots
[i
];
125 if (mem
->memory_size
== 0 ||
126 (found
&& found
->start_addr
< mem
->start_addr
)) {
130 if (end_addr
> mem
->start_addr
&&
131 start_addr
< mem
->start_addr
+ mem
->memory_size
) {
139 static int kvm_set_user_memory_region(KVMState
*s
, KVMSlot
*slot
)
141 struct kvm_userspace_memory_region mem
;
143 mem
.slot
= slot
->slot
;
144 mem
.guest_phys_addr
= slot
->start_addr
;
145 mem
.memory_size
= slot
->memory_size
;
146 mem
.userspace_addr
= (unsigned long)qemu_get_ram_ptr(slot
->phys_offset
);
147 mem
.flags
= slot
->flags
;
148 if (s
->migration_log
) {
149 mem
.flags
|= KVM_MEM_LOG_DIRTY_PAGES
;
151 return kvm_vm_ioctl(s
, KVM_SET_USER_MEMORY_REGION
, &mem
);
154 static void kvm_reset_vcpu(void *opaque
)
156 CPUState
*env
= opaque
;
158 kvm_arch_reset_vcpu(env
);
159 if (kvm_arch_put_registers(env
)) {
160 fprintf(stderr
, "Fatal: kvm vcpu reset failed\n");
165 int kvm_irqchip_in_kernel(void)
167 return kvm_state
->irqchip_in_kernel
;
170 int kvm_pit_in_kernel(void)
172 return kvm_state
->pit_in_kernel
;
176 int kvm_init_vcpu(CPUState
*env
)
178 KVMState
*s
= kvm_state
;
182 dprintf("kvm_init_vcpu\n");
184 ret
= kvm_vm_ioctl(s
, KVM_CREATE_VCPU
, env
->cpu_index
);
186 dprintf("kvm_create_vcpu failed\n");
193 mmap_size
= kvm_ioctl(s
, KVM_GET_VCPU_MMAP_SIZE
, 0);
195 dprintf("KVM_GET_VCPU_MMAP_SIZE failed\n");
199 env
->kvm_run
= mmap(NULL
, mmap_size
, PROT_READ
| PROT_WRITE
, MAP_SHARED
,
201 if (env
->kvm_run
== MAP_FAILED
) {
203 dprintf("mmap'ing vcpu state failed\n");
207 #ifdef KVM_CAP_COALESCED_MMIO
208 if (s
->coalesced_mmio
&& !s
->coalesced_mmio_ring
)
209 s
->coalesced_mmio_ring
= (void *) env
->kvm_run
+
210 s
->coalesced_mmio
* PAGE_SIZE
;
213 ret
= kvm_arch_init_vcpu(env
);
215 qemu_register_reset(kvm_reset_vcpu
, env
);
216 kvm_arch_reset_vcpu(env
);
217 ret
= kvm_arch_put_registers(env
);
224 * dirty pages logging control
226 static int kvm_dirty_pages_log_change(target_phys_addr_t phys_addr
,
227 ram_addr_t size
, int flags
, int mask
)
229 KVMState
*s
= kvm_state
;
230 KVMSlot
*mem
= kvm_lookup_matching_slot(s
, phys_addr
, phys_addr
+ size
);
234 fprintf(stderr
, "BUG: %s: invalid parameters " TARGET_FMT_plx
"-"
235 TARGET_FMT_plx
"\n", __func__
, phys_addr
,
236 (target_phys_addr_t
)(phys_addr
+ size
- 1));
240 old_flags
= mem
->flags
;
242 flags
= (mem
->flags
& ~mask
) | flags
;
245 /* If nothing changed effectively, no need to issue ioctl */
246 if (s
->migration_log
) {
247 flags
|= KVM_MEM_LOG_DIRTY_PAGES
;
249 if (flags
== old_flags
) {
253 return kvm_set_user_memory_region(s
, mem
);
256 int kvm_log_start(target_phys_addr_t phys_addr
, ram_addr_t size
)
258 return kvm_dirty_pages_log_change(phys_addr
, size
,
259 KVM_MEM_LOG_DIRTY_PAGES
,
260 KVM_MEM_LOG_DIRTY_PAGES
);
263 int kvm_log_stop(target_phys_addr_t phys_addr
, ram_addr_t size
)
265 return kvm_dirty_pages_log_change(phys_addr
, size
,
267 KVM_MEM_LOG_DIRTY_PAGES
);
270 static int kvm_set_migration_log(int enable
)
272 KVMState
*s
= kvm_state
;
276 s
->migration_log
= enable
;
278 for (i
= 0; i
< ARRAY_SIZE(s
->slots
); i
++) {
281 if (!!(mem
->flags
& KVM_MEM_LOG_DIRTY_PAGES
) == enable
) {
284 err
= kvm_set_user_memory_region(s
, mem
);
292 static int test_le_bit(unsigned long nr
, unsigned char *addr
)
294 return (addr
[nr
>> 3] >> (nr
& 7)) & 1;
298 * kvm_physical_sync_dirty_bitmap - Grab dirty bitmap from kernel space
299 * This function updates qemu's dirty bitmap using cpu_physical_memory_set_dirty().
300 * This means all bits are set to dirty.
302 * @start_add: start of logged region.
303 * @end_addr: end of logged region.
305 static int kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr
,
306 target_phys_addr_t end_addr
)
308 KVMState
*s
= kvm_state
;
309 unsigned long size
, allocated_size
= 0;
310 target_phys_addr_t phys_addr
;
316 d
.dirty_bitmap
= NULL
;
317 while (start_addr
< end_addr
) {
318 mem
= kvm_lookup_overlapping_slot(s
, start_addr
, end_addr
);
323 size
= ((mem
->memory_size
>> TARGET_PAGE_BITS
) + 7) / 8;
324 if (!d
.dirty_bitmap
) {
325 d
.dirty_bitmap
= qemu_malloc(size
);
326 } else if (size
> allocated_size
) {
327 d
.dirty_bitmap
= qemu_realloc(d
.dirty_bitmap
, size
);
329 allocated_size
= size
;
330 memset(d
.dirty_bitmap
, 0, allocated_size
);
334 if (kvm_vm_ioctl(s
, KVM_GET_DIRTY_LOG
, &d
) == -1) {
335 dprintf("ioctl failed %d\n", errno
);
340 for (phys_addr
= mem
->start_addr
, addr
= mem
->phys_offset
;
341 phys_addr
< mem
->start_addr
+ mem
->memory_size
;
342 phys_addr
+= TARGET_PAGE_SIZE
, addr
+= TARGET_PAGE_SIZE
) {
343 unsigned char *bitmap
= (unsigned char *)d
.dirty_bitmap
;
344 unsigned nr
= (phys_addr
- mem
->start_addr
) >> TARGET_PAGE_BITS
;
346 if (test_le_bit(nr
, bitmap
)) {
347 cpu_physical_memory_set_dirty(addr
);
350 start_addr
= phys_addr
;
352 qemu_free(d
.dirty_bitmap
);
357 int kvm_coalesce_mmio_region(target_phys_addr_t start
, ram_addr_t size
)
360 #ifdef KVM_CAP_COALESCED_MMIO
361 KVMState
*s
= kvm_state
;
363 if (s
->coalesced_mmio
) {
364 struct kvm_coalesced_mmio_zone zone
;
369 ret
= kvm_vm_ioctl(s
, KVM_REGISTER_COALESCED_MMIO
, &zone
);
376 int kvm_uncoalesce_mmio_region(target_phys_addr_t start
, ram_addr_t size
)
379 #ifdef KVM_CAP_COALESCED_MMIO
380 KVMState
*s
= kvm_state
;
382 if (s
->coalesced_mmio
) {
383 struct kvm_coalesced_mmio_zone zone
;
388 ret
= kvm_vm_ioctl(s
, KVM_UNREGISTER_COALESCED_MMIO
, &zone
);
395 int kvm_check_extension(KVMState
*s
, unsigned int extension
)
399 ret
= kvm_ioctl(s
, KVM_CHECK_EXTENSION
, extension
);
407 static void kvm_set_phys_mem(target_phys_addr_t start_addr
,
409 ram_addr_t phys_offset
)
411 KVMState
*s
= kvm_state
;
412 ram_addr_t flags
= phys_offset
& ~TARGET_PAGE_MASK
;
416 if (start_addr
& ~TARGET_PAGE_MASK
) {
417 if (flags
>= IO_MEM_UNASSIGNED
) {
418 if (!kvm_lookup_overlapping_slot(s
, start_addr
,
419 start_addr
+ size
)) {
422 fprintf(stderr
, "Unaligned split of a KVM memory slot\n");
424 fprintf(stderr
, "Only page-aligned memory slots supported\n");
429 /* KVM does not support read-only slots */
430 phys_offset
&= ~IO_MEM_ROM
;
433 mem
= kvm_lookup_overlapping_slot(s
, start_addr
, start_addr
+ size
);
438 if (flags
< IO_MEM_UNASSIGNED
&& start_addr
>= mem
->start_addr
&&
439 (start_addr
+ size
<= mem
->start_addr
+ mem
->memory_size
) &&
440 (phys_offset
- start_addr
== mem
->phys_offset
- mem
->start_addr
)) {
441 /* The new slot fits into the existing one and comes with
442 * identical parameters - nothing to be done. */
448 /* unregister the overlapping slot */
449 mem
->memory_size
= 0;
450 err
= kvm_set_user_memory_region(s
, mem
);
452 fprintf(stderr
, "%s: error unregistering overlapping slot: %s\n",
453 __func__
, strerror(-err
));
457 /* Workaround for older KVM versions: we can't join slots, even not by
458 * unregistering the previous ones and then registering the larger
459 * slot. We have to maintain the existing fragmentation. Sigh.
461 * This workaround assumes that the new slot starts at the same
462 * address as the first existing one. If not or if some overlapping
463 * slot comes around later, we will fail (not seen in practice so far)
464 * - and actually require a recent KVM version. */
465 if (s
->broken_set_mem_region
&&
466 old
.start_addr
== start_addr
&& old
.memory_size
< size
&&
467 flags
< IO_MEM_UNASSIGNED
) {
468 mem
= kvm_alloc_slot(s
);
469 mem
->memory_size
= old
.memory_size
;
470 mem
->start_addr
= old
.start_addr
;
471 mem
->phys_offset
= old
.phys_offset
;
474 err
= kvm_set_user_memory_region(s
, mem
);
476 fprintf(stderr
, "%s: error updating slot: %s\n", __func__
,
481 start_addr
+= old
.memory_size
;
482 phys_offset
+= old
.memory_size
;
483 size
-= old
.memory_size
;
487 /* register prefix slot */
488 if (old
.start_addr
< start_addr
) {
489 mem
= kvm_alloc_slot(s
);
490 mem
->memory_size
= start_addr
- old
.start_addr
;
491 mem
->start_addr
= old
.start_addr
;
492 mem
->phys_offset
= old
.phys_offset
;
495 err
= kvm_set_user_memory_region(s
, mem
);
497 fprintf(stderr
, "%s: error registering prefix slot: %s\n",
498 __func__
, strerror(-err
));
503 /* register suffix slot */
504 if (old
.start_addr
+ old
.memory_size
> start_addr
+ size
) {
505 ram_addr_t size_delta
;
507 mem
= kvm_alloc_slot(s
);
508 mem
->start_addr
= start_addr
+ size
;
509 size_delta
= mem
->start_addr
- old
.start_addr
;
510 mem
->memory_size
= old
.memory_size
- size_delta
;
511 mem
->phys_offset
= old
.phys_offset
+ size_delta
;
514 err
= kvm_set_user_memory_region(s
, mem
);
516 fprintf(stderr
, "%s: error registering suffix slot: %s\n",
517 __func__
, strerror(-err
));
523 /* in case the KVM bug workaround already "consumed" the new slot */
527 /* KVM does not need to know about this memory */
528 if (flags
>= IO_MEM_UNASSIGNED
)
531 mem
= kvm_alloc_slot(s
);
532 mem
->memory_size
= size
;
533 mem
->start_addr
= start_addr
;
534 mem
->phys_offset
= phys_offset
;
537 err
= kvm_set_user_memory_region(s
, mem
);
539 fprintf(stderr
, "%s: error registering slot: %s\n", __func__
,
545 static void kvm_client_set_memory(struct CPUPhysMemoryClient
*client
,
546 target_phys_addr_t start_addr
,
548 ram_addr_t phys_offset
)
550 kvm_set_phys_mem(start_addr
, size
, phys_offset
);
553 static int kvm_client_sync_dirty_bitmap(struct CPUPhysMemoryClient
*client
,
554 target_phys_addr_t start_addr
,
555 target_phys_addr_t end_addr
)
557 return kvm_physical_sync_dirty_bitmap(start_addr
, end_addr
);
560 static int kvm_client_migration_log(struct CPUPhysMemoryClient
*client
,
563 return kvm_set_migration_log(enable
);
566 static CPUPhysMemoryClient kvm_cpu_phys_memory_client
= {
567 .set_memory
= kvm_client_set_memory
,
568 .sync_dirty_bitmap
= kvm_client_sync_dirty_bitmap
,
569 .migration_log
= kvm_client_migration_log
,
572 int kvm_init(int smp_cpus
)
574 static const char upgrade_note
[] =
575 "Please upgrade to at least kernel 2.6.29 or recent kvm-kmod\n"
576 "(see http://sourceforge.net/projects/kvm).\n";
582 fprintf(stderr
, "No SMP KVM support, use '-smp 1'\n");
586 s
= qemu_mallocz(sizeof(KVMState
));
588 #ifdef KVM_CAP_SET_GUEST_DEBUG
589 QTAILQ_INIT(&s
->kvm_sw_breakpoints
);
591 for (i
= 0; i
< ARRAY_SIZE(s
->slots
); i
++)
592 s
->slots
[i
].slot
= i
;
595 s
->fd
= qemu_open("/dev/kvm", O_RDWR
);
597 fprintf(stderr
, "Could not access KVM kernel module: %m\n");
602 ret
= kvm_ioctl(s
, KVM_GET_API_VERSION
, 0);
603 if (ret
< KVM_API_VERSION
) {
606 fprintf(stderr
, "kvm version too old\n");
610 if (ret
> KVM_API_VERSION
) {
612 fprintf(stderr
, "kvm version not supported\n");
616 s
->vmfd
= kvm_ioctl(s
, KVM_CREATE_VM
, 0);
620 /* initially, KVM allocated its own memory and we had to jump through
621 * hooks to make phys_ram_base point to this. Modern versions of KVM
622 * just use a user allocated buffer so we can use regular pages
623 * unmodified. Make sure we have a sufficiently modern version of KVM.
625 if (!kvm_check_extension(s
, KVM_CAP_USER_MEMORY
)) {
627 fprintf(stderr
, "kvm does not support KVM_CAP_USER_MEMORY\n%s",
632 /* There was a nasty bug in < kvm-80 that prevents memory slots from being
633 * destroyed properly. Since we rely on this capability, refuse to work
634 * with any kernel without this capability. */
635 if (!kvm_check_extension(s
, KVM_CAP_DESTROY_MEMORY_REGION_WORKS
)) {
639 "KVM kernel module broken (DESTROY_MEMORY_REGION).\n%s",
644 s
->coalesced_mmio
= 0;
645 #ifdef KVM_CAP_COALESCED_MMIO
646 s
->coalesced_mmio
= kvm_check_extension(s
, KVM_CAP_COALESCED_MMIO
);
647 s
->coalesced_mmio_ring
= NULL
;
650 s
->broken_set_mem_region
= 1;
651 #ifdef KVM_CAP_JOIN_MEMORY_REGIONS_WORKS
652 ret
= kvm_ioctl(s
, KVM_CHECK_EXTENSION
, KVM_CAP_JOIN_MEMORY_REGIONS_WORKS
);
654 s
->broken_set_mem_region
= 0;
659 #ifdef KVM_CAP_VCPU_EVENTS
660 s
->vcpu_events
= kvm_check_extension(s
, KVM_CAP_VCPU_EVENTS
);
663 s
->robust_singlestep
= 0;
664 #ifdef KVM_CAP_X86_ROBUST_SINGLESTEP
665 s
->robust_singlestep
=
666 kvm_check_extension(s
, KVM_CAP_X86_ROBUST_SINGLESTEP
);
669 ret
= kvm_arch_init(s
, smp_cpus
);
674 cpu_register_phys_memory_client(&kvm_cpu_phys_memory_client
);
690 static int kvm_handle_io(uint16_t port
, void *data
, int direction
, int size
,
696 for (i
= 0; i
< count
; i
++) {
697 if (direction
== KVM_EXIT_IO_IN
) {
700 stb_p(ptr
, cpu_inb(port
));
703 stw_p(ptr
, cpu_inw(port
));
706 stl_p(ptr
, cpu_inl(port
));
712 cpu_outb(port
, ldub_p(ptr
));
715 cpu_outw(port
, lduw_p(ptr
));
718 cpu_outl(port
, ldl_p(ptr
));
729 void kvm_flush_coalesced_mmio_buffer(void)
731 #ifdef KVM_CAP_COALESCED_MMIO
732 KVMState
*s
= kvm_state
;
733 if (s
->coalesced_mmio_ring
) {
734 struct kvm_coalesced_mmio_ring
*ring
= s
->coalesced_mmio_ring
;
735 while (ring
->first
!= ring
->last
) {
736 struct kvm_coalesced_mmio
*ent
;
738 ent
= &ring
->coalesced_mmio
[ring
->first
];
740 cpu_physical_memory_write(ent
->phys_addr
, ent
->data
, ent
->len
);
742 ring
->first
= (ring
->first
+ 1) % KVM_COALESCED_MMIO_MAX
;
748 void kvm_cpu_synchronize_state(CPUState
*env
)
750 if (!env
->kvm_vcpu_dirty
) {
751 kvm_arch_get_registers(env
);
752 env
->kvm_vcpu_dirty
= 1;
756 int kvm_cpu_exec(CPUState
*env
)
758 struct kvm_run
*run
= env
->kvm_run
;
761 dprintf("kvm_cpu_exec()\n");
764 #ifndef CONFIG_IOTHREAD
765 if (env
->exit_request
) {
766 dprintf("interrupt exit requested\n");
772 if (env
->kvm_vcpu_dirty
) {
773 kvm_arch_put_registers(env
);
774 env
->kvm_vcpu_dirty
= 0;
777 kvm_arch_pre_run(env
, run
);
778 qemu_mutex_unlock_iothread();
779 ret
= kvm_vcpu_ioctl(env
, KVM_RUN
, 0);
780 qemu_mutex_lock_iothread();
781 kvm_arch_post_run(env
, run
);
783 if (ret
== -EINTR
|| ret
== -EAGAIN
) {
785 dprintf("io window exit\n");
791 dprintf("kvm run failed %s\n", strerror(-ret
));
795 kvm_flush_coalesced_mmio_buffer();
797 ret
= 0; /* exit loop */
798 switch (run
->exit_reason
) {
800 dprintf("handle_io\n");
801 ret
= kvm_handle_io(run
->io
.port
,
802 (uint8_t *)run
+ run
->io
.data_offset
,
808 dprintf("handle_mmio\n");
809 cpu_physical_memory_rw(run
->mmio
.phys_addr
,
815 case KVM_EXIT_IRQ_WINDOW_OPEN
:
816 dprintf("irq_window_open\n");
818 case KVM_EXIT_SHUTDOWN
:
819 dprintf("shutdown\n");
820 qemu_system_reset_request();
823 case KVM_EXIT_UNKNOWN
:
824 dprintf("kvm_exit_unknown\n");
826 case KVM_EXIT_FAIL_ENTRY
:
827 dprintf("kvm_exit_fail_entry\n");
829 case KVM_EXIT_EXCEPTION
:
830 dprintf("kvm_exit_exception\n");
833 dprintf("kvm_exit_debug\n");
834 #ifdef KVM_CAP_SET_GUEST_DEBUG
835 if (kvm_arch_debug(&run
->debug
.arch
)) {
836 gdb_set_stop_cpu(env
);
838 env
->exception_index
= EXCP_DEBUG
;
841 /* re-enter, this exception was guest-internal */
843 #endif /* KVM_CAP_SET_GUEST_DEBUG */
846 dprintf("kvm_arch_handle_exit\n");
847 ret
= kvm_arch_handle_exit(env
, run
);
852 if (env
->exit_request
) {
853 env
->exit_request
= 0;
854 env
->exception_index
= EXCP_INTERRUPT
;
860 int kvm_ioctl(KVMState
*s
, int type
, ...)
867 arg
= va_arg(ap
, void *);
870 ret
= ioctl(s
->fd
, type
, arg
);
877 int kvm_vm_ioctl(KVMState
*s
, int type
, ...)
884 arg
= va_arg(ap
, void *);
887 ret
= ioctl(s
->vmfd
, type
, arg
);
894 int kvm_vcpu_ioctl(CPUState
*env
, int type
, ...)
901 arg
= va_arg(ap
, void *);
904 ret
= ioctl(env
->kvm_fd
, type
, arg
);
911 int kvm_has_sync_mmu(void)
913 #ifdef KVM_CAP_SYNC_MMU
914 KVMState
*s
= kvm_state
;
916 return kvm_check_extension(s
, KVM_CAP_SYNC_MMU
);
922 int kvm_has_vcpu_events(void)
924 return kvm_state
->vcpu_events
;
927 int kvm_has_robust_singlestep(void)
929 return kvm_state
->robust_singlestep
;
932 void kvm_setup_guest_memory(void *start
, size_t size
)
934 if (!kvm_has_sync_mmu()) {
936 int ret
= madvise(start
, size
, MADV_DONTFORK
);
944 "Need MADV_DONTFORK in absence of synchronous KVM MMU\n");
950 #ifdef KVM_CAP_SET_GUEST_DEBUG
951 static void on_vcpu(CPUState
*env
, void (*func
)(void *data
), void *data
)
953 #ifdef CONFIG_IOTHREAD
954 if (env
!= cpu_single_env
) {
961 struct kvm_sw_breakpoint
*kvm_find_sw_breakpoint(CPUState
*env
,
964 struct kvm_sw_breakpoint
*bp
;
966 QTAILQ_FOREACH(bp
, &env
->kvm_state
->kvm_sw_breakpoints
, entry
) {
973 int kvm_sw_breakpoints_active(CPUState
*env
)
975 return !QTAILQ_EMPTY(&env
->kvm_state
->kvm_sw_breakpoints
);
978 struct kvm_set_guest_debug_data
{
979 struct kvm_guest_debug dbg
;
984 static void kvm_invoke_set_guest_debug(void *data
)
986 struct kvm_set_guest_debug_data
*dbg_data
= data
;
987 CPUState
*env
= dbg_data
->env
;
989 dbg_data
->err
= kvm_vcpu_ioctl(env
, KVM_SET_GUEST_DEBUG
, &dbg_data
->dbg
);
992 int kvm_update_guest_debug(CPUState
*env
, unsigned long reinject_trap
)
994 struct kvm_set_guest_debug_data data
;
996 data
.dbg
.control
= reinject_trap
;
998 if (env
->singlestep_enabled
) {
999 data
.dbg
.control
|= KVM_GUESTDBG_ENABLE
| KVM_GUESTDBG_SINGLESTEP
;
1001 kvm_arch_update_guest_debug(env
, &data
.dbg
);
1004 on_vcpu(env
, kvm_invoke_set_guest_debug
, &data
);
1008 int kvm_insert_breakpoint(CPUState
*current_env
, target_ulong addr
,
1009 target_ulong len
, int type
)
1011 struct kvm_sw_breakpoint
*bp
;
1015 if (type
== GDB_BREAKPOINT_SW
) {
1016 bp
= kvm_find_sw_breakpoint(current_env
, addr
);
1022 bp
= qemu_malloc(sizeof(struct kvm_sw_breakpoint
));
1028 err
= kvm_arch_insert_sw_breakpoint(current_env
, bp
);
1034 QTAILQ_INSERT_HEAD(¤t_env
->kvm_state
->kvm_sw_breakpoints
,
1037 err
= kvm_arch_insert_hw_breakpoint(addr
, len
, type
);
1042 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1043 err
= kvm_update_guest_debug(env
, 0);
1050 int kvm_remove_breakpoint(CPUState
*current_env
, target_ulong addr
,
1051 target_ulong len
, int type
)
1053 struct kvm_sw_breakpoint
*bp
;
1057 if (type
== GDB_BREAKPOINT_SW
) {
1058 bp
= kvm_find_sw_breakpoint(current_env
, addr
);
1062 if (bp
->use_count
> 1) {
1067 err
= kvm_arch_remove_sw_breakpoint(current_env
, bp
);
1071 QTAILQ_REMOVE(¤t_env
->kvm_state
->kvm_sw_breakpoints
, bp
, entry
);
1074 err
= kvm_arch_remove_hw_breakpoint(addr
, len
, type
);
1079 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1080 err
= kvm_update_guest_debug(env
, 0);
1087 void kvm_remove_all_breakpoints(CPUState
*current_env
)
1089 struct kvm_sw_breakpoint
*bp
, *next
;
1090 KVMState
*s
= current_env
->kvm_state
;
1093 QTAILQ_FOREACH_SAFE(bp
, &s
->kvm_sw_breakpoints
, entry
, next
) {
1094 if (kvm_arch_remove_sw_breakpoint(current_env
, bp
) != 0) {
1095 /* Try harder to find a CPU that currently sees the breakpoint. */
1096 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1097 if (kvm_arch_remove_sw_breakpoint(env
, bp
) == 0)
1102 kvm_arch_remove_all_hw_breakpoints();
1104 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
1105 kvm_update_guest_debug(env
, 0);
1108 #else /* !KVM_CAP_SET_GUEST_DEBUG */
1110 int kvm_update_guest_debug(CPUState
*env
, unsigned long reinject_trap
)
1115 int kvm_insert_breakpoint(CPUState
*current_env
, target_ulong addr
,
1116 target_ulong len
, int type
)
1121 int kvm_remove_breakpoint(CPUState
*current_env
, target_ulong addr
,
1122 target_ulong len
, int type
)
1127 void kvm_remove_all_breakpoints(CPUState
*current_env
)
1130 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
1132 int kvm_set_signal_mask(CPUState
*env
, const sigset_t
*sigset
)
1134 struct kvm_signal_mask
*sigmask
;
1138 return kvm_vcpu_ioctl(env
, KVM_SET_SIGNAL_MASK
, NULL
);
1140 sigmask
= qemu_malloc(sizeof(*sigmask
) + sizeof(*sigset
));
1143 memcpy(sigmask
->sigset
, sigset
, sizeof(*sigset
));
1144 r
= kvm_vcpu_ioctl(env
, KVM_SET_SIGNAL_MASK
, sigmask
);