4 * Copyright (C) 2006-2008 Qumranet Technologies
6 * Licensed under the terms of the GNU GPL version 2 or higher.
9 #include "config-host.h"
15 #include "qemu-common.h"
24 #include <sys/utsname.h>
25 #include <sys/syscall.h>
34 int kvm_pit_reinject
= 1;
36 kvm_context_t kvm_context
;
38 pthread_mutex_t qemu_mutex
= PTHREAD_MUTEX_INITIALIZER
;
39 pthread_cond_t qemu_vcpu_cond
= PTHREAD_COND_INITIALIZER
;
40 pthread_cond_t qemu_system_cond
= PTHREAD_COND_INITIALIZER
;
41 pthread_cond_t qemu_pause_cond
= PTHREAD_COND_INITIALIZER
;
42 pthread_cond_t qemu_work_cond
= PTHREAD_COND_INITIALIZER
;
43 __thread
struct CPUState
*current_env
;
45 static int qemu_system_ready
;
47 #define SIG_IPI (SIGRTMIN+4)
50 static int io_thread_fd
= -1;
51 static int io_thread_sigfd
= -1;
53 static CPUState
*kvm_debug_cpu_requested
;
55 /* The list of ioperm_data */
56 static LIST_HEAD(, ioperm_data
) ioperm_head
;
58 static inline unsigned long kvm_get_thread_id(void)
60 return syscall(SYS_gettid
);
63 static void qemu_cond_wait(pthread_cond_t
*cond
)
65 CPUState
*env
= cpu_single_env
;
66 static const struct timespec ts
= {
71 pthread_cond_timedwait(cond
, &qemu_mutex
, &ts
);
75 static void sig_ipi_handler(int n
)
79 static void on_vcpu(CPUState
*env
, void (*func
)(void *data
), void *data
)
81 struct qemu_work_item wi
;
83 if (env
== current_env
) {
90 if (!env
->kvm_cpu_state
.queued_work_first
)
91 env
->kvm_cpu_state
.queued_work_first
= &wi
;
93 env
->kvm_cpu_state
.queued_work_last
->next
= &wi
;
94 env
->kvm_cpu_state
.queued_work_last
= &wi
;
98 pthread_kill(env
->kvm_cpu_state
.thread
, SIG_IPI
);
100 qemu_cond_wait(&qemu_work_cond
);
103 static void inject_interrupt(void *data
)
105 cpu_interrupt(current_env
, (int)data
);
108 void kvm_inject_interrupt(CPUState
*env
, int mask
)
110 on_vcpu(env
, inject_interrupt
, (void *)mask
);
113 void kvm_update_interrupt_request(CPUState
*env
)
118 if (!current_env
|| !current_env
->kvm_cpu_state
.created
)
121 * Testing for created here is really redundant
123 if (current_env
&& current_env
->kvm_cpu_state
.created
&&
124 env
!= current_env
&& !env
->kvm_cpu_state
.signalled
)
128 env
->kvm_cpu_state
.signalled
= 1;
129 if (env
->kvm_cpu_state
.thread
)
130 pthread_kill(env
->kvm_cpu_state
.thread
, SIG_IPI
);
135 void kvm_update_after_sipi(CPUState
*env
)
137 env
->kvm_cpu_state
.sipi_needed
= 1;
138 kvm_update_interrupt_request(env
);
141 void kvm_apic_init(CPUState
*env
)
143 if (env
->cpu_index
!= 0)
144 env
->kvm_cpu_state
.init
= 1;
145 kvm_update_interrupt_request(env
);
150 static int try_push_interrupts(void *opaque
)
152 return kvm_arch_try_push_interrupts(opaque
);
155 static void post_kvm_run(void *opaque
, void *data
)
157 CPUState
*env
= (CPUState
*)data
;
159 pthread_mutex_lock(&qemu_mutex
);
160 kvm_arch_post_kvm_run(opaque
, env
);
163 static int pre_kvm_run(void *opaque
, void *data
)
165 CPUState
*env
= (CPUState
*)data
;
167 kvm_arch_pre_kvm_run(opaque
, env
);
169 if (env
->interrupt_request
& CPU_INTERRUPT_EXIT
)
171 pthread_mutex_unlock(&qemu_mutex
);
175 static void kvm_do_load_registers(void *_env
)
177 CPUState
*env
= _env
;
179 kvm_arch_load_regs(env
);
182 void kvm_load_registers(CPUState
*env
)
184 if (kvm_enabled() && qemu_system_ready
)
185 on_vcpu(env
, kvm_do_load_registers
, env
);
188 static void kvm_do_save_registers(void *_env
)
190 CPUState
*env
= _env
;
192 kvm_arch_save_regs(env
);
195 void kvm_save_registers(CPUState
*env
)
198 on_vcpu(env
, kvm_do_save_registers
, env
);
201 int kvm_cpu_exec(CPUState
*env
)
205 r
= kvm_run(kvm_context
, env
->cpu_index
, env
);
207 printf("kvm_run returned %d\n", r
);
214 static int has_work(CPUState
*env
)
216 if (!vm_running
|| (env
&& env
->kvm_cpu_state
.stopped
))
220 return kvm_arch_has_work(env
);
223 static void flush_queued_work(CPUState
*env
)
225 struct qemu_work_item
*wi
;
227 if (!env
->kvm_cpu_state
.queued_work_first
)
230 while ((wi
= env
->kvm_cpu_state
.queued_work_first
)) {
231 env
->kvm_cpu_state
.queued_work_first
= wi
->next
;
235 env
->kvm_cpu_state
.queued_work_last
= NULL
;
236 pthread_cond_broadcast(&qemu_work_cond
);
239 static void kvm_main_loop_wait(CPUState
*env
, int timeout
)
246 pthread_mutex_unlock(&qemu_mutex
);
248 ts
.tv_sec
= timeout
/ 1000;
249 ts
.tv_nsec
= (timeout
% 1000) * 1000000;
250 sigemptyset(&waitset
);
251 sigaddset(&waitset
, SIG_IPI
);
253 r
= sigtimedwait(&waitset
, &siginfo
, &ts
);
256 pthread_mutex_lock(&qemu_mutex
);
258 if (r
== -1 && !(e
== EAGAIN
|| e
== EINTR
)) {
259 printf("sigtimedwait: %s\n", strerror(e
));
263 cpu_single_env
= env
;
264 flush_queued_work(env
);
266 if (env
->kvm_cpu_state
.stop
) {
267 env
->kvm_cpu_state
.stop
= 0;
268 env
->kvm_cpu_state
.stopped
= 1;
269 pthread_cond_signal(&qemu_pause_cond
);
272 env
->kvm_cpu_state
.signalled
= 0;
275 static int all_threads_paused(void)
277 CPUState
*penv
= first_cpu
;
280 if (penv
->kvm_cpu_state
.stop
)
282 penv
= (CPUState
*)penv
->next_cpu
;
288 static void pause_all_threads(void)
290 CPUState
*penv
= first_cpu
;
293 if (penv
!= cpu_single_env
) {
294 penv
->kvm_cpu_state
.stop
= 1;
295 pthread_kill(penv
->kvm_cpu_state
.thread
, SIG_IPI
);
297 penv
->kvm_cpu_state
.stop
= 0;
298 penv
->kvm_cpu_state
.stopped
= 1;
299 cpu_interrupt(penv
, CPU_INTERRUPT_EXIT
);
301 penv
= (CPUState
*)penv
->next_cpu
;
304 while (!all_threads_paused())
305 qemu_cond_wait(&qemu_pause_cond
);
308 static void resume_all_threads(void)
310 CPUState
*penv
= first_cpu
;
312 assert(!cpu_single_env
);
315 penv
->kvm_cpu_state
.stop
= 0;
316 penv
->kvm_cpu_state
.stopped
= 0;
317 pthread_kill(penv
->kvm_cpu_state
.thread
, SIG_IPI
);
318 penv
= (CPUState
*)penv
->next_cpu
;
322 static void kvm_vm_state_change_handler(void *context
, int running
)
325 resume_all_threads();
330 static void update_regs_for_sipi(CPUState
*env
)
332 kvm_arch_update_regs_for_sipi(env
);
333 env
->kvm_cpu_state
.sipi_needed
= 0;
336 static void update_regs_for_init(CPUState
*env
)
339 SegmentCache cs
= env
->segs
[R_CS
];
345 /* restore SIPI vector */
346 if(env
->kvm_cpu_state
.sipi_needed
)
347 env
->segs
[R_CS
] = cs
;
350 env
->kvm_cpu_state
.init
= 0;
351 kvm_arch_load_regs(env
);
354 static void setup_kernel_sigmask(CPUState
*env
)
359 sigaddset(&set
, SIGUSR2
);
360 sigaddset(&set
, SIGIO
);
361 sigaddset(&set
, SIGALRM
);
362 sigprocmask(SIG_BLOCK
, &set
, NULL
);
364 sigprocmask(SIG_BLOCK
, NULL
, &set
);
365 sigdelset(&set
, SIG_IPI
);
367 kvm_set_signal_mask(kvm_context
, env
->cpu_index
, &set
);
370 static void qemu_kvm_system_reset(void)
372 CPUState
*penv
= first_cpu
;
379 kvm_arch_cpu_reset(penv
);
380 penv
= (CPUState
*)penv
->next_cpu
;
383 resume_all_threads();
386 static int kvm_main_loop_cpu(CPUState
*env
)
388 setup_kernel_sigmask(env
);
390 pthread_mutex_lock(&qemu_mutex
);
391 if (kvm_irqchip_in_kernel(kvm_context
))
394 kvm_qemu_init_env(env
);
396 kvm_tpr_vcpu_start(env
);
399 cpu_single_env
= env
;
400 kvm_load_registers(env
);
403 while (!has_work(env
))
404 kvm_main_loop_wait(env
, 1000);
405 if (env
->interrupt_request
& (CPU_INTERRUPT_HARD
| CPU_INTERRUPT_NMI
))
407 if (!kvm_irqchip_in_kernel(kvm_context
)) {
408 if (env
->kvm_cpu_state
.init
)
409 update_regs_for_init(env
);
410 if (env
->kvm_cpu_state
.sipi_needed
)
411 update_regs_for_sipi(env
);
413 if (!env
->halted
&& !env
->kvm_cpu_state
.init
)
415 env
->interrupt_request
&= ~CPU_INTERRUPT_EXIT
;
416 kvm_main_loop_wait(env
, 0);
418 pthread_mutex_unlock(&qemu_mutex
);
422 static void *ap_main_loop(void *_env
)
424 CPUState
*env
= _env
;
426 struct ioperm_data
*data
= NULL
;
429 env
->thread_id
= kvm_get_thread_id();
430 sigfillset(&signals
);
431 sigprocmask(SIG_BLOCK
, &signals
, NULL
);
432 kvm_create_vcpu(kvm_context
, env
->cpu_index
);
433 kvm_qemu_init_env(env
);
435 #ifdef USE_KVM_DEVICE_ASSIGNMENT
436 /* do ioperm for io ports of assigned devices */
437 LIST_FOREACH(data
, &ioperm_head
, entries
)
438 on_vcpu(env
, kvm_arch_do_ioperm
, data
);
441 /* signal VCPU creation */
442 pthread_mutex_lock(&qemu_mutex
);
443 current_env
->kvm_cpu_state
.created
= 1;
444 pthread_cond_signal(&qemu_vcpu_cond
);
446 /* and wait for machine initialization */
447 while (!qemu_system_ready
)
448 qemu_cond_wait(&qemu_system_cond
);
449 pthread_mutex_unlock(&qemu_mutex
);
451 kvm_main_loop_cpu(env
);
455 void kvm_init_vcpu(CPUState
*env
)
457 pthread_create(&env
->kvm_cpu_state
.thread
, NULL
, ap_main_loop
, env
);
459 while (env
->kvm_cpu_state
.created
== 0)
460 qemu_cond_wait(&qemu_vcpu_cond
);
463 int kvm_init_ap(void)
468 qemu_add_vm_change_state_handler(kvm_vm_state_change_handler
, NULL
);
470 signal(SIG_IPI
, sig_ipi_handler
);
474 void qemu_kvm_notify_work(void)
480 if (io_thread_fd
== -1)
483 memcpy(buffer
, &value
, sizeof(value
));
488 len
= write(io_thread_fd
, buffer
+ offset
, 8 - offset
);
489 if (len
== -1 && errno
== EINTR
)
499 fprintf(stderr
, "failed to notify io thread\n");
502 /* If we have signalfd, we mask out the signals we want to handle and then
503 * use signalfd to listen for them. We rely on whatever the current signal
504 * handler is to dispatch the signals when we receive them.
507 static void sigfd_handler(void *opaque
)
509 int fd
= (unsigned long)opaque
;
510 struct qemu_signalfd_siginfo info
;
511 struct sigaction action
;
516 len
= read(fd
, &info
, sizeof(info
));
517 } while (len
== -1 && errno
== EINTR
);
519 if (len
== -1 && errno
== EAGAIN
)
522 if (len
!= sizeof(info
)) {
523 printf("read from sigfd returned %ld: %m\n", len
);
527 sigaction(info
.ssi_signo
, NULL
, &action
);
528 if (action
.sa_handler
)
529 action
.sa_handler(info
.ssi_signo
);
534 /* Used to break IO thread out of select */
535 static void io_thread_wakeup(void *opaque
)
537 int fd
= (unsigned long)opaque
;
544 len
= read(fd
, buffer
+ offset
, 8 - offset
);
545 if (len
== -1 && errno
== EINTR
)
555 int kvm_main_loop(void)
561 io_thread
= pthread_self();
562 qemu_system_ready
= 1;
564 if (qemu_eventfd(fds
) == -1) {
565 fprintf(stderr
, "failed to create eventfd\n");
569 qemu_set_fd_handler2(fds
[0], NULL
, io_thread_wakeup
, NULL
,
570 (void *)(unsigned long)fds
[0]);
572 io_thread_fd
= fds
[1];
575 sigaddset(&mask
, SIGIO
);
576 sigaddset(&mask
, SIGALRM
);
577 sigprocmask(SIG_BLOCK
, &mask
, NULL
);
579 sigfd
= qemu_signalfd(&mask
);
581 fprintf(stderr
, "failed to create signalfd\n");
585 fcntl(sigfd
, F_SETFL
, O_NONBLOCK
);
587 qemu_set_fd_handler2(sigfd
, NULL
, sigfd_handler
, NULL
,
588 (void *)(unsigned long)sigfd
);
590 pthread_cond_broadcast(&qemu_system_cond
);
592 io_thread_sigfd
= sigfd
;
593 cpu_single_env
= NULL
;
596 main_loop_wait(1000);
597 if (qemu_shutdown_requested())
599 else if (qemu_powerdown_requested())
600 qemu_system_powerdown();
601 else if (qemu_reset_requested())
602 qemu_kvm_system_reset();
603 #ifdef CONFIG_GDBSTUB
604 else if (kvm_debug_cpu_requested
) {
605 gdb_set_stop_cpu(kvm_debug_cpu_requested
);
607 kvm_debug_cpu_requested
= NULL
;
613 pthread_mutex_unlock(&qemu_mutex
);
618 #ifdef KVM_CAP_SET_GUEST_DEBUG
619 int kvm_debug(void *opaque
, void *data
, struct kvm_debug_exit_arch
*arch_info
)
621 int handle
= kvm_arch_debug(arch_info
);
622 struct CPUState
*env
= data
;
625 kvm_debug_cpu_requested
= env
;
626 env
->kvm_cpu_state
.stopped
= 1;
632 static int kvm_inb(void *opaque
, uint16_t addr
, uint8_t *data
)
634 *data
= cpu_inb(0, addr
);
638 static int kvm_inw(void *opaque
, uint16_t addr
, uint16_t *data
)
640 *data
= cpu_inw(0, addr
);
644 static int kvm_inl(void *opaque
, uint16_t addr
, uint32_t *data
)
646 *data
= cpu_inl(0, addr
);
650 #define PM_IO_BASE 0xb000
652 static int kvm_outb(void *opaque
, uint16_t addr
, uint8_t data
)
657 cpu_outb(0, 0xb3, 0);
664 x
= cpu_inw(0, PM_IO_BASE
+ 4);
666 cpu_outw(0, PM_IO_BASE
+ 4, x
);
673 x
= cpu_inw(0, PM_IO_BASE
+ 4);
675 cpu_outw(0, PM_IO_BASE
+ 4, x
);
683 cpu_outb(0, addr
, data
);
687 static int kvm_outw(void *opaque
, uint16_t addr
, uint16_t data
)
689 cpu_outw(0, addr
, data
);
693 static int kvm_outl(void *opaque
, uint16_t addr
, uint32_t data
)
695 cpu_outl(0, addr
, data
);
699 static int kvm_mmio_read(void *opaque
, uint64_t addr
, uint8_t *data
, int len
)
701 cpu_physical_memory_rw(addr
, data
, len
, 0);
705 static int kvm_mmio_write(void *opaque
, uint64_t addr
, uint8_t *data
, int len
)
707 cpu_physical_memory_rw(addr
, data
, len
, 1);
711 static int kvm_io_window(void *opaque
)
717 static int kvm_halt(void *opaque
, int vcpu
)
719 return kvm_arch_halt(opaque
, vcpu
);
722 static int kvm_shutdown(void *opaque
, void *data
)
724 struct CPUState
*env
= (struct CPUState
*)data
;
726 /* stop the current vcpu from going back to guest mode */
727 env
->kvm_cpu_state
.stopped
= 1;
729 qemu_system_reset_request();
733 static struct kvm_callbacks qemu_kvm_ops
= {
734 #ifdef KVM_CAP_SET_GUEST_DEBUG
743 .mmio_read
= kvm_mmio_read
,
744 .mmio_write
= kvm_mmio_write
,
746 .shutdown
= kvm_shutdown
,
747 .io_window
= kvm_io_window
,
748 .try_push_interrupts
= try_push_interrupts
,
749 #ifdef KVM_CAP_USER_NMI
750 .push_nmi
= kvm_arch_push_nmi
,
752 .post_kvm_run
= post_kvm_run
,
753 .pre_kvm_run
= pre_kvm_run
,
755 .tpr_access
= handle_tpr_access
,
758 .powerpc_dcr_read
= handle_powerpc_dcr_read
,
759 .powerpc_dcr_write
= handle_powerpc_dcr_write
,
765 /* Try to initialize kvm */
766 kvm_context
= kvm_init(&qemu_kvm_ops
, cpu_single_env
);
770 pthread_mutex_lock(&qemu_mutex
);
776 static int destroy_region_works
= 0;
779 int kvm_qemu_create_context(void)
785 kvm_disable_irqchip_creation(kvm_context
);
788 kvm_disable_pit_creation(kvm_context
);
790 if (kvm_create(kvm_context
, phys_ram_size
, (void**)&phys_ram_base
) < 0) {
794 r
= kvm_arch_qemu_create_context();
797 if (kvm_pit
&& !kvm_pit_reinject
) {
798 if (kvm_reinject_control(kvm_context
, 0)) {
799 fprintf(stderr
, "failure to disable in-kernel PIT reinjection\n");
804 destroy_region_works
= kvm_destroy_memory_region_works(kvm_context
);
807 if (kvm_irqchip
&& kvm_has_gsi_routing(kvm_context
)) {
808 kvm_clear_gsi_routes(kvm_context
);
809 for (i
= 0; i
< 8; ++i
) {
812 r
= kvm_add_irq_route(kvm_context
, i
, KVM_IRQCHIP_PIC_MASTER
, i
);
816 for (i
= 8; i
< 16; ++i
) {
817 r
= kvm_add_irq_route(kvm_context
, i
, KVM_IRQCHIP_PIC_SLAVE
, i
- 8);
821 for (i
= 0; i
< 24; ++i
) {
822 r
= kvm_add_irq_route(kvm_context
, i
, KVM_IRQCHIP_IOAPIC
, i
);
826 kvm_commit_irq_routes(kvm_context
);
831 void kvm_qemu_destroy(void)
833 kvm_finalize(kvm_context
);
837 static int must_use_aliases_source(target_phys_addr_t addr
)
839 if (destroy_region_works
)
841 if (addr
== 0xa0000 || addr
== 0xa8000)
846 static int must_use_aliases_target(target_phys_addr_t addr
)
848 if (destroy_region_works
)
850 if (addr
>= 0xe0000000 && addr
< 0x100000000ull
)
855 static struct mapping
{
856 target_phys_addr_t phys
;
860 static int nr_mappings
;
862 static struct mapping
*find_ram_mapping(ram_addr_t ram_addr
)
866 for (p
= mappings
; p
< mappings
+ nr_mappings
; ++p
) {
867 if (p
->ram
<= ram_addr
&& ram_addr
< p
->ram
+ p
->len
) {
874 static struct mapping
*find_mapping(target_phys_addr_t start_addr
)
878 for (p
= mappings
; p
< mappings
+ nr_mappings
; ++p
) {
879 if (p
->phys
<= start_addr
&& start_addr
< p
->phys
+ p
->len
) {
886 static void drop_mapping(target_phys_addr_t start_addr
)
888 struct mapping
*p
= find_mapping(start_addr
);
891 *p
= mappings
[--nr_mappings
];
895 void kvm_cpu_register_physical_memory(target_phys_addr_t start_addr
,
897 unsigned long phys_offset
)
900 unsigned long area_flags
= phys_offset
& ~TARGET_PAGE_MASK
;
905 phys_offset
&= ~IO_MEM_ROM
;
907 if (area_flags
== IO_MEM_UNASSIGNED
) {
909 if (must_use_aliases_source(start_addr
)) {
910 kvm_destroy_memory_alias(kvm_context
, start_addr
);
913 if (must_use_aliases_target(start_addr
))
916 kvm_unregister_memory_area(kvm_context
, start_addr
, size
);
920 r
= kvm_is_containing_region(kvm_context
, start_addr
, size
);
924 if (area_flags
>= TLB_MMIO
)
928 if (must_use_aliases_source(start_addr
)) {
929 p
= find_ram_mapping(phys_offset
);
931 kvm_create_memory_alias(kvm_context
, start_addr
, size
,
932 p
->phys
+ (phys_offset
- p
->ram
));
938 r
= kvm_register_phys_mem(kvm_context
, start_addr
,
939 phys_ram_base
+ phys_offset
,
942 printf("kvm_cpu_register_physical_memory: failed\n");
947 drop_mapping(start_addr
);
948 p
= &mappings
[nr_mappings
++];
949 p
->phys
= start_addr
;
950 p
->ram
= phys_offset
;
957 void kvm_cpu_unregister_physical_memory(target_phys_addr_t start_addr
,
958 target_phys_addr_t size
,
959 unsigned long phys_offset
)
961 kvm_unregister_memory_area(kvm_context
, start_addr
, size
);
964 int kvm_setup_guest_memory(void *area
, unsigned long size
)
969 if (kvm_enabled() && !kvm_has_sync_mmu())
970 ret
= madvise(area
, size
, MADV_DONTFORK
);
979 int kvm_qemu_check_extension(int ext
)
981 return kvm_check_extension(kvm_context
, ext
);
984 int kvm_qemu_init_env(CPUState
*cenv
)
986 return kvm_arch_qemu_init_env(cenv
);
989 #ifdef KVM_CAP_SET_GUEST_DEBUG
990 struct kvm_sw_breakpoint_head kvm_sw_breakpoints
=
991 TAILQ_HEAD_INITIALIZER(kvm_sw_breakpoints
);
993 struct kvm_sw_breakpoint
*kvm_find_sw_breakpoint(target_ulong pc
)
995 struct kvm_sw_breakpoint
*bp
;
997 TAILQ_FOREACH(bp
, &kvm_sw_breakpoints
, entry
) {
1004 struct kvm_set_guest_debug_data
{
1005 struct kvm_guest_debug dbg
;
1009 void kvm_invoke_set_guest_debug(void *data
)
1011 struct kvm_set_guest_debug_data
*dbg_data
= data
;
1013 dbg_data
->err
= kvm_set_guest_debug(kvm_context
, cpu_single_env
->cpu_index
,
1017 int kvm_update_guest_debug(CPUState
*env
, unsigned long reinject_trap
)
1019 struct kvm_set_guest_debug_data data
;
1021 data
.dbg
.control
= 0;
1022 if (env
->singlestep_enabled
)
1023 data
.dbg
.control
= KVM_GUESTDBG_ENABLE
| KVM_GUESTDBG_SINGLESTEP
;
1025 kvm_arch_update_guest_debug(env
, &data
.dbg
);
1026 data
.dbg
.control
|= reinject_trap
;
1028 on_vcpu(env
, kvm_invoke_set_guest_debug
, &data
);
1032 int kvm_insert_breakpoint(CPUState
*current_env
, target_ulong addr
,
1033 target_ulong len
, int type
)
1035 struct kvm_sw_breakpoint
*bp
;
1039 if (type
== GDB_BREAKPOINT_SW
) {
1040 bp
= kvm_find_sw_breakpoint(addr
);
1046 bp
= qemu_malloc(sizeof(struct kvm_sw_breakpoint
));
1052 err
= kvm_arch_insert_sw_breakpoint(current_env
, bp
);
1058 TAILQ_INSERT_HEAD(&kvm_sw_breakpoints
, bp
, entry
);
1060 err
= kvm_arch_insert_hw_breakpoint(addr
, len
, type
);
1065 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1066 err
= kvm_update_guest_debug(env
, 0);
1073 int kvm_remove_breakpoint(CPUState
*current_env
, target_ulong addr
,
1074 target_ulong len
, int type
)
1076 struct kvm_sw_breakpoint
*bp
;
1080 if (type
== GDB_BREAKPOINT_SW
) {
1081 bp
= kvm_find_sw_breakpoint(addr
);
1085 if (bp
->use_count
> 1) {
1090 err
= kvm_arch_remove_sw_breakpoint(current_env
, bp
);
1094 TAILQ_REMOVE(&kvm_sw_breakpoints
, bp
, entry
);
1097 err
= kvm_arch_remove_hw_breakpoint(addr
, len
, type
);
1102 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1103 err
= kvm_update_guest_debug(env
, 0);
1110 void kvm_remove_all_breakpoints(CPUState
*current_env
)
1112 struct kvm_sw_breakpoint
*bp
, *next
;
1115 TAILQ_FOREACH_SAFE(bp
, &kvm_sw_breakpoints
, entry
, next
) {
1116 if (kvm_arch_remove_sw_breakpoint(current_env
, bp
) != 0) {
1117 /* Try harder to find a CPU that currently sees the breakpoint. */
1118 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1119 if (kvm_arch_remove_sw_breakpoint(env
, bp
) == 0)
1124 kvm_arch_remove_all_hw_breakpoints();
1126 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
1127 kvm_update_guest_debug(env
, 0);
1130 #else /* !KVM_CAP_SET_GUEST_DEBUG */
1132 int kvm_update_guest_debug(CPUState
*env
, unsigned long reinject_trap
)
1137 int kvm_insert_breakpoint(CPUState
*current_env
, target_ulong addr
,
1138 target_ulong len
, int type
)
1143 int kvm_remove_breakpoint(CPUState
*current_env
, target_ulong addr
,
1144 target_ulong len
, int type
)
1149 void kvm_remove_all_breakpoints(CPUState
*current_env
)
1152 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
1155 * dirty pages logging
1157 /* FIXME: use unsigned long pointer instead of unsigned char */
1158 unsigned char *kvm_dirty_bitmap
= NULL
;
1159 int kvm_physical_memory_set_dirty_tracking(int enable
)
1167 if (!kvm_dirty_bitmap
) {
1168 unsigned bitmap_size
= BITMAP_SIZE(phys_ram_size
);
1169 kvm_dirty_bitmap
= qemu_malloc(bitmap_size
);
1170 if (kvm_dirty_bitmap
== NULL
) {
1171 perror("Failed to allocate dirty pages bitmap");
1175 r
= kvm_dirty_pages_log_enable_all(kvm_context
);
1180 if (kvm_dirty_bitmap
) {
1181 r
= kvm_dirty_pages_log_reset(kvm_context
);
1182 qemu_free(kvm_dirty_bitmap
);
1183 kvm_dirty_bitmap
= NULL
;
1189 /* get kvm's dirty pages bitmap and update qemu's */
1190 static int kvm_get_dirty_pages_log_range(unsigned long start_addr
,
1191 unsigned char *bitmap
,
1192 unsigned int offset
,
1193 unsigned long mem_size
)
1195 unsigned int i
, j
, n
=0;
1197 unsigned long page_number
, addr
, addr1
;
1198 ram_addr_t ram_addr
;
1199 unsigned int len
= ((mem_size
/TARGET_PAGE_SIZE
) + 7) / 8;
1202 * bitmap-traveling is faster than memory-traveling (for addr...)
1203 * especially when most of the memory is not dirty.
1205 for (i
=0; i
<len
; i
++) {
1210 page_number
= i
* 8 + j
;
1211 addr1
= page_number
* TARGET_PAGE_SIZE
;
1212 addr
= offset
+ addr1
;
1213 ram_addr
= cpu_get_physical_page_desc(addr
);
1214 cpu_physical_memory_set_dirty(ram_addr
);
1220 static int kvm_get_dirty_bitmap_cb(unsigned long start
, unsigned long len
,
1221 void *bitmap
, void *opaque
)
1223 return kvm_get_dirty_pages_log_range(start
, bitmap
, start
, len
);
1227 * get kvm's dirty pages bitmap and update qemu's
1228 * we only care about physical ram, which resides in slots 0 and 3
1230 int kvm_update_dirty_pages_log(void)
1235 r
= kvm_get_dirty_pages_range(kvm_context
, 0, phys_ram_size
,
1236 kvm_dirty_bitmap
, NULL
,
1237 kvm_get_dirty_bitmap_cb
);
1241 void kvm_qemu_log_memory(target_phys_addr_t start
, target_phys_addr_t size
,
1245 kvm_dirty_pages_log_enable_slot(kvm_context
, start
, size
);
1248 if (must_use_aliases_target(start
))
1251 kvm_dirty_pages_log_disable_slot(kvm_context
, start
, size
);
1255 int kvm_get_phys_ram_page_bitmap(unsigned char *bitmap
)
1257 unsigned int bsize
= BITMAP_SIZE(phys_ram_size
);
1258 unsigned int brsize
= BITMAP_SIZE(ram_size
);
1259 unsigned int extra_pages
= (phys_ram_size
- ram_size
) / TARGET_PAGE_SIZE
;
1260 unsigned int extra_bytes
= (extra_pages
+7)/8;
1261 unsigned int hole_start
= BITMAP_SIZE(0xa0000);
1262 unsigned int hole_end
= BITMAP_SIZE(0xc0000);
1264 memset(bitmap
, 0xFF, brsize
+ extra_bytes
);
1265 memset(bitmap
+ hole_start
, 0, hole_end
- hole_start
);
1266 memset(bitmap
+ brsize
+ extra_bytes
, 0, bsize
- brsize
- extra_bytes
);
1271 #ifdef KVM_CAP_IRQCHIP
1273 int kvm_set_irq(int irq
, int level
)
1275 return kvm_set_irq_level(kvm_context
, irq
, level
);
1280 int qemu_kvm_get_dirty_pages(unsigned long phys_addr
, void *buf
)
1282 return kvm_get_dirty_pages(kvm_context
, phys_addr
, buf
);
1285 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr
,
1286 unsigned long size
, int log
, int writable
)
1288 return kvm_create_phys_mem(kvm_context
, start_addr
, size
, log
, writable
);
1291 void kvm_cpu_destroy_phys_mem(target_phys_addr_t start_addr
,
1294 kvm_destroy_phys_mem(kvm_context
, start_addr
, size
);
1297 void kvm_mutex_unlock(void)
1299 assert(!cpu_single_env
);
1300 pthread_mutex_unlock(&qemu_mutex
);
1303 void kvm_mutex_lock(void)
1305 pthread_mutex_lock(&qemu_mutex
);
1306 cpu_single_env
= NULL
;
1309 int qemu_kvm_register_coalesced_mmio(target_phys_addr_t addr
, unsigned int size
)
1311 return kvm_register_coalesced_mmio(kvm_context
, addr
, size
);
1314 int qemu_kvm_unregister_coalesced_mmio(target_phys_addr_t addr
,
1317 return kvm_unregister_coalesced_mmio(kvm_context
, addr
, size
);
1320 int kvm_coalesce_mmio_region(target_phys_addr_t start
, ram_addr_t size
)
1322 return kvm_register_coalesced_mmio(kvm_context
, start
, size
);
1325 int kvm_uncoalesce_mmio_region(target_phys_addr_t start
, ram_addr_t size
)
1327 return kvm_unregister_coalesced_mmio(kvm_context
, start
, size
);
1330 #ifdef USE_KVM_DEVICE_ASSIGNMENT
1331 void kvm_add_ioperm_data(struct ioperm_data
*data
)
1333 LIST_INSERT_HEAD(&ioperm_head
, data
, entries
);
1336 void kvm_ioperm(CPUState
*env
, void *data
)
1338 if (kvm_enabled() && qemu_system_ready
)
1339 on_vcpu(env
, kvm_arch_do_ioperm
, data
);
1344 void kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr
, target_phys_addr_t end_addr
)
1350 if (must_use_aliases_source(start_addr
))
1354 buf
= qemu_malloc((end_addr
- start_addr
) / 8 + 2);
1355 kvm_get_dirty_pages_range(kvm_context
, start_addr
, end_addr
- start_addr
,
1356 buf
, NULL
, kvm_get_dirty_bitmap_cb
);
1361 int kvm_log_start(target_phys_addr_t phys_addr
, target_phys_addr_t len
)
1364 if (must_use_aliases_source(phys_addr
))
1367 kvm_qemu_log_memory(phys_addr
, len
, 1);
1371 int kvm_log_stop(target_phys_addr_t phys_addr
, target_phys_addr_t len
)
1374 if (must_use_aliases_source(phys_addr
))
1377 kvm_qemu_log_memory(phys_addr
, len
, 0);
1381 /* hack: both libkvm and upstream qemu define kvm_has_sync_mmu(), differently */
1382 #undef kvm_has_sync_mmu
1383 int qemu_kvm_has_sync_mmu(void)
1385 return kvm_has_sync_mmu(kvm_context
);
1388 void qemu_kvm_cpu_stop(CPUState
*env
)
1391 env
->kvm_cpu_state
.stopped
= 1;