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"
19 #include "qemu-common.h"
27 #include <sys/utsname.h>
28 #include <sys/syscall.h>
34 extern void perror(const char *s
);
36 kvm_context_t kvm_context
;
40 pthread_mutex_t qemu_mutex
= PTHREAD_MUTEX_INITIALIZER
;
41 pthread_cond_t qemu_vcpu_cond
= PTHREAD_COND_INITIALIZER
;
42 pthread_cond_t qemu_system_cond
= PTHREAD_COND_INITIALIZER
;
43 pthread_cond_t qemu_pause_cond
= PTHREAD_COND_INITIALIZER
;
44 pthread_cond_t qemu_work_cond
= PTHREAD_COND_INITIALIZER
;
45 __thread
struct CPUState
*current_env
;
47 static int qemu_system_ready
;
49 #define SIG_IPI (SIGRTMIN+4)
52 static int io_thread_fd
= -1;
53 static int io_thread_sigfd
= -1;
55 static int kvm_debug_stop_requested
;
57 /* The list of ioperm_data */
58 static LIST_HEAD(, ioperm_data
) ioperm_head
;
60 static inline unsigned long kvm_get_thread_id(void)
62 return syscall(SYS_gettid
);
65 static void qemu_cond_wait(pthread_cond_t
*cond
)
67 CPUState
*env
= cpu_single_env
;
68 static const struct timespec ts
= {
73 pthread_cond_timedwait(cond
, &qemu_mutex
, &ts
);
77 static void sig_ipi_handler(int n
)
81 static void on_vcpu(CPUState
*env
, void (*func
)(void *data
), void *data
)
83 struct qemu_work_item wi
;
85 if (env
== current_env
) {
92 if (!env
->kvm_cpu_state
.queued_work_first
)
93 env
->kvm_cpu_state
.queued_work_first
= &wi
;
95 env
->kvm_cpu_state
.queued_work_last
->next
= &wi
;
96 env
->kvm_cpu_state
.queued_work_last
= &wi
;
100 pthread_kill(env
->kvm_cpu_state
.thread
, SIG_IPI
);
102 qemu_cond_wait(&qemu_work_cond
);
105 static void inject_interrupt(void *data
)
107 cpu_interrupt(current_env
, (int)data
);
110 void kvm_inject_interrupt(CPUState
*env
, int mask
)
112 on_vcpu(env
, inject_interrupt
, (void *)mask
);
115 void kvm_update_interrupt_request(CPUState
*env
)
120 if (current_env
&& !current_env
->kvm_cpu_state
.created
)
123 * Testing for created here is really redundant
125 if (current_env
&& current_env
->kvm_cpu_state
.created
&&
126 env
!= current_env
&& !env
->kvm_cpu_state
.signalled
)
130 env
->kvm_cpu_state
.signalled
= 1;
131 if (env
->kvm_cpu_state
.thread
)
132 pthread_kill(env
->kvm_cpu_state
.thread
, SIG_IPI
);
137 void kvm_update_after_sipi(CPUState
*env
)
139 env
->kvm_cpu_state
.sipi_needed
= 1;
140 kvm_update_interrupt_request(env
);
143 void kvm_apic_init(CPUState
*env
)
145 if (env
->cpu_index
!= 0)
146 env
->kvm_cpu_state
.init
= 1;
147 kvm_update_interrupt_request(env
);
152 static int try_push_interrupts(void *opaque
)
154 return kvm_arch_try_push_interrupts(opaque
);
158 static void push_nmi(void *opaque
)
160 kvm_arch_push_nmi(opaque
);
164 static void post_kvm_run(void *opaque
, void *data
)
166 CPUState
*env
= (CPUState
*)data
;
168 pthread_mutex_lock(&qemu_mutex
);
169 kvm_arch_post_kvm_run(opaque
, env
);
172 static int pre_kvm_run(void *opaque
, void *data
)
174 CPUState
*env
= (CPUState
*)data
;
176 kvm_arch_pre_kvm_run(opaque
, env
);
178 if (env
->interrupt_request
& CPU_INTERRUPT_EXIT
)
180 pthread_mutex_unlock(&qemu_mutex
);
184 static void kvm_do_load_registers(void *_env
)
186 CPUState
*env
= _env
;
188 kvm_arch_load_regs(env
);
191 void kvm_load_registers(CPUState
*env
)
193 if (kvm_enabled() && qemu_system_ready
)
194 on_vcpu(env
, kvm_do_load_registers
, env
);
197 static void kvm_do_save_registers(void *_env
)
199 CPUState
*env
= _env
;
201 kvm_arch_save_regs(env
);
204 void kvm_save_registers(CPUState
*env
)
207 on_vcpu(env
, kvm_do_save_registers
, env
);
210 int kvm_cpu_exec(CPUState
*env
)
214 r
= kvm_run(kvm_context
, env
->cpu_index
, env
);
216 printf("kvm_run returned %d\n", r
);
223 extern int vm_running
;
225 static int has_work(CPUState
*env
)
227 if (!vm_running
|| (env
&& env
->kvm_cpu_state
.stopped
))
231 return kvm_arch_has_work(env
);
234 static void flush_queued_work(CPUState
*env
)
236 struct qemu_work_item
*wi
;
238 if (!env
->kvm_cpu_state
.queued_work_first
)
241 while ((wi
= env
->kvm_cpu_state
.queued_work_first
)) {
242 env
->kvm_cpu_state
.queued_work_first
= wi
->next
;
246 env
->kvm_cpu_state
.queued_work_last
= NULL
;
247 pthread_cond_broadcast(&qemu_work_cond
);
250 static void kvm_main_loop_wait(CPUState
*env
, int timeout
)
257 pthread_mutex_unlock(&qemu_mutex
);
259 ts
.tv_sec
= timeout
/ 1000;
260 ts
.tv_nsec
= (timeout
% 1000) * 1000000;
261 sigemptyset(&waitset
);
262 sigaddset(&waitset
, SIG_IPI
);
264 r
= sigtimedwait(&waitset
, &siginfo
, &ts
);
267 pthread_mutex_lock(&qemu_mutex
);
269 if (r
== -1 && !(e
== EAGAIN
|| e
== EINTR
)) {
270 printf("sigtimedwait: %s\n", strerror(e
));
274 cpu_single_env
= env
;
275 flush_queued_work(env
);
277 if (env
->kvm_cpu_state
.stop
) {
278 env
->kvm_cpu_state
.stop
= 0;
279 env
->kvm_cpu_state
.stopped
= 1;
280 pthread_cond_signal(&qemu_pause_cond
);
283 env
->kvm_cpu_state
.signalled
= 0;
286 static int all_threads_paused(void)
288 CPUState
*penv
= first_cpu
;
291 if (penv
->kvm_cpu_state
.stop
)
293 penv
= (CPUState
*)penv
->next_cpu
;
299 static void pause_all_threads(void)
301 CPUState
*penv
= first_cpu
;
303 assert(!cpu_single_env
);
306 penv
->kvm_cpu_state
.stop
= 1;
307 pthread_kill(penv
->kvm_cpu_state
.thread
, SIG_IPI
);
308 penv
= (CPUState
*)penv
->next_cpu
;
311 while (!all_threads_paused())
312 qemu_cond_wait(&qemu_pause_cond
);
315 static void resume_all_threads(void)
317 CPUState
*penv
= first_cpu
;
319 assert(!cpu_single_env
);
322 penv
->kvm_cpu_state
.stop
= 0;
323 penv
->kvm_cpu_state
.stopped
= 0;
324 pthread_kill(penv
->kvm_cpu_state
.thread
, SIG_IPI
);
325 penv
= (CPUState
*)penv
->next_cpu
;
329 static void kvm_vm_state_change_handler(void *context
, int running
)
332 resume_all_threads();
337 static void update_regs_for_sipi(CPUState
*env
)
339 kvm_arch_update_regs_for_sipi(env
);
340 env
->kvm_cpu_state
.sipi_needed
= 0;
343 static void update_regs_for_init(CPUState
*env
)
346 SegmentCache cs
= env
->segs
[R_CS
];
352 /* restore SIPI vector */
353 if(env
->kvm_cpu_state
.sipi_needed
)
354 env
->segs
[R_CS
] = cs
;
357 env
->kvm_cpu_state
.init
= 0;
358 kvm_arch_load_regs(env
);
361 static void setup_kernel_sigmask(CPUState
*env
)
366 sigaddset(&set
, SIGUSR2
);
367 sigaddset(&set
, SIGIO
);
368 sigaddset(&set
, SIGALRM
);
369 sigprocmask(SIG_BLOCK
, &set
, NULL
);
371 sigprocmask(SIG_BLOCK
, NULL
, &set
);
372 sigdelset(&set
, SIG_IPI
);
374 kvm_set_signal_mask(kvm_context
, env
->cpu_index
, &set
);
377 void qemu_kvm_system_reset(void)
379 CPUState
*penv
= first_cpu
;
386 kvm_arch_cpu_reset(penv
);
387 penv
= (CPUState
*)penv
->next_cpu
;
390 resume_all_threads();
393 static int kvm_main_loop_cpu(CPUState
*env
)
395 setup_kernel_sigmask(env
);
397 pthread_mutex_lock(&qemu_mutex
);
398 if (kvm_irqchip_in_kernel(kvm_context
))
401 kvm_qemu_init_env(env
);
403 kvm_tpr_vcpu_start(env
);
406 cpu_single_env
= env
;
407 kvm_load_registers(env
);
410 while (!has_work(env
))
411 kvm_main_loop_wait(env
, 1000);
412 if (env
->interrupt_request
& (CPU_INTERRUPT_HARD
| CPU_INTERRUPT_NMI
))
414 if (!kvm_irqchip_in_kernel(kvm_context
)) {
415 if (env
->kvm_cpu_state
.init
)
416 update_regs_for_init(env
);
417 if (env
->kvm_cpu_state
.sipi_needed
)
418 update_regs_for_sipi(env
);
420 if (!env
->halted
&& !env
->kvm_cpu_state
.init
)
422 env
->interrupt_request
&= ~CPU_INTERRUPT_EXIT
;
423 kvm_main_loop_wait(env
, 0);
425 pthread_mutex_unlock(&qemu_mutex
);
429 static void *ap_main_loop(void *_env
)
431 CPUState
*env
= _env
;
433 struct ioperm_data
*data
= NULL
;
436 env
->thread_id
= kvm_get_thread_id();
437 sigfillset(&signals
);
438 sigprocmask(SIG_BLOCK
, &signals
, NULL
);
439 kvm_create_vcpu(kvm_context
, env
->cpu_index
);
440 kvm_qemu_init_env(env
);
442 #ifdef USE_KVM_DEVICE_ASSIGNMENT
443 /* do ioperm for io ports of assigned devices */
444 LIST_FOREACH(data
, &ioperm_head
, entries
)
445 on_vcpu(env
, kvm_arch_do_ioperm
, data
);
448 /* signal VCPU creation */
449 pthread_mutex_lock(&qemu_mutex
);
450 current_env
->kvm_cpu_state
.created
= 1;
451 pthread_cond_signal(&qemu_vcpu_cond
);
453 /* and wait for machine initialization */
454 while (!qemu_system_ready
)
455 qemu_cond_wait(&qemu_system_cond
);
456 pthread_mutex_unlock(&qemu_mutex
);
458 kvm_main_loop_cpu(env
);
462 void kvm_init_vcpu(CPUState
*env
)
464 int cpu
= env
->cpu_index
;
465 pthread_create(&env
->kvm_cpu_state
.thread
, NULL
, ap_main_loop
, env
);
467 while (env
->kvm_cpu_state
.created
== 0)
468 qemu_cond_wait(&qemu_vcpu_cond
);
471 int kvm_init_ap(void)
476 qemu_add_vm_change_state_handler(kvm_vm_state_change_handler
, NULL
);
478 signal(SIG_IPI
, sig_ipi_handler
);
482 void qemu_kvm_notify_work(void)
488 if (io_thread_fd
== -1)
491 memcpy(buffer
, &value
, sizeof(value
));
496 len
= write(io_thread_fd
, buffer
+ offset
, 8 - offset
);
497 if (len
== -1 && errno
== EINTR
)
507 fprintf(stderr
, "failed to notify io thread\n");
510 /* If we have signalfd, we mask out the signals we want to handle and then
511 * use signalfd to listen for them. We rely on whatever the current signal
512 * handler is to dispatch the signals when we receive them.
515 static void sigfd_handler(void *opaque
)
517 int fd
= (unsigned long)opaque
;
518 struct qemu_signalfd_siginfo info
;
519 struct sigaction action
;
524 len
= read(fd
, &info
, sizeof(info
));
525 } while (len
== -1 && errno
== EINTR
);
527 if (len
== -1 && errno
== EAGAIN
)
530 if (len
!= sizeof(info
)) {
531 printf("read from sigfd returned %ld: %m\n", len
);
535 sigaction(info
.ssi_signo
, NULL
, &action
);
536 if (action
.sa_handler
)
537 action
.sa_handler(info
.ssi_signo
);
542 /* Used to break IO thread out of select */
543 static void io_thread_wakeup(void *opaque
)
545 int fd
= (unsigned long)opaque
;
552 len
= read(fd
, buffer
+ offset
, 8 - offset
);
553 if (len
== -1 && errno
== EINTR
)
563 int kvm_main_loop(void)
569 io_thread
= pthread_self();
570 qemu_system_ready
= 1;
572 if (qemu_eventfd(fds
) == -1) {
573 fprintf(stderr
, "failed to create eventfd\n");
577 qemu_set_fd_handler2(fds
[0], NULL
, io_thread_wakeup
, NULL
,
578 (void *)(unsigned long)fds
[0]);
580 io_thread_fd
= fds
[1];
583 sigaddset(&mask
, SIGIO
);
584 sigaddset(&mask
, SIGALRM
);
585 sigprocmask(SIG_BLOCK
, &mask
, NULL
);
587 sigfd
= qemu_signalfd(&mask
);
589 fprintf(stderr
, "failed to create signalfd\n");
593 fcntl(sigfd
, F_SETFL
, O_NONBLOCK
);
595 qemu_set_fd_handler2(sigfd
, NULL
, sigfd_handler
, NULL
,
596 (void *)(unsigned long)sigfd
);
598 pthread_cond_broadcast(&qemu_system_cond
);
600 io_thread_sigfd
= sigfd
;
601 cpu_single_env
= NULL
;
604 main_loop_wait(1000);
605 if (qemu_shutdown_requested())
607 else if (qemu_powerdown_requested())
608 qemu_system_powerdown();
609 else if (qemu_reset_requested())
610 qemu_kvm_system_reset();
611 else if (kvm_debug_stop_requested
) {
613 kvm_debug_stop_requested
= 0;
618 pthread_mutex_unlock(&qemu_mutex
);
623 static int kvm_debug(void *opaque
, void *data
)
625 struct CPUState
*env
= (struct CPUState
*)data
;
627 kvm_debug_stop_requested
= 1;
628 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
= {
741 .mmio_read
= kvm_mmio_read
,
742 .mmio_write
= kvm_mmio_write
,
744 .shutdown
= kvm_shutdown
,
745 .io_window
= kvm_io_window
,
746 .try_push_interrupts
= try_push_interrupts
,
748 .push_nmi
= push_nmi
,
750 .post_kvm_run
= post_kvm_run
,
751 .pre_kvm_run
= pre_kvm_run
,
753 .tpr_access
= handle_tpr_access
,
756 .powerpc_dcr_read
= handle_powerpc_dcr_read
,
757 .powerpc_dcr_write
= handle_powerpc_dcr_write
,
763 /* Try to initialize kvm */
764 kvm_context
= kvm_init(&qemu_kvm_ops
, cpu_single_env
);
768 pthread_mutex_lock(&qemu_mutex
);
773 int kvm_qemu_create_context(void)
777 kvm_disable_irqchip_creation(kvm_context
);
780 kvm_disable_pit_creation(kvm_context
);
782 if (kvm_create(kvm_context
, phys_ram_size
, (void**)&phys_ram_base
) < 0) {
786 r
= kvm_arch_qemu_create_context();
792 void kvm_qemu_destroy(void)
794 kvm_finalize(kvm_context
);
797 void kvm_cpu_register_physical_memory(target_phys_addr_t start_addr
,
799 unsigned long phys_offset
)
802 unsigned long area_flags
= phys_offset
& ~TARGET_PAGE_MASK
;
804 phys_offset
&= ~IO_MEM_ROM
;
806 if (area_flags
== IO_MEM_UNASSIGNED
) {
807 kvm_unregister_memory_area(kvm_context
, start_addr
, size
);
811 r
= kvm_is_containing_region(kvm_context
, start_addr
, size
);
815 if (area_flags
>= TLB_MMIO
)
818 r
= kvm_register_phys_mem(kvm_context
, start_addr
,
819 phys_ram_base
+ phys_offset
,
822 printf("kvm_cpu_register_physical_memory: failed\n");
828 void kvm_cpu_unregister_physical_memory(target_phys_addr_t start_addr
,
829 target_phys_addr_t size
,
830 unsigned long phys_offset
)
832 kvm_unregister_memory_area(kvm_context
, start_addr
, size
);
835 int kvm_setup_guest_memory(void *area
, unsigned long size
)
840 if (kvm_enabled() && !kvm_has_sync_mmu(kvm_context
))
841 ret
= madvise(area
, size
, MADV_DONTFORK
);
850 int kvm_qemu_check_extension(int ext
)
852 return kvm_check_extension(kvm_context
, ext
);
855 int kvm_qemu_init_env(CPUState
*cenv
)
857 return kvm_arch_qemu_init_env(cenv
);
860 struct kvm_guest_debug_data
{
861 struct kvm_debug_guest dbg
;
865 void kvm_invoke_guest_debug(void *data
)
867 struct kvm_guest_debug_data
*dbg_data
= data
;
869 dbg_data
->err
= kvm_guest_debug(kvm_context
, cpu_single_env
->cpu_index
,
873 int kvm_update_debugger(CPUState
*env
)
875 struct kvm_guest_debug_data data
;
879 memset(data
.dbg
.breakpoints
, 0, sizeof(data
.dbg
.breakpoints
));
881 data
.dbg
.enabled
= 0;
882 if (env
->breakpoints
|| env
->singlestep_enabled
) {
883 bp
= env
->breakpoints
;
884 data
.dbg
.enabled
= 1;
885 for (i
= 0; i
< 4 && bp
; ++i
) {
886 data
.dbg
.breakpoints
[i
].enabled
= 1;
887 data
.dbg
.breakpoints
[i
].address
= bp
->pc
;
890 data
.dbg
.singlestep
= env
->singlestep_enabled
;
892 on_vcpu(env
, kvm_invoke_guest_debug
, &data
);
898 * dirty pages logging
900 /* FIXME: use unsigned long pointer instead of unsigned char */
901 unsigned char *kvm_dirty_bitmap
= NULL
;
902 int kvm_physical_memory_set_dirty_tracking(int enable
)
910 if (!kvm_dirty_bitmap
) {
911 unsigned bitmap_size
= BITMAP_SIZE(phys_ram_size
);
912 kvm_dirty_bitmap
= qemu_malloc(bitmap_size
);
913 if (kvm_dirty_bitmap
== NULL
) {
914 perror("Failed to allocate dirty pages bitmap");
918 r
= kvm_dirty_pages_log_enable_all(kvm_context
);
923 if (kvm_dirty_bitmap
) {
924 r
= kvm_dirty_pages_log_reset(kvm_context
);
925 qemu_free(kvm_dirty_bitmap
);
926 kvm_dirty_bitmap
= NULL
;
932 /* get kvm's dirty pages bitmap and update qemu's */
933 int kvm_get_dirty_pages_log_range(unsigned long start_addr
,
934 unsigned char *bitmap
,
936 unsigned long mem_size
)
938 unsigned int i
, j
, n
=0;
940 unsigned page_number
, addr
, addr1
;
941 unsigned int len
= ((mem_size
/TARGET_PAGE_SIZE
) + 7) / 8;
944 * bitmap-traveling is faster than memory-traveling (for addr...)
945 * especially when most of the memory is not dirty.
947 for (i
=0; i
<len
; i
++) {
952 page_number
= i
* 8 + j
;
953 addr1
= page_number
* TARGET_PAGE_SIZE
;
954 addr
= offset
+ addr1
;
955 cpu_physical_memory_set_dirty(addr
);
961 int kvm_get_dirty_bitmap_cb(unsigned long start
, unsigned long len
,
962 void *bitmap
, void *opaque
)
964 return kvm_get_dirty_pages_log_range(start
, bitmap
, start
, len
);
968 * get kvm's dirty pages bitmap and update qemu's
969 * we only care about physical ram, which resides in slots 0 and 3
971 int kvm_update_dirty_pages_log(void)
976 r
= kvm_get_dirty_pages_range(kvm_context
, 0, phys_ram_size
,
977 kvm_dirty_bitmap
, NULL
,
978 kvm_get_dirty_bitmap_cb
);
982 void kvm_qemu_log_memory(target_phys_addr_t start
, target_phys_addr_t size
,
986 kvm_dirty_pages_log_enable_slot(kvm_context
, start
, size
);
988 kvm_dirty_pages_log_disable_slot(kvm_context
, start
, size
);
991 int kvm_get_phys_ram_page_bitmap(unsigned char *bitmap
)
993 unsigned int bsize
= BITMAP_SIZE(phys_ram_size
);
994 unsigned int brsize
= BITMAP_SIZE(ram_size
);
995 unsigned int extra_pages
= (phys_ram_size
- ram_size
) / TARGET_PAGE_SIZE
;
996 unsigned int extra_bytes
= (extra_pages
+7)/8;
997 unsigned int hole_start
= BITMAP_SIZE(0xa0000);
998 unsigned int hole_end
= BITMAP_SIZE(0xc0000);
1000 memset(bitmap
, 0xFF, brsize
+ extra_bytes
);
1001 memset(bitmap
+ hole_start
, 0, hole_end
- hole_start
);
1002 memset(bitmap
+ brsize
+ extra_bytes
, 0, bsize
- brsize
- extra_bytes
);
1007 #ifdef KVM_CAP_IRQCHIP
1009 int kvm_set_irq(int irq
, int level
)
1011 return kvm_set_irq_level(kvm_context
, irq
, level
);
1016 int qemu_kvm_get_dirty_pages(unsigned long phys_addr
, void *buf
)
1018 return kvm_get_dirty_pages(kvm_context
, phys_addr
, buf
);
1021 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr
,
1022 unsigned long size
, int log
, int writable
)
1024 return kvm_create_phys_mem(kvm_context
, start_addr
, size
, log
, writable
);
1027 void kvm_cpu_destroy_phys_mem(target_phys_addr_t start_addr
,
1030 kvm_destroy_phys_mem(kvm_context
, start_addr
, size
);
1033 void kvm_mutex_unlock(void)
1035 assert(!cpu_single_env
);
1036 pthread_mutex_unlock(&qemu_mutex
);
1039 void kvm_mutex_lock(void)
1041 pthread_mutex_lock(&qemu_mutex
);
1042 cpu_single_env
= NULL
;
1045 int qemu_kvm_register_coalesced_mmio(target_phys_addr_t addr
, unsigned int size
)
1047 return kvm_register_coalesced_mmio(kvm_context
, addr
, size
);
1050 int qemu_kvm_unregister_coalesced_mmio(target_phys_addr_t addr
,
1053 return kvm_unregister_coalesced_mmio(kvm_context
, addr
, size
);
1056 #ifdef USE_KVM_DEVICE_ASSIGNMENT
1057 void kvm_add_ioperm_data(struct ioperm_data
*data
)
1059 LIST_INSERT_HEAD(&ioperm_head
, data
, entries
);
1062 void kvm_ioperm(CPUState
*env
, void *data
)
1064 if (kvm_enabled() && qemu_system_ready
)
1065 on_vcpu(env
, kvm_arch_do_ioperm
, data
);