[mirror_qemu.git] / include / sysemu / kvm_int.h

/*
 * Internal definitions for a target's KVM support
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 *
 */

#ifndef QEMU_KVM_INT_H
#define QEMU_KVM_INT_H

#include "exec/memory.h"
#include "qapi/qapi-types-common.h"
#include "qemu/accel.h"
#include "qemu/queue.h"
#include "sysemu/kvm.h"

typedef struct KVMSlot
{
    hwaddr start_addr;
    ram_addr_t memory_size;
    void *ram;
    int slot;
    int flags;
    int old_flags;
    /* Dirty bitmap cache for the slot */
    unsigned long *dirty_bmap;
    unsigned long dirty_bmap_size;
    /* Cache of the address space ID */
    int as_id;
    /* Cache of the offset in ram address space */
    ram_addr_t ram_start_offset;
} KVMSlot;

typedef struct KVMMemoryUpdate {
    QSIMPLEQ_ENTRY(KVMMemoryUpdate) next;
    MemoryRegionSection section;
} KVMMemoryUpdate;

typedef struct KVMMemoryListener {
    MemoryListener listener;
    KVMSlot *slots;
    unsigned int nr_used_slots;
    int as_id;
    QSIMPLEQ_HEAD(, KVMMemoryUpdate) transaction_add;
    QSIMPLEQ_HEAD(, KVMMemoryUpdate) transaction_del;
} KVMMemoryListener;

#define KVM_MSI_HASHTAB_SIZE    256

enum KVMDirtyRingReaperState {
    KVM_DIRTY_RING_REAPER_NONE = 0,
    /* The reaper is sleeping */
    KVM_DIRTY_RING_REAPER_WAIT,
    /* The reaper is reaping for dirty pages */
    KVM_DIRTY_RING_REAPER_REAPING,
};

/*
 * KVM reaper instance, responsible for collecting the KVM dirty bits
 * via the dirty ring.
 */
struct KVMDirtyRingReaper {
    /* The reaper thread */
    QemuThread reaper_thr;
    volatile uint64_t reaper_iteration; /* iteration number of reaper thr */
    volatile enum KVMDirtyRingReaperState reaper_state; /* reap thr state */
};
struct KVMState
{
    AccelState parent_obj;

    int nr_slots;
    int fd;
    int vmfd;
    int coalesced_mmio;
    int coalesced_pio;
    struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
    bool coalesced_flush_in_progress;
    int vcpu_events;
    int robust_singlestep;
    int debugregs;
#ifdef KVM_CAP_SET_GUEST_DEBUG
    QTAILQ_HEAD(, kvm_sw_breakpoint) kvm_sw_breakpoints;
#endif
    int max_nested_state_len;
    int many_ioeventfds;
    int intx_set_mask;
    int kvm_shadow_mem;
    bool kernel_irqchip_allowed;
    bool kernel_irqchip_required;
    OnOffAuto kernel_irqchip_split;
    bool sync_mmu;
    uint64_t manual_dirty_log_protect;
    /* The man page (and posix) say ioctl numbers are signed int, but
     * they're not.  Linux, glibc and *BSD all treat ioctl numbers as
     * unsigned, and treating them as signed here can break things */
    unsigned irq_set_ioctl;
    unsigned int sigmask_len;
    GHashTable *gsimap;
#ifdef KVM_CAP_IRQ_ROUTING
    struct kvm_irq_routing *irq_routes;
    int nr_allocated_irq_routes;
    unsigned long *used_gsi_bitmap;
    unsigned int gsi_count;
    QTAILQ_HEAD(, KVMMSIRoute) msi_hashtab[KVM_MSI_HASHTAB_SIZE];
#endif
    KVMMemoryListener memory_listener;
    QLIST_HEAD(, KVMParkedVcpu) kvm_parked_vcpus;

    /* For "info mtree -f" to tell if an MR is registered in KVM */
    int nr_as;
    struct KVMAs {
        KVMMemoryListener *ml;
        AddressSpace *as;
    } *as;
    uint64_t kvm_dirty_ring_bytes;  /* Size of the per-vcpu dirty ring */
    uint32_t kvm_dirty_ring_size;   /* Number of dirty GFNs per ring */
    bool kvm_dirty_ring_with_bitmap;
    uint64_t kvm_eager_split_size;  /* Eager Page Splitting chunk size */
    struct KVMDirtyRingReaper reaper;
    NotifyVmexitOption notify_vmexit;
    uint32_t notify_window;
    uint32_t xen_version;
    uint32_t xen_caps;
    uint16_t xen_gnttab_max_frames;
    uint16_t xen_evtchn_max_pirq;
};

void kvm_memory_listener_register(KVMState *s, KVMMemoryListener *kml,
                                  AddressSpace *as, int as_id, const char *name);

void kvm_set_max_memslot_size(hwaddr max_slot_size);

/**
 * kvm_hwpoison_page_add:
 *
 * Parameters:
 *  @ram_addr: the address in the RAM for the poisoned page
 *
 * Add a poisoned page to the list
 *
 * Return: None.
 */
void kvm_hwpoison_page_add(ram_addr_t ram_addr);
#endif
Commit	Line	Data
8571ed35 PB	1	/*
	2	* Internal definitions for a target's KVM support
	3	*
	4	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	5	* See the COPYING file in the top-level directory.
	6	*
	7	*/
	8
	9	#ifndef QEMU_KVM_INT_H
	10	#define QEMU_KVM_INT_H
	11
ec150c7e	12	#include "exec/memory.h"
5f8a6bce	13	#include "qapi/qapi-types-common.h"
940e43aa	14	#include "qemu/accel.h"
f39b7d2b	15	#include "qemu/queue.h"
8571ed35 PB	16	#include "sysemu/kvm.h"
	17
	18	typedef struct KVMSlot
	19	{
	20	hwaddr start_addr;
	21	ram_addr_t memory_size;
	22	void *ram;
	23	int slot;
	24	int flags;
6c090d4a	25	int old_flags;
9f4bf4ba PX	26	/* Dirty bitmap cache for the slot */
9f4bf4ba PX	27	unsigned long *dirty_bmap;
563d32ba	28	unsigned long dirty_bmap_size;
e65e5f50 PX	29	/* Cache of the address space ID */
e65e5f50 PX	30	int as_id;
2c20b27e PX	31	/* Cache of the offset in ram address space */
2c20b27e PX	32	ram_addr_t ram_start_offset;
8571ed35 PB	33	} KVMSlot;
8571ed35 PB	34
f39b7d2b DH	35	typedef struct KVMMemoryUpdate {
	36	QSIMPLEQ_ENTRY(KVMMemoryUpdate) next;
	37	MemoryRegionSection section;
	38	} KVMMemoryUpdate;
	39
7bbda04c PB	40	typedef struct KVMMemoryListener {
	41	MemoryListener listener;
	42	KVMSlot *slots;
5b23186a	43	unsigned int nr_used_slots;
38bfe691	44	int as_id;
f39b7d2b DH	45	QSIMPLEQ_HEAD(, KVMMemoryUpdate) transaction_add;
f39b7d2b DH	46	QSIMPLEQ_HEAD(, KVMMemoryUpdate) transaction_del;
7bbda04c PB	47	} KVMMemoryListener;
7bbda04c PB	48
5f8a6bce CQ	49	#define KVM_MSI_HASHTAB_SIZE 256
	50
	51	enum KVMDirtyRingReaperState {
	52	KVM_DIRTY_RING_REAPER_NONE = 0,
	53	/* The reaper is sleeping */
	54	KVM_DIRTY_RING_REAPER_WAIT,
	55	/* The reaper is reaping for dirty pages */
	56	KVM_DIRTY_RING_REAPER_REAPING,
	57	};
	58
	59	/*
	60	* KVM reaper instance, responsible for collecting the KVM dirty bits
	61	* via the dirty ring.
	62	*/
	63	struct KVMDirtyRingReaper {
	64	/* The reaper thread */
	65	QemuThread reaper_thr;
	66	volatile uint64_t reaper_iteration; /* iteration number of reaper thr */
	67	volatile enum KVMDirtyRingReaperState reaper_state; /* reap thr state */
	68	};
	69	struct KVMState
	70	{
	71	AccelState parent_obj;
	72
	73	int nr_slots;
	74	int fd;
	75	int vmfd;
	76	int coalesced_mmio;
	77	int coalesced_pio;
	78	struct kvm_coalesced_mmio_ring *coalesced_mmio_ring;
	79	bool coalesced_flush_in_progress;
	80	int vcpu_events;
	81	int robust_singlestep;
	82	int debugregs;
	83	#ifdef KVM_CAP_SET_GUEST_DEBUG
	84	QTAILQ_HEAD(, kvm_sw_breakpoint) kvm_sw_breakpoints;
	85	#endif
	86	int max_nested_state_len;
	87	int many_ioeventfds;
	88	int intx_set_mask;
	89	int kvm_shadow_mem;
	90	bool kernel_irqchip_allowed;
	91	bool kernel_irqchip_required;
	92	OnOffAuto kernel_irqchip_split;
	93	bool sync_mmu;
	94	uint64_t manual_dirty_log_protect;
	95	/* The man page (and posix) say ioctl numbers are signed int, but
	96	* they're not. Linux, glibc and *BSD all treat ioctl numbers as
	97	* unsigned, and treating them as signed here can break things */
	98	unsigned irq_set_ioctl;
	99	unsigned int sigmask_len;
	100	GHashTable *gsimap;
	101	#ifdef KVM_CAP_IRQ_ROUTING
	102	struct kvm_irq_routing *irq_routes;
	103	int nr_allocated_irq_routes;
	104	unsigned long *used_gsi_bitmap;
	105	unsigned int gsi_count;
	106	QTAILQ_HEAD(, KVMMSIRoute) msi_hashtab[KVM_MSI_HASHTAB_SIZE];
	107	#endif
	108	KVMMemoryListener memory_listener;
	109	QLIST_HEAD(, KVMParkedVcpu) kvm_parked_vcpus;
	110
	111	/* For "info mtree -f" to tell if an MR is registered in KVM */
	112	int nr_as;
113	struct KVMAs {
114	KVMMemoryListener *ml;
115	AddressSpace *as;
116	} *as;
117	uint64_t kvm_dirty_ring_bytes; /* Size of the per-vcpu dirty ring */
118	uint32_t kvm_dirty_ring_size; /* Number of dirty GFNs per ring */
b20cc776	119	bool kvm_dirty_ring_with_bitmap;
c8f2eb5d	120	uint64_t kvm_eager_split_size; /* Eager Page Splitting chunk size */
5f8a6bce CQ	121	struct KVMDirtyRingReaper reaper;
	122	NotifyVmexitOption notify_vmexit;
	123	uint32_t notify_window;
61491cf4 DW	124	uint32_t xen_version;
61491cf4 DW	125	uint32_t xen_caps;
6f43f2ee	126	uint16_t xen_gnttab_max_frames;
e16aff4c	127	uint16_t xen_evtchn_max_pirq;
5f8a6bce CQ	128	};
5f8a6bce CQ	129
38bfe691	130	void kvm_memory_listener_register(KVMState s, KVMMemoryListener kml,
142518bd	131	AddressSpace as, int as_id, const char name);
38bfe691	132
023ae9a8	133	void kvm_set_max_memslot_size(hwaddr max_slot_size);
6b552b9b DG	134
	135	/**
	136	* kvm_hwpoison_page_add:
	137	*
	138	* Parameters:
	139	* @ram_addr: the address in the RAM for the poisoned page
	140	*
	141	* Add a poisoned page to the list
	142	*
	143	* Return: None.
	144	*/
	145	void kvm_hwpoison_page_add(ram_addr_t ram_addr);
8571ed35	146	#endif