4 * Copyright (C) 2006-2008 Qumranet Technologies
6 * Licensed under the terms of the GNU GPL version 2 or higher.
8 #ifndef THE_ORIGINAL_AND_TRUE_QEMU_KVM_H
9 #define THE_ORIGINAL_AND_TRUE_QEMU_KVM_H
19 #include <asm/ptrace.h>
25 #define __user /* temporary, until installed via make headers_install */
28 #include <linux/kvm.h>
32 /* FIXME: share this number with kvm */
33 /* FIXME: or dynamically alloc/realloc regions */
35 #define KVM_MAX_NUM_MEM_REGIONS 1u
37 #define LIBKVM_S390_ORIGIN (0UL)
38 #elif defined(__ia64__)
39 #define KVM_MAX_NUM_MEM_REGIONS 32u
42 #define KVM_MAX_NUM_MEM_REGIONS 32u
46 /* kvm abi verison variable */
50 * \brief The KVM context
52 * The verbose KVM context
57 /// is dirty pages logging enabled for all regions or not
58 int dirty_pages_log_all
;
59 /// do not create in-kernel irqchip if set
60 int no_irqchip_creation
;
61 /// in-kernel irqchip status
62 int irqchip_in_kernel
;
63 /// ioctl to use to inject interrupts
64 int irqchip_inject_ioctl
;
65 /// do not create in-kernel pit if set
67 #ifdef KVM_CAP_IRQ_ROUTING
68 struct kvm_irq_routing
*irq_routes
;
69 int nr_allocated_irq_routes
;
71 void *used_gsi_bitmap
;
75 typedef struct kvm_context
*kvm_context_t
;
78 int kvm_alloc_kernel_memory(kvm_context_t kvm
, unsigned long memory
,
80 int kvm_alloc_userspace_memory(kvm_context_t kvm
, unsigned long memory
,
83 int kvm_arch_create(kvm_context_t kvm
, unsigned long phys_mem_bytes
,
86 int kvm_arch_run(CPUState
*env
);
89 void kvm_show_code(CPUState
*env
);
91 int handle_halt(CPUState
*env
);
93 int handle_shutdown(kvm_context_t kvm
, CPUState
*env
);
94 void post_kvm_run(kvm_context_t kvm
, CPUState
*env
);
95 int pre_kvm_run(kvm_context_t kvm
, CPUState
*env
);
96 int handle_io_window(kvm_context_t kvm
);
97 int try_push_interrupts(kvm_context_t kvm
);
99 #if defined(__x86_64__) || defined(__i386__)
100 int kvm_get_msrs(CPUState
*env
, struct kvm_msr_entry
*msrs
, int n
);
101 int kvm_set_msrs(CPUState
*env
, struct kvm_msr_entry
*msrs
, int n
);
106 * \brief Disable the in-kernel IRQCHIP creation
108 * In-kernel irqchip is enabled by default. If userspace irqchip is to be used,
109 * this should be called prior to kvm_create().
111 * \param kvm Pointer to the kvm_context
113 void kvm_disable_irqchip_creation(kvm_context_t kvm
);
116 * \brief Disable the in-kernel PIT creation
118 * In-kernel pit is enabled by default. If userspace pit is to be used,
119 * this should be called prior to kvm_create().
121 * \param kvm Pointer to the kvm_context
123 void kvm_disable_pit_creation(kvm_context_t kvm
);
126 * \brief Create new virtual machine
128 * This creates a new virtual machine, maps physical RAM to it, and creates a
129 * virtual CPU for it.\n
131 * Memory gets mapped for addresses 0->0xA0000, 0xC0000->phys_mem_bytes
133 * \param kvm Pointer to the current kvm_context
134 * \param phys_mem_bytes The amount of physical ram you want the VM to have
135 * \param phys_mem This pointer will be set to point to the memory that
136 * kvm_create allocates for physical RAM
137 * \return 0 on success
139 int kvm_create(kvm_context_t kvm
, unsigned long phys_mem_bytes
,
141 int kvm_create_vm(kvm_context_t kvm
);
142 void kvm_create_irqchip(kvm_context_t kvm
);
145 * \brief Start the VCPU
147 * This starts the VCPU and virtualization is started.\n
149 * This function will not return until any of these conditions are met:
150 * - An IO/MMIO handler does not return "0"
151 * - An exception that neither the guest OS, nor KVM can handle occurs
153 * \note This function will call the callbacks registered in kvm_init()
154 * to emulate those functions
155 * \note If you at any point want to interrupt the VCPU, kvm_run() will
156 * listen to the EINTR signal. This allows you to simulate external interrupts
157 * and asyncronous IO.
159 * \param kvm Pointer to the current kvm_context
160 * \param vcpu Which virtual CPU should be started
161 * \return 0 on success, but you really shouldn't expect this function to
162 * return except for when an error has occured, or when you have sent it
165 int kvm_run(CPUState
*env
);
168 * \brief Check if a vcpu is ready for interrupt injection
170 * This checks if vcpu interrupts are not masked by mov ss or sti.
172 * \param kvm Pointer to the current kvm_context
173 * \param vcpu Which virtual CPU should get dumped
174 * \return boolean indicating interrupt injection readiness
176 int kvm_is_ready_for_interrupt_injection(CPUState
*env
);
179 * \brief Read VCPU registers
181 * This gets the GP registers from the VCPU and outputs them
182 * into a kvm_regs structure
184 * \note This function returns a \b copy of the VCPUs registers.\n
185 * If you wish to modify the VCPUs GP registers, you should call kvm_set_regs()
187 * \param kvm Pointer to the current kvm_context
188 * \param vcpu Which virtual CPU should get dumped
189 * \param regs Pointer to a kvm_regs which will be populated with the VCPUs
191 * \return 0 on success
193 int kvm_get_regs(CPUState
*env
, struct kvm_regs
*regs
);
196 * \brief Write VCPU registers
198 * This sets the GP registers on the VCPU from a kvm_regs structure
200 * \note When this function returns, the regs pointer and the data it points to
202 * \param kvm Pointer to the current kvm_context
203 * \param vcpu Which virtual CPU should get dumped
204 * \param regs Pointer to a kvm_regs which will be populated with the VCPUs
206 * \return 0 on success
208 int kvm_set_regs(CPUState
*env
, struct kvm_regs
*regs
);
210 #ifdef KVM_CAP_MP_STATE
212 * * \brief Read VCPU MP state
215 int kvm_get_mpstate(CPUState
*env
, struct kvm_mp_state
*mp_state
);
218 * * \brief Write VCPU MP state
221 int kvm_set_mpstate(CPUState
*env
, struct kvm_mp_state
*mp_state
);
225 * \brief Simulate an external vectored interrupt
227 * This allows you to simulate an external vectored interrupt.
229 * \param kvm Pointer to the current kvm_context
230 * \param vcpu Which virtual CPU should get dumped
231 * \param irq Vector number
232 * \return 0 on success
234 int kvm_inject_irq(CPUState
*env
, unsigned irq
);
236 #if defined(__i386__) || defined(__x86_64__)
238 * \brief Setup a vcpu's cpuid instruction emulation
240 * Set up a table of cpuid function to cpuid outputs.\n
242 * \param kvm Pointer to the current kvm_context
243 * \param vcpu Which virtual CPU should be initialized
244 * \param nent number of entries to be installed
245 * \param entries cpuid function entries table
246 * \return 0 on success, or -errno on error
248 int kvm_setup_cpuid(CPUState
*env
, int nent
,
249 struct kvm_cpuid_entry
*entries
);
252 * \brief Setup a vcpu's cpuid instruction emulation
254 * Set up a table of cpuid function to cpuid outputs.
255 * This call replaces the older kvm_setup_cpuid interface by adding a few
256 * parameters to support cpuid functions that have sub-leaf values.
258 * \param kvm Pointer to the current kvm_context
259 * \param vcpu Which virtual CPU should be initialized
260 * \param nent number of entries to be installed
261 * \param entries cpuid function entries table
262 * \return 0 on success, or -errno on error
264 int kvm_setup_cpuid2(CPUState
*env
, int nent
,
265 struct kvm_cpuid_entry2
*entries
);
268 * \brief Setting the number of shadow pages to be allocated to the vm
270 * \param kvm pointer to kvm_context
271 * \param nrshadow_pages number of pages to be allocated
273 int kvm_set_shadow_pages(kvm_context_t kvm
, unsigned int nrshadow_pages
);
276 * \brief Getting the number of shadow pages that are allocated to the vm
278 * \param kvm pointer to kvm_context
279 * \param nrshadow_pages number of pages to be allocated
281 int kvm_get_shadow_pages(kvm_context_t kvm
, unsigned int *nrshadow_pages
);
286 * \brief Dump VCPU registers
288 * This dumps some of the information that KVM has about a virtual CPU, namely:
291 * A much more verbose version of this is available as kvm_dump_vcpu()
293 * \param kvm Pointer to the current kvm_context
294 * \param vcpu Which virtual CPU should get dumped
295 * \return 0 on success
297 void kvm_show_regs(CPUState
*env
);
300 void *kvm_create_phys_mem(kvm_context_t
, unsigned long phys_start
,
301 unsigned long len
, int log
, int writable
);
302 void kvm_destroy_phys_mem(kvm_context_t
, unsigned long phys_start
,
305 int kvm_is_containing_region(kvm_context_t kvm
, unsigned long phys_start
,
307 int kvm_register_phys_mem(kvm_context_t kvm
, unsigned long phys_start
,
308 void *userspace_addr
, unsigned long len
, int log
);
309 int kvm_get_dirty_pages_range(kvm_context_t kvm
, unsigned long phys_addr
,
310 unsigned long end_addr
, void *opaque
,
311 int (*cb
)(unsigned long start
,
312 unsigned long len
, void *bitmap
,
314 int kvm_register_coalesced_mmio(kvm_context_t kvm
, uint64_t addr
,
316 int kvm_unregister_coalesced_mmio(kvm_context_t kvm
, uint64_t addr
,
320 * \brief Get a bitmap of guest ram pages which are allocated to the guest.
322 * \param kvm Pointer to the current kvm_context
323 * \param phys_addr Memory slot phys addr
324 * \param bitmap Long aligned address of a big enough bitmap (one bit per page)
326 int kvm_get_mem_map(kvm_context_t kvm
, unsigned long phys_addr
, void *bitmap
);
327 int kvm_get_mem_map_range(kvm_context_t kvm
, unsigned long phys_addr
,
328 unsigned long len
, void *buf
, void *opaque
,
329 int (*cb
)(unsigned long start
,
330 unsigned long len
, void *bitmap
,
332 int kvm_set_irq_level(kvm_context_t kvm
, int irq
, int level
, int *status
);
334 int kvm_dirty_pages_log_enable_slot(kvm_context_t kvm
, uint64_t phys_start
,
336 int kvm_dirty_pages_log_disable_slot(kvm_context_t kvm
, uint64_t phys_start
,
339 * \brief Enable dirty-pages-logging for all memory regions
341 * \param kvm Pointer to the current kvm_context
343 int kvm_dirty_pages_log_enable_all(kvm_context_t kvm
);
346 * \brief Disable dirty-page-logging for some memory regions
348 * Disable dirty-pages-logging for those memory regions that were
349 * created with dirty-page-logging disabled.
351 * \param kvm Pointer to the current kvm_context
353 int kvm_dirty_pages_log_reset(kvm_context_t kvm
);
355 #ifdef KVM_CAP_IRQCHIP
357 * \brief Dump in kernel IRQCHIP contents
359 * Dump one of the in kernel irq chip devices, including PIC (master/slave)
360 * and IOAPIC into a kvm_irqchip structure
362 * \param kvm Pointer to the current kvm_context
363 * \param chip The irq chip device to be dumped
365 int kvm_get_irqchip(kvm_context_t kvm
, struct kvm_irqchip
*chip
);
368 * \brief Set in kernel IRQCHIP contents
370 * Write one of the in kernel irq chip devices, including PIC (master/slave)
374 * \param kvm Pointer to the current kvm_context
375 * \param chip THe irq chip device to be written
377 int kvm_set_irqchip(kvm_context_t kvm
, struct kvm_irqchip
*chip
);
379 #if defined(__i386__) || defined(__x86_64__)
381 * \brief Get in kernel local APIC for vcpu
383 * Save the local apic state including the timer of a virtual CPU
385 * \param kvm Pointer to the current kvm_context
386 * \param vcpu Which virtual CPU should be accessed
387 * \param s Local apic state of the specific virtual CPU
389 int kvm_get_lapic(CPUState
*env
, struct kvm_lapic_state
*s
);
392 * \brief Set in kernel local APIC for vcpu
394 * Restore the local apic state including the timer of a virtual CPU
396 * \param kvm Pointer to the current kvm_context
397 * \param vcpu Which virtual CPU should be accessed
398 * \param s Local apic state of the specific virtual CPU
400 int kvm_set_lapic(CPUState
*env
, struct kvm_lapic_state
*s
);
405 * \brief Simulate an NMI
407 * This allows you to simulate a non-maskable interrupt.
409 * \param kvm Pointer to the current kvm_context
410 * \param vcpu Which virtual CPU should get dumped
411 * \return 0 on success
413 int kvm_inject_nmi(CPUState
*env
);
418 * \brief Initialize coalesced MMIO
420 * Check for coalesced MMIO capability and store in context
422 * \param kvm Pointer to the current kvm_context
424 int kvm_init_coalesced_mmio(kvm_context_t kvm
);
428 #if defined(__i386__) || defined(__x86_64__)
430 * \brief Get in kernel PIT of the virtual domain
432 * Save the PIT state.
434 * \param kvm Pointer to the current kvm_context
435 * \param s PIT state of the virtual domain
437 int kvm_get_pit(kvm_context_t kvm
, struct kvm_pit_state
*s
);
440 * \brief Set in kernel PIT of the virtual domain
442 * Restore the PIT state.
443 * Timer would be retriggerred after restored.
445 * \param kvm Pointer to the current kvm_context
446 * \param s PIT state of the virtual domain
448 int kvm_set_pit(kvm_context_t kvm
, struct kvm_pit_state
*s
);
450 int kvm_reinject_control(kvm_context_t kvm
, int pit_reinject
);
452 #ifdef KVM_CAP_PIT_STATE2
454 * \brief Check for kvm support of kvm_pit_state2
456 * \param kvm Pointer to the current kvm_context
457 * \return 0 on success
459 int kvm_has_pit_state2(kvm_context_t kvm
);
462 * \brief Set in kernel PIT state2 of the virtual domain
465 * \param kvm Pointer to the current kvm_context
466 * \param ps2 PIT state2 of the virtual domain
467 * \return 0 on success
469 int kvm_set_pit2(kvm_context_t kvm
, struct kvm_pit_state2
*ps2
);
472 * \brief Get in kernel PIT state2 of the virtual domain
475 * \param kvm Pointer to the current kvm_context
476 * \param ps2 PIT state2 of the virtual domain
477 * \return 0 on success
479 int kvm_get_pit2(kvm_context_t kvm
, struct kvm_pit_state2
*ps2
);
487 int kvm_enable_vapic(CPUState
*env
, uint64_t vapic
);
491 #if defined(__s390__)
492 int kvm_s390_initial_reset(kvm_context_t kvm
, int slot
);
493 int kvm_s390_interrupt(kvm_context_t kvm
, int slot
,
494 struct kvm_s390_interrupt
*kvmint
);
495 int kvm_s390_set_initial_psw(kvm_context_t kvm
, int slot
, psw_t psw
);
496 int kvm_s390_store_status(kvm_context_t kvm
, int slot
, unsigned long addr
);
499 #ifdef KVM_CAP_DEVICE_ASSIGNMENT
501 * \brief Notifies host kernel about a PCI device to be assigned to a guest
503 * Used for PCI device assignment, this function notifies the host
504 * kernel about the assigning of the physical PCI device to a guest.
506 * \param kvm Pointer to the current kvm_context
507 * \param assigned_dev Parameters, like bus, devfn number, etc
509 int kvm_assign_pci_device(kvm_context_t kvm
,
510 struct kvm_assigned_pci_dev
*assigned_dev
);
513 * \brief Assign IRQ for an assigned device
515 * Used for PCI device assignment, this function assigns IRQ numbers for
516 * an physical device and guest IRQ handling.
518 * \param kvm Pointer to the current kvm_context
519 * \param assigned_irq Parameters, like dev id, host irq, guest irq, etc
521 int kvm_assign_irq(kvm_context_t kvm
, struct kvm_assigned_irq
*assigned_irq
);
523 #ifdef KVM_CAP_ASSIGN_DEV_IRQ
525 * \brief Deassign IRQ for an assigned device
527 * Used for PCI device assignment, this function deassigns IRQ numbers
528 * for an assigned device.
530 * \param kvm Pointer to the current kvm_context
531 * \param assigned_irq Parameters, like dev id, host irq, guest irq, etc
533 int kvm_deassign_irq(kvm_context_t kvm
, struct kvm_assigned_irq
*assigned_irq
);
537 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
539 * \brief Notifies host kernel about a PCI device to be deassigned from a guest
541 * Used for hot remove PCI device, this function notifies the host
542 * kernel about the deassigning of the physical PCI device from a guest.
544 * \param kvm Pointer to the current kvm_context
545 * \param assigned_dev Parameters, like bus, devfn number, etc
547 int kvm_deassign_pci_device(kvm_context_t kvm
,
548 struct kvm_assigned_pci_dev
*assigned_dev
);
552 * \brief Determines the number of gsis that can be routed
554 * Returns the number of distinct gsis that can be routed by kvm. This is
555 * also the number of distinct routes (if a gsi has two routes, than another
556 * gsi cannot be used...)
558 * \param kvm Pointer to the current kvm_context
560 int kvm_get_gsi_count(kvm_context_t kvm
);
563 * \brief Clears the temporary irq routing table
565 * Clears the temporary irq routing table. Nothing is committed to the
569 int kvm_clear_gsi_routes(void);
572 * \brief Adds an irq route to the temporary irq routing table
574 * Adds an irq route to the temporary irq routing table. Nothing is
575 * committed to the running VM.
577 int kvm_add_irq_route(int gsi
, int irqchip
, int pin
);
580 * \brief Removes an irq route from the temporary irq routing table
582 * Adds an irq route to the temporary irq routing table. Nothing is
583 * committed to the running VM.
585 int kvm_del_irq_route(int gsi
, int irqchip
, int pin
);
587 struct kvm_irq_routing_entry
;
589 * \brief Adds a routing entry to the temporary irq routing table
591 * Adds a filled routing entry to the temporary irq routing table. Nothing is
592 * committed to the running VM.
594 int kvm_add_routing_entry(struct kvm_irq_routing_entry
*entry
);
597 * \brief Removes a routing from the temporary irq routing table
599 * Remove a routing to the temporary irq routing table. Nothing is
600 * committed to the running VM.
602 int kvm_del_routing_entry(struct kvm_irq_routing_entry
*entry
);
605 * \brief Updates a routing in the temporary irq routing table
607 * Update a routing in the temporary irq routing table
608 * with a new value. entry type and GSI can not be changed.
609 * Nothing is committed to the running VM.
611 int kvm_update_routing_entry(struct kvm_irq_routing_entry
*entry
,
612 struct kvm_irq_routing_entry
*newentry
);
616 * \brief Create a file descriptor for injecting interrupts
618 * Creates an eventfd based file-descriptor that maps to a specific GSI
619 * in the guest. eventfd compliant signaling (write() from userspace, or
620 * eventfd_signal() from kernelspace) will cause the GSI to inject
621 * itself into the guest at the next available window.
623 * \param kvm Pointer to the current kvm_context
624 * \param gsi GSI to assign to this fd
625 * \param flags reserved, must be zero
627 int kvm_irqfd(kvm_context_t kvm
, int gsi
, int flags
);
629 #ifdef KVM_CAP_DEVICE_MSIX
630 int kvm_assign_set_msix_nr(kvm_context_t kvm
,
631 struct kvm_assigned_msix_nr
*msix_nr
);
632 int kvm_assign_set_msix_entry(kvm_context_t kvm
,
633 struct kvm_assigned_msix_entry
*entry
);
636 #else /* !CONFIG_KVM */
638 typedef struct kvm_context
*kvm_context_t
;
639 typedef struct kvm_vcpu_context
*kvm_vcpu_context_t
;
641 struct kvm_pit_state
{
644 #endif /* !CONFIG_KVM */
648 * \brief Create new KVM context
650 * This creates a new kvm_context. A KVM context is a small area of data that
651 * holds information about the KVM instance that gets created by this call.\n
652 * This should always be your first call to KVM.
654 * \param opaque Not used
655 * \return NULL on failure
657 int kvm_init(int smp_cpus
);
659 int kvm_main_loop(void);
660 int kvm_init_ap(void);
661 int kvm_vcpu_inited(CPUState
*env
);
662 void kvm_save_lapic(CPUState
*env
);
663 void kvm_load_lapic(CPUState
*env
);
665 void kvm_hpet_enable_kpit(void);
666 void kvm_hpet_disable_kpit(void);
668 int kvm_physical_memory_set_dirty_tracking(int enable
);
670 void on_vcpu(CPUState
*env
, void (*func
)(void *data
), void *data
);
671 void qemu_kvm_call_with_env(void (*func
)(void *), void *data
, CPUState
*env
);
672 void qemu_kvm_cpuid_on_env(CPUState
*env
);
673 void kvm_inject_interrupt(CPUState
*env
, int mask
);
674 void kvm_update_after_sipi(CPUState
*env
);
675 void kvm_update_interrupt_request(CPUState
*env
);
676 #ifndef CONFIG_USER_ONLY
677 void *kvm_cpu_create_phys_mem(target_phys_addr_t start_addr
, unsigned long size
,
678 int log
, int writable
);
680 void kvm_cpu_destroy_phys_mem(target_phys_addr_t start_addr
,
682 void kvm_qemu_log_memory(target_phys_addr_t start
, target_phys_addr_t size
,
685 int kvm_qemu_create_memory_alias(uint64_t phys_start
, uint64_t len
,
686 uint64_t target_phys
);
687 int kvm_qemu_destroy_memory_alias(uint64_t phys_start
);
689 int kvm_arch_qemu_create_context(void);
691 void kvm_arch_save_regs(CPUState
*env
);
692 void kvm_arch_load_regs(CPUState
*env
, int level
);
693 int kvm_arch_has_work(CPUState
*env
);
694 void kvm_arch_process_irqchip_events(CPUState
*env
);
695 int kvm_arch_try_push_interrupts(void *opaque
);
696 void kvm_arch_push_nmi(void *opaque
);
697 void kvm_arch_cpu_reset(CPUState
*env
);
698 int kvm_set_boot_cpu_id(uint32_t id
);
700 void qemu_kvm_aio_wait_start(void);
701 void qemu_kvm_aio_wait(void);
702 void qemu_kvm_aio_wait_end(void);
704 void kvm_tpr_access_report(CPUState
*env
, uint64_t rip
, int is_write
);
706 int kvm_arch_init_irq_routing(void);
708 int kvm_mmio_read(void *opaque
, uint64_t addr
, uint8_t * data
, int len
);
709 int kvm_mmio_write(void *opaque
, uint64_t addr
, uint8_t * data
, int len
);
711 #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT
714 void kvm_ioperm(CPUState
*env
, void *data
);
715 void kvm_add_ioperm_data(struct ioperm_data
*data
);
716 void kvm_remove_ioperm_data(unsigned long start_port
, unsigned long num
);
717 void kvm_arch_do_ioperm(void *_data
);
720 #define ALIGN(x, y) (((x)+(y)-1) & ~((y)-1))
721 #define BITMAP_SIZE(m) (ALIGN(((m)>>TARGET_PAGE_BITS), HOST_LONG_BITS) / 8)
724 #include "qemu-queue.h"
726 extern int kvm_irqchip
;
728 extern int kvm_pit_reinject
;
729 extern int kvm_nested
;
730 extern kvm_context_t kvm_context
;
733 unsigned long start_port
;
736 QLIST_ENTRY(ioperm_data
) entries
;
739 void qemu_kvm_cpu_stop(CPUState
*env
);
740 int kvm_arch_halt(CPUState
*env
);
741 int handle_tpr_access(void *opaque
, CPUState
*env
, uint64_t rip
,
744 #define qemu_kvm_has_gsi_routing() kvm_has_gsi_routing()
746 #define qemu_kvm_has_pit_state2() kvm_has_pit_state2(kvm_context)
750 #define qemu_kvm_has_gsi_routing() (0)
752 #define qemu_kvm_has_pit_state2() (0)
754 #define qemu_kvm_cpu_stop(env) do {} while(0)
759 typedef struct KVMSlot
{
760 target_phys_addr_t start_addr
;
761 ram_addr_t memory_size
;
762 ram_addr_t phys_offset
;
767 typedef struct kvm_dirty_log KVMDirtyLog
;
774 #ifdef KVM_CAP_COALESCED_MMIO
775 struct kvm_coalesced_mmio_ring
*coalesced_mmio_ring
;
777 int broken_set_mem_region
;
780 int robust_singlestep
;
782 #ifdef KVM_CAP_SET_GUEST_DEBUG
783 QTAILQ_HEAD(, kvm_sw_breakpoint
) kvm_sw_breakpoints
;
785 int irqchip_in_kernel
;
789 struct kvm_context kvm_context
;
792 extern struct KVMState
*kvm_state
;
794 int kvm_tpr_enable_vapic(CPUState
*env
);
796 unsigned long kvm_get_thread_id(void);
797 int kvm_cpu_is_stopped(CPUState
*env
);