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
, (long)data
);
108 void kvm_inject_interrupt(CPUState
*env
, int mask
)
110 on_vcpu(env
, inject_interrupt
, (void *)(long)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
, int reason
)
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 static int kvm_debug(void *opaque
, void *data
,
620 struct kvm_debug_exit_arch
*arch_info
)
622 int handle
= kvm_arch_debug(arch_info
);
623 struct CPUState
*env
= data
;
626 kvm_debug_cpu_requested
= env
;
627 env
->kvm_cpu_state
.stopped
= 1;
633 static int kvm_inb(void *opaque
, uint16_t addr
, uint8_t *data
)
635 *data
= cpu_inb(0, addr
);
639 static int kvm_inw(void *opaque
, uint16_t addr
, uint16_t *data
)
641 *data
= cpu_inw(0, addr
);
645 static int kvm_inl(void *opaque
, uint16_t addr
, uint32_t *data
)
647 *data
= cpu_inl(0, addr
);
651 #define PM_IO_BASE 0xb000
653 static int kvm_outb(void *opaque
, uint16_t addr
, uint8_t data
)
658 cpu_outb(0, 0xb3, 0);
665 x
= cpu_inw(0, PM_IO_BASE
+ 4);
667 cpu_outw(0, PM_IO_BASE
+ 4, x
);
674 x
= cpu_inw(0, PM_IO_BASE
+ 4);
676 cpu_outw(0, PM_IO_BASE
+ 4, x
);
684 cpu_outb(0, addr
, data
);
688 static int kvm_outw(void *opaque
, uint16_t addr
, uint16_t data
)
690 cpu_outw(0, addr
, data
);
694 static int kvm_outl(void *opaque
, uint16_t addr
, uint32_t data
)
696 cpu_outl(0, addr
, data
);
700 static int kvm_mmio_read(void *opaque
, uint64_t addr
, uint8_t *data
, int len
)
702 cpu_physical_memory_rw(addr
, data
, len
, 0);
706 static int kvm_mmio_write(void *opaque
, uint64_t addr
, uint8_t *data
, int len
)
708 cpu_physical_memory_rw(addr
, data
, len
, 1);
712 static int kvm_io_window(void *opaque
)
718 static int kvm_halt(void *opaque
, int vcpu
)
720 return kvm_arch_halt(opaque
, vcpu
);
723 static int kvm_shutdown(void *opaque
, void *data
)
725 struct CPUState
*env
= (struct CPUState
*)data
;
727 /* stop the current vcpu from going back to guest mode */
728 env
->kvm_cpu_state
.stopped
= 1;
730 qemu_system_reset_request();
734 static struct kvm_callbacks qemu_kvm_ops
= {
735 #ifdef KVM_CAP_SET_GUEST_DEBUG
744 .mmio_read
= kvm_mmio_read
,
745 .mmio_write
= kvm_mmio_write
,
747 .shutdown
= kvm_shutdown
,
748 .io_window
= kvm_io_window
,
749 .try_push_interrupts
= try_push_interrupts
,
750 #ifdef KVM_CAP_USER_NMI
751 .push_nmi
= kvm_arch_push_nmi
,
753 .post_kvm_run
= post_kvm_run
,
754 .pre_kvm_run
= pre_kvm_run
,
756 .tpr_access
= handle_tpr_access
,
759 .powerpc_dcr_read
= handle_powerpc_dcr_read
,
760 .powerpc_dcr_write
= handle_powerpc_dcr_write
,
766 /* Try to initialize kvm */
767 kvm_context
= kvm_init(&qemu_kvm_ops
, cpu_single_env
);
771 pthread_mutex_lock(&qemu_mutex
);
777 static int destroy_region_works
= 0;
780 int kvm_qemu_create_context(void)
786 kvm_disable_irqchip_creation(kvm_context
);
789 kvm_disable_pit_creation(kvm_context
);
791 if (kvm_create(kvm_context
, phys_ram_size
, (void**)&phys_ram_base
) < 0) {
795 r
= kvm_arch_qemu_create_context();
798 if (kvm_pit
&& !kvm_pit_reinject
) {
799 if (kvm_reinject_control(kvm_context
, 0)) {
800 fprintf(stderr
, "failure to disable in-kernel PIT reinjection\n");
805 destroy_region_works
= kvm_destroy_memory_region_works(kvm_context
);
808 if (kvm_irqchip
&& kvm_has_gsi_routing(kvm_context
)) {
809 kvm_clear_gsi_routes(kvm_context
);
810 for (i
= 0; i
< 8; ++i
) {
813 r
= kvm_add_irq_route(kvm_context
, i
, KVM_IRQCHIP_PIC_MASTER
, i
);
817 for (i
= 8; i
< 16; ++i
) {
818 r
= kvm_add_irq_route(kvm_context
, i
, KVM_IRQCHIP_PIC_SLAVE
, i
- 8);
822 for (i
= 0; i
< 24; ++i
) {
823 r
= kvm_add_irq_route(kvm_context
, i
, KVM_IRQCHIP_IOAPIC
, i
);
827 kvm_commit_irq_routes(kvm_context
);
832 void kvm_qemu_destroy(void)
834 kvm_finalize(kvm_context
);
838 static int must_use_aliases_source(target_phys_addr_t addr
)
840 if (destroy_region_works
)
842 if (addr
== 0xa0000 || addr
== 0xa8000)
847 static int must_use_aliases_target(target_phys_addr_t addr
)
849 if (destroy_region_works
)
851 if (addr
>= 0xe0000000 && addr
< 0x100000000ull
)
856 static struct mapping
{
857 target_phys_addr_t phys
;
861 static int nr_mappings
;
863 static struct mapping
*find_ram_mapping(ram_addr_t ram_addr
)
867 for (p
= mappings
; p
< mappings
+ nr_mappings
; ++p
) {
868 if (p
->ram
<= ram_addr
&& ram_addr
< p
->ram
+ p
->len
) {
875 static struct mapping
*find_mapping(target_phys_addr_t start_addr
)
879 for (p
= mappings
; p
< mappings
+ nr_mappings
; ++p
) {
880 if (p
->phys
<= start_addr
&& start_addr
< p
->phys
+ p
->len
) {
887 static void drop_mapping(target_phys_addr_t start_addr
)
889 struct mapping
*p
= find_mapping(start_addr
);
892 *p
= mappings
[--nr_mappings
];
896 void kvm_cpu_register_physical_memory(target_phys_addr_t start_addr
,
898 unsigned long phys_offset
)
901 unsigned long area_flags
= phys_offset
& ~TARGET_PAGE_MASK
;
906 phys_offset
&= ~IO_MEM_ROM
;
908 if (area_flags
== IO_MEM_UNASSIGNED
) {
910 if (must_use_aliases_source(start_addr
)) {
911 kvm_destroy_memory_alias(kvm_context
, start_addr
);
914 if (must_use_aliases_target(start_addr
))
917 kvm_unregister_memory_area(kvm_context
, start_addr
, size
);
921 r
= kvm_is_containing_region(kvm_context
, start_addr
, size
);
925 if (area_flags
>= TLB_MMIO
)
929 if (must_use_aliases_source(start_addr
)) {
930 p
= find_ram_mapping(phys_offset
);
932 kvm_create_memory_alias(kvm_context
, start_addr
, size
,
933 p
->phys
+ (phys_offset
- p
->ram
));
939 r
= kvm_register_phys_mem(kvm_context
, start_addr
,
940 phys_ram_base
+ phys_offset
,
943 printf("kvm_cpu_register_physical_memory: failed\n");
948 drop_mapping(start_addr
);
949 p
= &mappings
[nr_mappings
++];
950 p
->phys
= start_addr
;
951 p
->ram
= phys_offset
;
958 void kvm_cpu_unregister_physical_memory(target_phys_addr_t start_addr
,
959 target_phys_addr_t size
,
960 unsigned long phys_offset
)
962 kvm_unregister_memory_area(kvm_context
, start_addr
, size
);
965 int kvm_setup_guest_memory(void *area
, unsigned long size
)
970 if (kvm_enabled() && !kvm_has_sync_mmu())
971 ret
= madvise(area
, size
, MADV_DONTFORK
);
980 int kvm_qemu_check_extension(int ext
)
982 return kvm_check_extension(kvm_context
, ext
);
985 int kvm_qemu_init_env(CPUState
*cenv
)
987 return kvm_arch_qemu_init_env(cenv
);
990 #ifdef KVM_CAP_SET_GUEST_DEBUG
991 struct kvm_sw_breakpoint_head kvm_sw_breakpoints
=
992 TAILQ_HEAD_INITIALIZER(kvm_sw_breakpoints
);
994 struct kvm_sw_breakpoint
*kvm_find_sw_breakpoint(target_ulong pc
)
996 struct kvm_sw_breakpoint
*bp
;
998 TAILQ_FOREACH(bp
, &kvm_sw_breakpoints
, entry
) {
1005 struct kvm_set_guest_debug_data
{
1006 struct kvm_guest_debug dbg
;
1010 static void kvm_invoke_set_guest_debug(void *data
)
1012 struct kvm_set_guest_debug_data
*dbg_data
= data
;
1014 dbg_data
->err
= kvm_set_guest_debug(kvm_context
, cpu_single_env
->cpu_index
,
1018 int kvm_update_guest_debug(CPUState
*env
, unsigned long reinject_trap
)
1020 struct kvm_set_guest_debug_data data
;
1022 data
.dbg
.control
= 0;
1023 if (env
->singlestep_enabled
)
1024 data
.dbg
.control
= KVM_GUESTDBG_ENABLE
| KVM_GUESTDBG_SINGLESTEP
;
1026 kvm_arch_update_guest_debug(env
, &data
.dbg
);
1027 data
.dbg
.control
|= reinject_trap
;
1029 on_vcpu(env
, kvm_invoke_set_guest_debug
, &data
);
1033 int kvm_insert_breakpoint(CPUState
*current_env
, target_ulong addr
,
1034 target_ulong len
, int type
)
1036 struct kvm_sw_breakpoint
*bp
;
1040 if (type
== GDB_BREAKPOINT_SW
) {
1041 bp
= kvm_find_sw_breakpoint(addr
);
1047 bp
= qemu_malloc(sizeof(struct kvm_sw_breakpoint
));
1053 err
= kvm_arch_insert_sw_breakpoint(current_env
, bp
);
1059 TAILQ_INSERT_HEAD(&kvm_sw_breakpoints
, bp
, entry
);
1061 err
= kvm_arch_insert_hw_breakpoint(addr
, len
, type
);
1066 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1067 err
= kvm_update_guest_debug(env
, 0);
1074 int kvm_remove_breakpoint(CPUState
*current_env
, target_ulong addr
,
1075 target_ulong len
, int type
)
1077 struct kvm_sw_breakpoint
*bp
;
1081 if (type
== GDB_BREAKPOINT_SW
) {
1082 bp
= kvm_find_sw_breakpoint(addr
);
1086 if (bp
->use_count
> 1) {
1091 err
= kvm_arch_remove_sw_breakpoint(current_env
, bp
);
1095 TAILQ_REMOVE(&kvm_sw_breakpoints
, bp
, entry
);
1098 err
= kvm_arch_remove_hw_breakpoint(addr
, len
, type
);
1103 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1104 err
= kvm_update_guest_debug(env
, 0);
1111 void kvm_remove_all_breakpoints(CPUState
*current_env
)
1113 struct kvm_sw_breakpoint
*bp
, *next
;
1116 TAILQ_FOREACH_SAFE(bp
, &kvm_sw_breakpoints
, entry
, next
) {
1117 if (kvm_arch_remove_sw_breakpoint(current_env
, bp
) != 0) {
1118 /* Try harder to find a CPU that currently sees the breakpoint. */
1119 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
1120 if (kvm_arch_remove_sw_breakpoint(env
, bp
) == 0)
1125 kvm_arch_remove_all_hw_breakpoints();
1127 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
1128 kvm_update_guest_debug(env
, 0);
1131 #else /* !KVM_CAP_SET_GUEST_DEBUG */
1133 int kvm_update_guest_debug(CPUState
*env
, unsigned long reinject_trap
)
1138 int kvm_insert_breakpoint(CPUState
*current_env
, target_ulong addr
,
1139 target_ulong len
, int type
)
1144 int kvm_remove_breakpoint(CPUState
*current_env
, target_ulong addr
,
1145 target_ulong len
, int type
)
1150 void kvm_remove_all_breakpoints(CPUState
*current_env
)
1153 #endif /* !KVM_CAP_SET_GUEST_DEBUG */
1156 * dirty pages logging
1158 /* FIXME: use unsigned long pointer instead of unsigned char */
1159 unsigned char *kvm_dirty_bitmap
= NULL
;
1160 int kvm_physical_memory_set_dirty_tracking(int enable
)
1168 if (!kvm_dirty_bitmap
) {
1169 unsigned bitmap_size
= BITMAP_SIZE(phys_ram_size
);
1170 kvm_dirty_bitmap
= qemu_malloc(bitmap_size
);
1171 if (kvm_dirty_bitmap
== NULL
) {
1172 perror("Failed to allocate dirty pages bitmap");
1176 r
= kvm_dirty_pages_log_enable_all(kvm_context
);
1181 if (kvm_dirty_bitmap
) {
1182 r
= kvm_dirty_pages_log_reset(kvm_context
);
1183 qemu_free(kvm_dirty_bitmap
);
1184 kvm_dirty_bitmap
= NULL
;
1190 /* get kvm's dirty pages bitmap and update qemu's */
1191 static int kvm_get_dirty_pages_log_range(unsigned long start_addr
,
1192 unsigned char *bitmap
,
1193 unsigned int offset
,
1194 unsigned long mem_size
)
1196 unsigned int i
, j
, n
=0;
1198 unsigned long page_number
, addr
, addr1
;
1199 ram_addr_t ram_addr
;
1200 unsigned int len
= ((mem_size
/TARGET_PAGE_SIZE
) + 7) / 8;
1203 * bitmap-traveling is faster than memory-traveling (for addr...)
1204 * especially when most of the memory is not dirty.
1206 for (i
=0; i
<len
; i
++) {
1211 page_number
= i
* 8 + j
;
1212 addr1
= page_number
* TARGET_PAGE_SIZE
;
1213 addr
= offset
+ addr1
;
1214 ram_addr
= cpu_get_physical_page_desc(addr
);
1215 cpu_physical_memory_set_dirty(ram_addr
);
1221 static int kvm_get_dirty_bitmap_cb(unsigned long start
, unsigned long len
,
1222 void *bitmap
, void *opaque
)
1224 return kvm_get_dirty_pages_log_range(start
, bitmap
, start
, len
);
1228 * get kvm's dirty pages bitmap and update qemu's
1229 * we only care about physical ram, which resides in slots 0 and 3
1231 int kvm_update_dirty_pages_log(void)
1236 r
= kvm_get_dirty_pages_range(kvm_context
, 0, -1ULL,
1237 kvm_dirty_bitmap
, NULL
,
1238 kvm_get_dirty_bitmap_cb
);
1242 void kvm_qemu_log_memory(target_phys_addr_t start
, target_phys_addr_t size
,
1246 kvm_dirty_pages_log_enable_slot(kvm_context
, start
, size
);
1249 if (must_use_aliases_target(start
))
1252 kvm_dirty_pages_log_disable_slot(kvm_context
, start
, size
);
1256 int kvm_get_phys_ram_page_bitmap(unsigned char *bitmap
)
1258 unsigned int bsize
= BITMAP_SIZE(phys_ram_size
);
1259 unsigned int brsize
= BITMAP_SIZE(ram_size
);
1260 unsigned int extra_pages
= (phys_ram_size
- ram_size
) / TARGET_PAGE_SIZE
;
1261 unsigned int extra_bytes
= (extra_pages
+7)/8;
1262 unsigned int hole_start
= BITMAP_SIZE(0xa0000);
1263 unsigned int hole_end
= BITMAP_SIZE(0xc0000);
1265 memset(bitmap
, 0xFF, brsize
+ extra_bytes
);
1266 memset(bitmap
+ hole_start
, 0, hole_end
- hole_start
);
1267 memset(bitmap
+ brsize
+ extra_bytes
, 0, bsize
- brsize
- extra_bytes
);
1272 #ifdef KVM_CAP_IRQCHIP
1274 int kvm_set_irq(int irq
, int level
, int *status
)
1276 return kvm_set_irq_level(kvm_context
, irq
, level
, status
);
1281 int qemu_kvm_get_dirty_pages(unsigned long phys_addr
, void *buf
)
1283 return kvm_get_dirty_pages(kvm_context
, phys_addr
, buf
);
1286 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr
,
1287 unsigned long size
, int log
, int writable
)
1289 return kvm_create_phys_mem(kvm_context
, start_addr
, size
, log
, writable
);
1292 void kvm_cpu_destroy_phys_mem(target_phys_addr_t start_addr
,
1295 kvm_destroy_phys_mem(kvm_context
, start_addr
, size
);
1298 void kvm_mutex_unlock(void)
1300 assert(!cpu_single_env
);
1301 pthread_mutex_unlock(&qemu_mutex
);
1304 void kvm_mutex_lock(void)
1306 pthread_mutex_lock(&qemu_mutex
);
1307 cpu_single_env
= NULL
;
1310 int qemu_kvm_register_coalesced_mmio(target_phys_addr_t addr
, unsigned int size
)
1312 return kvm_register_coalesced_mmio(kvm_context
, addr
, size
);
1315 int qemu_kvm_unregister_coalesced_mmio(target_phys_addr_t addr
,
1318 return kvm_unregister_coalesced_mmio(kvm_context
, addr
, size
);
1321 int kvm_coalesce_mmio_region(target_phys_addr_t start
, ram_addr_t size
)
1323 return kvm_register_coalesced_mmio(kvm_context
, start
, size
);
1326 int kvm_uncoalesce_mmio_region(target_phys_addr_t start
, ram_addr_t size
)
1328 return kvm_unregister_coalesced_mmio(kvm_context
, start
, size
);
1331 #ifdef USE_KVM_DEVICE_ASSIGNMENT
1332 void kvm_add_ioperm_data(struct ioperm_data
*data
)
1334 LIST_INSERT_HEAD(&ioperm_head
, data
, entries
);
1337 void kvm_remove_ioperm_data(unsigned long start_port
, unsigned long num
)
1339 struct ioperm_data
*data
;
1341 data
= LIST_FIRST(&ioperm_head
);
1343 struct ioperm_data
*next
= LIST_NEXT(data
, entries
);
1345 if (data
->start_port
== start_port
&& data
->num
== num
) {
1346 LIST_REMOVE(data
, entries
);
1354 void kvm_ioperm(CPUState
*env
, void *data
)
1356 if (kvm_enabled() && qemu_system_ready
)
1357 on_vcpu(env
, kvm_arch_do_ioperm
, data
);
1362 void kvm_physical_sync_dirty_bitmap(target_phys_addr_t start_addr
, target_phys_addr_t end_addr
)
1368 if (must_use_aliases_source(start_addr
))
1372 buf
= qemu_malloc((end_addr
- start_addr
) / 8 + 2);
1373 kvm_get_dirty_pages_range(kvm_context
, start_addr
, end_addr
- start_addr
,
1374 buf
, NULL
, kvm_get_dirty_bitmap_cb
);
1379 int kvm_log_start(target_phys_addr_t phys_addr
, target_phys_addr_t len
)
1382 if (must_use_aliases_source(phys_addr
))
1385 kvm_qemu_log_memory(phys_addr
, len
, 1);
1389 int kvm_log_stop(target_phys_addr_t phys_addr
, target_phys_addr_t len
)
1392 if (must_use_aliases_source(phys_addr
))
1395 kvm_qemu_log_memory(phys_addr
, len
, 0);
1399 /* hack: both libkvm and upstream qemu define kvm_has_sync_mmu(), differently */
1400 #undef kvm_has_sync_mmu
1401 int qemu_kvm_has_sync_mmu(void)
1403 return kvm_has_sync_mmu(kvm_context
);
1406 void qemu_kvm_cpu_stop(CPUState
*env
)
1409 env
->kvm_cpu_state
.stopped
= 1;