[linux-2.6-block.git] / drivers / kvm / kvm.h

#ifndef __KVM_H
#define __KVM_H

/*
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 */

#include <linux/types.h>
#include <linux/hardirq.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/spinlock.h>
#include <linux/signal.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/preempt.h>
#include <asm/signal.h>

#include <linux/kvm.h>
#include <linux/kvm_para.h>

#define KVM_MAX_VCPUS 4
#define KVM_ALIAS_SLOTS 4
#define KVM_MEMORY_SLOTS 8
/* memory slots that does not exposed to userspace */
#define KVM_PRIVATE_MEM_SLOTS 4
#define KVM_PERMILLE_MMU_PAGES 20
#define KVM_MIN_ALLOC_MMU_PAGES 64
#define KVM_NUM_MMU_PAGES 1024
#define KVM_MIN_FREE_MMU_PAGES 5
#define KVM_REFILL_PAGES 25
#define KVM_MAX_CPUID_ENTRIES 40

#define KVM_PIO_PAGE_OFFSET 1

/*
 * vcpu->requests bit members
 */
#define KVM_REQ_TLB_FLUSH          0

/*
 * Address types:
 *
 *  gva - guest virtual address
 *  gpa - guest physical address
 *  gfn - guest frame number
 *  hva - host virtual address
 *  hpa - host physical address
 *  hfn - host frame number
 */

typedef unsigned long  gva_t;
typedef u64            gpa_t;
typedef unsigned long  gfn_t;

typedef unsigned long  hva_t;
typedef u64            hpa_t;
typedef unsigned long  hfn_t;

#define NR_PTE_CHAIN_ENTRIES 5

struct kvm_pte_chain {
	u64 *parent_ptes[NR_PTE_CHAIN_ENTRIES];
	struct hlist_node link;
};

/*
 * kvm_mmu_page_role, below, is defined as:
 *
 *   bits 0:3 - total guest paging levels (2-4, or zero for real mode)
 *   bits 4:7 - page table level for this shadow (1-4)
 *   bits 8:9 - page table quadrant for 2-level guests
 *   bit   16 - "metaphysical" - gfn is not a real page (huge page/real mode)
 *   bits 17:19 - "access" - the user, writable, and nx bits of a huge page pde
 */
union kvm_mmu_page_role {
	unsigned word;
	struct {
		unsigned glevels : 4;
		unsigned level : 4;
		unsigned quadrant : 2;
		unsigned pad_for_nice_hex_output : 6;
		unsigned metaphysical : 1;
		unsigned hugepage_access : 3;
	};
};

struct kvm_mmu_page {
	struct list_head link;
	struct hlist_node hash_link;

	/*
	 * The following two entries are used to key the shadow page in the
	 * hash table.
	 */
	gfn_t gfn;
	union kvm_mmu_page_role role;

	u64 *spt;
	/* hold the gfn of each spte inside spt */
	gfn_t *gfns;
	unsigned long slot_bitmap; /* One bit set per slot which has memory
				    * in this shadow page.
				    */
	int multimapped;         /* More than one parent_pte? */
	int root_count;          /* Currently serving as active root */
	union {
		u64 *parent_pte;               /* !multimapped */
		struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */
	};
};

struct kvm_vcpu;
extern struct kmem_cache *kvm_vcpu_cache;

/*
 * x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
 * 32-bit).  The kvm_mmu structure abstracts the details of the current mmu
 * mode.
 */
struct kvm_mmu {
	void (*new_cr3)(struct kvm_vcpu *vcpu);
	int (*page_fault)(struct kvm_vcpu *vcpu, gva_t gva, u32 err);
	void (*free)(struct kvm_vcpu *vcpu);
	gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva);
	void (*prefetch_page)(struct kvm_vcpu *vcpu,
			      struct kvm_mmu_page *page);
	hpa_t root_hpa;
	int root_level;
	int shadow_root_level;

	u64 *pae_root;
};

#define KVM_NR_MEM_OBJS 40

struct kvm_mmu_memory_cache {
	int nobjs;
	void *objects[KVM_NR_MEM_OBJS];
};

/*
 * We don't want allocation failures within the mmu code, so we preallocate
 * enough memory for a single page fault in a cache.
 */
struct kvm_guest_debug {
	int enabled;
	unsigned long bp[4];
	int singlestep;
};

struct kvm_pio_request {
	unsigned long count;
	int cur_count;
	struct page *guest_pages[2];
	unsigned guest_page_offset;
	int in;
	int port;
	int size;
	int string;
	int down;
	int rep;
};

struct kvm_vcpu_stat {
	u32 pf_fixed;
	u32 pf_guest;
	u32 tlb_flush;
	u32 invlpg;

	u32 exits;
	u32 io_exits;
	u32 mmio_exits;
	u32 signal_exits;
	u32 irq_window_exits;
	u32 halt_exits;
	u32 halt_wakeup;
	u32 request_irq_exits;
	u32 irq_exits;
	u32 host_state_reload;
	u32 efer_reload;
	u32 fpu_reload;
	u32 insn_emulation;
	u32 insn_emulation_fail;
};

struct kvm_io_device {
	void (*read)(struct kvm_io_device *this,
		     gpa_t addr,
		     int len,
		     void *val);
	void (*write)(struct kvm_io_device *this,
		      gpa_t addr,
		      int len,
		      const void *val);
	int (*in_range)(struct kvm_io_device *this, gpa_t addr);
	void (*destructor)(struct kvm_io_device *this);

	void             *private;
};

static inline void kvm_iodevice_read(struct kvm_io_device *dev,
				     gpa_t addr,
				     int len,
				     void *val)
{
	dev->read(dev, addr, len, val);
}

static inline void kvm_iodevice_write(struct kvm_io_device *dev,
				      gpa_t addr,
				      int len,
				      const void *val)
{
	dev->write(dev, addr, len, val);
}

static inline int kvm_iodevice_inrange(struct kvm_io_device *dev, gpa_t addr)
{
	return dev->in_range(dev, addr);
}

static inline void kvm_iodevice_destructor(struct kvm_io_device *dev)
{
	if (dev->destructor)
		dev->destructor(dev);
}

/*
 * It would be nice to use something smarter than a linear search, TBD...
 * Thankfully we dont expect many devices to register (famous last words :),
 * so until then it will suffice.  At least its abstracted so we can change
 * in one place.
 */
struct kvm_io_bus {
	int                   dev_count;
#define NR_IOBUS_DEVS 6
	struct kvm_io_device *devs[NR_IOBUS_DEVS];
};

void kvm_io_bus_init(struct kvm_io_bus *bus);
void kvm_io_bus_destroy(struct kvm_io_bus *bus);
struct kvm_io_device *kvm_io_bus_find_dev(struct kvm_io_bus *bus, gpa_t addr);
void kvm_io_bus_register_dev(struct kvm_io_bus *bus,
			     struct kvm_io_device *dev);

#ifdef CONFIG_HAS_IOMEM
#define KVM_VCPU_MMIO 			\
	int mmio_needed;		\
	int mmio_read_completed;	\
	int mmio_is_write;		\
	int mmio_size;			\
	unsigned char mmio_data[8];	\
	gpa_t mmio_phys_addr;

#else
#define KVM_VCPU_MMIO

#endif

#define KVM_VCPU_COMM 					\
	struct kvm *kvm; 				\
	struct preempt_notifier preempt_notifier;	\
	int vcpu_id;					\
	struct mutex mutex;				\
	int   cpu;					\
	struct kvm_run *run;				\
	int guest_mode;					\
	unsigned long requests;				\
	struct kvm_guest_debug guest_debug;		\
	int fpu_active; 				\
	int guest_fpu_loaded;				\
	wait_queue_head_t wq;				\
	int sigset_active;				\
	sigset_t sigset;				\
	struct kvm_vcpu_stat stat;			\
	KVM_VCPU_MMIO

struct kvm_mem_alias {
	gfn_t base_gfn;
	unsigned long npages;
	gfn_t target_gfn;
};

struct kvm_memory_slot {
	gfn_t base_gfn;
	unsigned long npages;
	unsigned long flags;
	unsigned long *rmap;
	unsigned long *dirty_bitmap;
	unsigned long userspace_addr;
	int user_alloc;
};

struct kvm_vm_stat {
	u32 mmu_shadow_zapped;
	u32 mmu_pte_write;
	u32 mmu_pte_updated;
	u32 mmu_pde_zapped;
	u32 mmu_flooded;
	u32 mmu_recycled;
};

struct kvm {
	struct mutex lock; /* protects everything except vcpus */
	int naliases;
	struct kvm_mem_alias aliases[KVM_ALIAS_SLOTS];
	int nmemslots;
	struct kvm_memory_slot memslots[KVM_MEMORY_SLOTS +
					KVM_PRIVATE_MEM_SLOTS];
	/*
	 * Hash table of struct kvm_mmu_page.
	 */
	struct list_head active_mmu_pages;
	unsigned int n_free_mmu_pages;
	unsigned int n_requested_mmu_pages;
	unsigned int n_alloc_mmu_pages;
	struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
	struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
	struct list_head vm_list;
	struct file *filp;
	struct kvm_io_bus mmio_bus;
	struct kvm_io_bus pio_bus;
	struct kvm_pic *vpic;
	struct kvm_ioapic *vioapic;
	int round_robin_prev_vcpu;
	unsigned int tss_addr;
	struct page *apic_access_page;
	struct kvm_vm_stat stat;
};

static inline struct kvm_pic *pic_irqchip(struct kvm *kvm)
{
	return kvm->vpic;
}

static inline struct kvm_ioapic *ioapic_irqchip(struct kvm *kvm)
{
	return kvm->vioapic;
}

static inline int irqchip_in_kernel(struct kvm *kvm)
{
	return pic_irqchip(kvm) != NULL;
}

struct descriptor_table {
	u16 limit;
	unsigned long base;
} __attribute__((packed));

/* The guest did something we don't support. */
#define pr_unimpl(vcpu, fmt, ...)					\
 do {									\
	if (printk_ratelimit())						\
		printk(KERN_ERR "kvm: %i: cpu%i " fmt,			\
		       current->tgid, (vcpu)->vcpu_id , ## __VA_ARGS__); \
 } while (0)

#define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
#define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)

int kvm_vcpu_init(struct kvm_vcpu *vcpu, struct kvm *kvm, unsigned id);
void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);

void vcpu_load(struct kvm_vcpu *vcpu);
void vcpu_put(struct kvm_vcpu *vcpu);

void decache_vcpus_on_cpu(int cpu);


int kvm_init(void *opaque, unsigned int vcpu_size,
		  struct module *module);
void kvm_exit(void);

hpa_t gpa_to_hpa(struct kvm *kvm, gpa_t gpa);
#define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
#define HPA_ERR_MASK ((hpa_t)1 << HPA_MSB)
static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
hpa_t gva_to_hpa(struct kvm_vcpu *vcpu, gva_t gva);
struct page *gva_to_page(struct kvm_vcpu *vcpu, gva_t gva);

extern struct page *bad_page;

int is_error_page(struct page *page);
int kvm_is_error_hva(unsigned long addr);
int kvm_set_memory_region(struct kvm *kvm,
			  struct kvm_userspace_memory_region *mem,
			  int user_alloc);
int __kvm_set_memory_region(struct kvm *kvm,
			    struct kvm_userspace_memory_region *mem,
			    int user_alloc);
gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn);
struct page *gfn_to_page(struct kvm *kvm, gfn_t gfn);
void kvm_release_page(struct page *page);
int kvm_read_guest_page(struct kvm *kvm, gfn_t gfn, void *data, int offset,
			int len);
int kvm_read_guest(struct kvm *kvm, gpa_t gpa, void *data, unsigned long len);
int kvm_write_guest_page(struct kvm *kvm, gfn_t gfn, const void *data,
			 int offset, int len);
int kvm_write_guest(struct kvm *kvm, gpa_t gpa, const void *data,
		    unsigned long len);
int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
struct kvm_memory_slot *gfn_to_memslot(struct kvm *kvm, gfn_t gfn);
int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
void mark_page_dirty(struct kvm *kvm, gfn_t gfn);

void kvm_vcpu_block(struct kvm_vcpu *vcpu);
void kvm_resched(struct kvm_vcpu *vcpu);
void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
void kvm_flush_remote_tlbs(struct kvm *kvm);

long kvm_arch_dev_ioctl(struct file *filp,
			unsigned int ioctl, unsigned long arg);
long kvm_arch_vcpu_ioctl(struct file *filp,
			 unsigned int ioctl, unsigned long arg);
void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);

int kvm_dev_ioctl_check_extension(long ext);

int kvm_get_dirty_log(struct kvm *kvm,
			struct kvm_dirty_log *log, int *is_dirty);
int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
				struct kvm_dirty_log *log);

int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
				   struct
				   kvm_userspace_memory_region *mem,
				   int user_alloc);
long kvm_arch_vm_ioctl(struct file *filp,
		       unsigned int ioctl, unsigned long arg);
void kvm_arch_destroy_vm(struct kvm *kvm);

int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);
int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu);

int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
				    struct kvm_translation *tr);

int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs);
int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs);
int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
				  struct kvm_sregs *sregs);
int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
				    struct kvm_debug_guest *dbg);
int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);

int kvm_arch_init(void *opaque);
void kvm_arch_exit(void);

int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);

void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id);
void kvm_arch_vcpu_destory(struct kvm_vcpu *vcpu);

int kvm_arch_vcpu_reset(struct kvm_vcpu *vcpu);
void kvm_arch_hardware_enable(void *garbage);
void kvm_arch_hardware_disable(void *garbage);
int kvm_arch_hardware_setup(void);
void kvm_arch_hardware_unsetup(void);
void kvm_arch_check_processor_compat(void *rtn);

void kvm_free_physmem(struct kvm *kvm);

struct  kvm *kvm_arch_create_vm(void);
void kvm_arch_destroy_vm(struct kvm *kvm);

static inline void kvm_guest_enter(void)
{
	account_system_vtime(current);
	current->flags |= PF_VCPU;
}

static inline void kvm_guest_exit(void)
{
	account_system_vtime(current);
	current->flags &= ~PF_VCPU;
}

static inline int memslot_id(struct kvm *kvm, struct kvm_memory_slot *slot)
{
	return slot - kvm->memslots;
}


enum kvm_stat_kind {
	KVM_STAT_VM,
	KVM_STAT_VCPU,
};

struct kvm_stats_debugfs_item {
	const char *name;
	int offset;
	enum kvm_stat_kind kind;
	struct dentry *dentry;
};
extern struct kvm_stats_debugfs_item debugfs_entries[];

#endif
Commit	Line	Data
6aa8b732 AK	1	#ifndef __KVM_H
	2	#define __KVM_H
	3
	4	/*
	5	* This work is licensed under the terms of the GNU GPL, version 2. See
	6	* the COPYING file in the top-level directory.
	7	*/
	8
	9	#include <linux/types.h>
e56a7a28	10	#include <linux/hardirq.h>
6aa8b732 AK	11	#include <linux/list.h>
	12	#include <linux/mutex.h>
	13	#include <linux/spinlock.h>
06ff0d37 MR	14	#include <linux/signal.h>
06ff0d37 MR	15	#include <linux/sched.h>
6aa8b732	16	#include <linux/mm.h>
15ad7146	17	#include <linux/preempt.h>
e8edc6e0	18	#include <asm/signal.h>
6aa8b732	19
6aa8b732	20	#include <linux/kvm.h>
102d8325	21	#include <linux/kvm_para.h>
6aa8b732	22
ef9254df	23	#define KVM_MAX_VCPUS 4
e8207547	24	#define KVM_ALIAS_SLOTS 4
2e2c618d	25	#define KVM_MEMORY_SLOTS 8
e0d62c7f IE	26	/* memory slots that does not exposed to userspace */
e0d62c7f IE	27	#define KVM_PRIVATE_MEM_SLOTS 4
82ce2c96 IE	28	#define KVM_PERMILLE_MMU_PAGES 20
82ce2c96 IE	29	#define KVM_MIN_ALLOC_MMU_PAGES 64
7494c0cc	30	#define KVM_NUM_MMU_PAGES 1024
ebeace86 AK	31	#define KVM_MIN_FREE_MMU_PAGES 5
ebeace86 AK	32	#define KVM_REFILL_PAGES 25
06465c5a	33	#define KVM_MAX_CPUID_ENTRIES 40
6aa8b732	34
039576c0 AK	35	#define KVM_PIO_PAGE_OFFSET 1
039576c0 AK	36
d9e368d6 AK	37	/*
	38	* vcpu->requests bit members
	39	*/
3176bc3e	40	#define KVM_REQ_TLB_FLUSH 0
d9e368d6	41
6aa8b732 AK	42	/*
	43	* Address types:
	44	*
	45	* gva - guest virtual address
	46	* gpa - guest physical address
	47	* gfn - guest frame number
	48	* hva - host virtual address
	49	* hpa - host physical address
	50	* hfn - host frame number
	51	*/
	52
	53	typedef unsigned long gva_t;
	54	typedef u64 gpa_t;
	55	typedef unsigned long gfn_t;
	56
	57	typedef unsigned long hva_t;
	58	typedef u64 hpa_t;
	59	typedef unsigned long hfn_t;
	60
cea0f0e7 AK	61	#define NR_PTE_CHAIN_ENTRIES 5
	62
	63	struct kvm_pte_chain {
	64	u64 *parent_ptes[NR_PTE_CHAIN_ENTRIES];
	65	struct hlist_node link;
	66	};
	67
	68	/*
	69	* kvm_mmu_page_role, below, is defined as:
	70	*
	71	* bits 0:3 - total guest paging levels (2-4, or zero for real mode)
	72	* bits 4:7 - page table level for this shadow (1-4)
	73	* bits 8:9 - page table quadrant for 2-level guests
	74	* bit 16 - "metaphysical" - gfn is not a real page (huge page/real mode)
d55e2cb2	75	* bits 17:19 - "access" - the user, writable, and nx bits of a huge page pde
cea0f0e7 AK	76	*/
	77	union kvm_mmu_page_role {
	78	unsigned word;
	79	struct {
	80	unsigned glevels : 4;
	81	unsigned level : 4;
	82	unsigned quadrant : 2;
	83	unsigned pad_for_nice_hex_output : 6;
	84	unsigned metaphysical : 1;
d55e2cb2	85	unsigned hugepage_access : 3;
cea0f0e7 AK	86	};
	87	};
	88
6aa8b732 AK	89	struct kvm_mmu_page {
6aa8b732 AK	90	struct list_head link;
cea0f0e7 AK	91	struct hlist_node hash_link;
	92
	93	/*
	94	* The following two entries are used to key the shadow page in the
	95	* hash table.
	96	*/
	97	gfn_t gfn;
	98	union kvm_mmu_page_role role;
	99
47ad8e68	100	u64 *spt;
290fc38d IE	101	/* hold the gfn of each spte inside spt */
290fc38d IE	102	gfn_t *gfns;
6aa8b732 AK	103	unsigned long slot_bitmap; /* One bit set per slot which has memory
	104	* in this shadow page.
	105	*/
cea0f0e7	106	int multimapped; /* More than one parent_pte? */
3bb65a22	107	int root_count; /* Currently serving as active root */
cea0f0e7 AK	108	union {
	109	u64 parent_pte; / !multimapped */
	110	struct hlist_head parent_ptes; /* multimapped, kvm_pte_chain */
	111	};
6aa8b732 AK	112	};
6aa8b732 AK	113
6aa8b732	114	struct kvm_vcpu;
c16f862d	115	extern struct kmem_cache *kvm_vcpu_cache;
6aa8b732 AK	116
	117	/*
	118	* x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
	119	* 32-bit). The kvm_mmu structure abstracts the details of the current mmu
	120	* mode.
	121	*/
	122	struct kvm_mmu {
	123	void (new_cr3)(struct kvm_vcpu vcpu);
	124	int (page_fault)(struct kvm_vcpu vcpu, gva_t gva, u32 err);
6aa8b732 AK	125	void (free)(struct kvm_vcpu vcpu);
6aa8b732 AK	126	gpa_t (gva_to_gpa)(struct kvm_vcpu vcpu, gva_t gva);
c7addb90 AK	127	void (prefetch_page)(struct kvm_vcpu vcpu,
c7addb90 AK	128	struct kvm_mmu_page *page);
6aa8b732 AK	129	hpa_t root_hpa;
	130	int root_level;
	131	int shadow_root_level;
17ac10ad AK	132
17ac10ad AK	133	u64 *pae_root;
6aa8b732 AK	134	};
6aa8b732 AK	135
290fc38d	136	#define KVM_NR_MEM_OBJS 40
714b93da AK	137
	138	struct kvm_mmu_memory_cache {
	139	int nobjs;
	140	void *objects[KVM_NR_MEM_OBJS];
	141	};
	142
	143	/*
	144	* We don't want allocation failures within the mmu code, so we preallocate
	145	* enough memory for a single page fault in a cache.
	146	*/
6aa8b732 AK	147	struct kvm_guest_debug {
	148	int enabled;
	149	unsigned long bp[4];
	150	int singlestep;
	151	};
	152
039576c0 AK	153	struct kvm_pio_request {
	154	unsigned long count;
	155	int cur_count;
	156	struct page *guest_pages[2];
	157	unsigned guest_page_offset;
	158	int in;
74906345	159	int port;
039576c0 AK	160	int size;
	161	int string;
	162	int down;
	163	int rep;
	164	};
	165
ba1389b7	166	struct kvm_vcpu_stat {
1165f5fe AK	167	u32 pf_fixed;
	168	u32 pf_guest;
	169	u32 tlb_flush;
	170	u32 invlpg;
	171
	172	u32 exits;
	173	u32 io_exits;
	174	u32 mmio_exits;
	175	u32 signal_exits;
	176	u32 irq_window_exits;
	177	u32 halt_exits;
b6958ce4	178	u32 halt_wakeup;
1165f5fe AK	179	u32 request_irq_exits;
1165f5fe AK	180	u32 irq_exits;
e1beb1d3	181	u32 host_state_reload;
2cc51560	182	u32 efer_reload;
f096ed85	183	u32 fpu_reload;
f2b5756b AK	184	u32 insn_emulation;
f2b5756b AK	185	u32 insn_emulation_fail;
1165f5fe AK	186	};
1165f5fe AK	187
2eeb2e94 GH	188	struct kvm_io_device {
	189	void (read)(struct kvm_io_device this,
	190	gpa_t addr,
	191	int len,
	192	void *val);
	193	void (write)(struct kvm_io_device this,
	194	gpa_t addr,
	195	int len,
	196	const void *val);
	197	int (in_range)(struct kvm_io_device this, gpa_t addr);
	198	void (destructor)(struct kvm_io_device this);
	199
	200	void *private;
	201	};
	202
	203	static inline void kvm_iodevice_read(struct kvm_io_device *dev,
	204	gpa_t addr,
	205	int len,
	206	void *val)
	207	{
	208	dev->read(dev, addr, len, val);
	209	}
	210
	211	static inline void kvm_iodevice_write(struct kvm_io_device *dev,
	212	gpa_t addr,
	213	int len,
	214	const void *val)
	215	{
	216	dev->write(dev, addr, len, val);
	217	}
	218
	219	static inline int kvm_iodevice_inrange(struct kvm_io_device *dev, gpa_t addr)
	220	{
	221	return dev->in_range(dev, addr);
	222	}
	223
	224	static inline void kvm_iodevice_destructor(struct kvm_io_device *dev)
	225	{
74906345 ED	226	if (dev->destructor)
74906345 ED	227	dev->destructor(dev);
2eeb2e94 GH	228	}
	229
	230	/*
	231	* It would be nice to use something smarter than a linear search, TBD...
	232	* Thankfully we dont expect many devices to register (famous last words :),
	233	* so until then it will suffice. At least its abstracted so we can change
	234	* in one place.
	235	*/
	236	struct kvm_io_bus {
	237	int dev_count;
	238	#define NR_IOBUS_DEVS 6
	239	struct kvm_io_device *devs[NR_IOBUS_DEVS];
	240	};
	241
	242	void kvm_io_bus_init(struct kvm_io_bus *bus);
	243	void kvm_io_bus_destroy(struct kvm_io_bus *bus);
	244	struct kvm_io_device kvm_io_bus_find_dev(struct kvm_io_bus bus, gpa_t addr);
	245	void kvm_io_bus_register_dev(struct kvm_io_bus *bus,
	246	struct kvm_io_device *dev);
	247
34c16eec ZX	248	#ifdef CONFIG_HAS_IOMEM
	249	#define KVM_VCPU_MMIO \
	250	int mmio_needed; \
	251	int mmio_read_completed; \
	252	int mmio_is_write; \
	253	int mmio_size; \
	254	unsigned char mmio_data[8]; \
6aa8b732 AK	255	gpa_t mmio_phys_addr;
6aa8b732 AK	256
34c16eec ZX	257	#else
34c16eec ZX	258	#define KVM_VCPU_MMIO
1961d276	259
34c16eec	260	#endif
1165f5fe	261
34c16eec ZX	262	#define KVM_VCPU_COMM \
	263	struct kvm *kvm; \
	264	struct preempt_notifier preempt_notifier; \
	265	int vcpu_id; \
	266	struct mutex mutex; \
	267	int cpu; \
	268	struct kvm_run *run; \
	269	int guest_mode; \
	270	unsigned long requests; \
	271	struct kvm_guest_debug guest_debug; \
	272	int fpu_active; \
	273	int guest_fpu_loaded; \
	274	wait_queue_head_t wq; \
	275	int sigset_active; \
	276	sigset_t sigset; \
ba1389b7	277	struct kvm_vcpu_stat stat; \
34c16eec	278	KVM_VCPU_MMIO
6aa8b732	279
e8207547 AK	280	struct kvm_mem_alias {
	281	gfn_t base_gfn;
	282	unsigned long npages;
	283	gfn_t target_gfn;
	284	};
	285
6aa8b732 AK	286	struct kvm_memory_slot {
	287	gfn_t base_gfn;
	288	unsigned long npages;
	289	unsigned long flags;
290fc38d	290	unsigned long *rmap;
6aa8b732	291	unsigned long *dirty_bitmap;
8a7ae055	292	unsigned long userspace_addr;
80b14b5b	293	int user_alloc;
6aa8b732 AK	294	};
6aa8b732 AK	295
ba1389b7	296	struct kvm_vm_stat {
4cee5764 AK	297	u32 mmu_shadow_zapped;
	298	u32 mmu_pte_write;
	299	u32 mmu_pte_updated;
	300	u32 mmu_pde_zapped;
	301	u32 mmu_flooded;
	302	u32 mmu_recycled;
ba1389b7 AK	303	};
ba1389b7 AK	304
6aa8b732	305	struct kvm {
11ec2804	306	struct mutex lock; /* protects everything except vcpus */
e8207547 AK	307	int naliases;
e8207547 AK	308	struct kvm_mem_alias aliases[KVM_ALIAS_SLOTS];
6aa8b732	309	int nmemslots;
e0d62c7f IE	310	struct kvm_memory_slot memslots[KVM_MEMORY_SLOTS +
e0d62c7f IE	311	KVM_PRIVATE_MEM_SLOTS];
cea0f0e7 AK	312	/*
	313	* Hash table of struct kvm_mmu_page.
	314	*/
6aa8b732	315	struct list_head active_mmu_pages;
82ce2c96 IE	316	unsigned int n_free_mmu_pages;
	317	unsigned int n_requested_mmu_pages;
	318	unsigned int n_alloc_mmu_pages;
cea0f0e7	319	struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
fb3f0f51	320	struct kvm_vcpu *vcpus[KVM_MAX_VCPUS];
133de902	321	struct list_head vm_list;
bccf2150	322	struct file *filp;
2eeb2e94	323	struct kvm_io_bus mmio_bus;
74906345	324	struct kvm_io_bus pio_bus;
85f455f7	325	struct kvm_pic *vpic;
1fd4f2a5	326	struct kvm_ioapic *vioapic;
932f72ad	327	int round_robin_prev_vcpu;
cbc94022	328	unsigned int tss_addr;
f78e0e2e	329	struct page *apic_access_page;
ba1389b7	330	struct kvm_vm_stat stat;
6aa8b732 AK	331	};
6aa8b732 AK	332
85f455f7 ED	333	static inline struct kvm_pic pic_irqchip(struct kvm kvm)
	334	{
	335	return kvm->vpic;
	336	}
	337
1fd4f2a5 ED	338	static inline struct kvm_ioapic ioapic_irqchip(struct kvm kvm)
	339	{
	340	return kvm->vioapic;
	341	}
	342
85f455f7 ED	343	static inline int irqchip_in_kernel(struct kvm *kvm)
85f455f7 ED	344	{
56919c5c	345	return pic_irqchip(kvm) != NULL;
85f455f7 ED	346	}
85f455f7 ED	347
6aa8b732 AK	348	struct descriptor_table {
	349	u16 limit;
	350	unsigned long base;
	351	} __attribute__((packed));
	352
f0242478 RR	353	/* The guest did something we don't support. */
	354	#define pr_unimpl(vcpu, fmt, ...) \
	355	do { \
	356	if (printk_ratelimit()) \
	357	printk(KERN_ERR "kvm: %i: cpu%i " fmt, \
	358	current->tgid, (vcpu)->vcpu_id , ## __VA_ARGS__); \
d77c26fc	359	} while (0)
f0242478	360
6aa8b732 AK	361	#define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
	362	#define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)
	363
fb3f0f51 RR	364	int kvm_vcpu_init(struct kvm_vcpu vcpu, struct kvm kvm, unsigned id);
	365	void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
	366
313a3dc7 CO	367	void vcpu_load(struct kvm_vcpu *vcpu);
	368	void vcpu_put(struct kvm_vcpu *vcpu);
	369
e9b11c17 ZX	370	void decache_vcpus_on_cpu(int cpu);
e9b11c17 ZX	371
313a3dc7	372
f8c16bba	373	int kvm_init(void *opaque, unsigned int vcpu_size,
c16f862d	374	struct module *module);
cb498ea2	375	void kvm_exit(void);
6aa8b732	376
4a4c9924	377	hpa_t gpa_to_hpa(struct kvm *kvm, gpa_t gpa);
6aa8b732 AK	378	#define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
	379	#define HPA_ERR_MASK ((hpa_t)1 << HPA_MSB)
	380	static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
	381	hpa_t gva_to_hpa(struct kvm_vcpu *vcpu, gva_t gva);
039576c0	382	struct page gva_to_page(struct kvm_vcpu vcpu, gva_t gva);
6aa8b732	383
cea7bb21	384	extern struct page *bad_page;
6aa8b732	385
cea7bb21	386	int is_error_page(struct page *page);
f9d46eb0	387	int kvm_is_error_hva(unsigned long addr);
210c7c4d IE	388	int kvm_set_memory_region(struct kvm *kvm,
	389	struct kvm_userspace_memory_region *mem,
	390	int user_alloc);
f78e0e2e SY	391	int __kvm_set_memory_region(struct kvm *kvm,
	392	struct kvm_userspace_memory_region *mem,
	393	int user_alloc);
290fc38d	394	gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn);
954bbbc2	395	struct page gfn_to_page(struct kvm kvm, gfn_t gfn);
8a7ae055	396	void kvm_release_page(struct page *page);
195aefde IE	397	int kvm_read_guest_page(struct kvm kvm, gfn_t gfn, void data, int offset,
	398	int len);
	399	int kvm_read_guest(struct kvm kvm, gpa_t gpa, void data, unsigned long len);
	400	int kvm_write_guest_page(struct kvm kvm, gfn_t gfn, const void data,
	401	int offset, int len);
	402	int kvm_write_guest(struct kvm kvm, gpa_t gpa, const void data,
	403	unsigned long len);
	404	int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
	405	int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
6aa8b732	406	struct kvm_memory_slot gfn_to_memslot(struct kvm kvm, gfn_t gfn);
e0d62c7f	407	int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
6aa8b732 AK	408	void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
6aa8b732 AK	409
8776e519	410	void kvm_vcpu_block(struct kvm_vcpu *vcpu);
6aa8b732	411	void kvm_resched(struct kvm_vcpu *vcpu);
7702fd1f AK	412	void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
7702fd1f AK	413	void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
d9e368d6	414	void kvm_flush_remote_tlbs(struct kvm *kvm);
6aa8b732	415
043405e1 CO	416	long kvm_arch_dev_ioctl(struct file *filp,
043405e1 CO	417	unsigned int ioctl, unsigned long arg);
313a3dc7 CO	418	long kvm_arch_vcpu_ioctl(struct file *filp,
	419	unsigned int ioctl, unsigned long arg);
	420	void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
	421	void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
018d00d2 ZX	422
	423	int kvm_dev_ioctl_check_extension(long ext);
	424
5bb064dc ZX	425	int kvm_get_dirty_log(struct kvm *kvm,
	426	struct kvm_dirty_log log, int is_dirty);
	427	int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
	428	struct kvm_dirty_log *log);
	429
1fe779f8 CO	430	int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
	431	struct
	432	kvm_userspace_memory_region *mem,
	433	int user_alloc);
	434	long kvm_arch_vm_ioctl(struct file *filp,
	435	unsigned int ioctl, unsigned long arg);
	436	void kvm_arch_destroy_vm(struct kvm *kvm);
313a3dc7	437
d0752060 HB	438	int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu vcpu, struct kvm_fpu fpu);
	439	int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu vcpu, struct kvm_fpu fpu);
	440
8b006791 ZX	441	int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
	442	struct kvm_translation *tr);
	443
b6c7a5dc HB	444	int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu vcpu, struct kvm_regs regs);
	445	int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu vcpu, struct kvm_regs regs);
	446	int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
	447	struct kvm_sregs *sregs);
	448	int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
	449	struct kvm_sregs *sregs);
	450	int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
	451	struct kvm_debug_guest *dbg);
	452	int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu vcpu, struct kvm_run kvm_run);
	453
f8c16bba ZX	454	int kvm_arch_init(void *opaque);
f8c16bba ZX	455	void kvm_arch_exit(void);
043405e1	456
e9b11c17 ZX	457	int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
	458	void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);
	459
	460	void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
	461	void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
	462	void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
	463	struct kvm_vcpu kvm_arch_vcpu_create(struct kvm kvm, unsigned int id);
	464	void kvm_arch_vcpu_destory(struct kvm_vcpu *vcpu);
	465
	466	int kvm_arch_vcpu_reset(struct kvm_vcpu *vcpu);
	467	void kvm_arch_hardware_enable(void *garbage);
	468	void kvm_arch_hardware_disable(void *garbage);
	469	int kvm_arch_hardware_setup(void);
	470	void kvm_arch_hardware_unsetup(void);
	471	void kvm_arch_check_processor_compat(void *rtn);
	472
d19a9cd2 ZX	473	void kvm_free_physmem(struct kvm *kvm);
	474
	475	struct kvm *kvm_arch_create_vm(void);
	476	void kvm_arch_destroy_vm(struct kvm *kvm);
e9b11c17	477
d172fcd3 LV	478	static inline void kvm_guest_enter(void)
d172fcd3 LV	479	{
e56a7a28	480	account_system_vtime(current);
d172fcd3 LV	481	current->flags \|= PF_VCPU;
	482	}
	483
	484	static inline void kvm_guest_exit(void)
	485	{
e56a7a28	486	account_system_vtime(current);
d172fcd3 LV	487	current->flags &= ~PF_VCPU;
	488	}
	489
6aa8b732 AK	490	static inline int memslot_id(struct kvm kvm, struct kvm_memory_slot slot)
	491	{
	492	return slot - kvm->memslots;
	493	}
	494
6aa8b732	495
ba1389b7 AK	496	enum kvm_stat_kind {
	497	KVM_STAT_VM,
	498	KVM_STAT_VCPU,
	499	};
	500
417bc304 HB	501	struct kvm_stats_debugfs_item {
	502	const char *name;
	503	int offset;
ba1389b7	504	enum kvm_stat_kind kind;
417bc304 HB	505	struct dentry *dentry;
	506	};
	507	extern struct kvm_stats_debugfs_item debugfs_entries[];
	508
6aa8b732	509	#endif