[GitHub/mt8127/android_kernel_alcatel_ttab.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>

#include "types.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

#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 - common access permissions for all ptes in this shadow page
 */
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 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

/*
 * 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_mmu_memory_cache {
	int nobjs;
	void *objects[KVM_NR_MEM_OBJS];
};

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;
};

/*
 * 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;
	u32 remote_tlb_flush;
};

struct kvm {
	struct mutex lock; /* protects everything except vcpus */
	struct mm_struct *mm; /* userspace tied to this vm */
	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;
};

/* 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);

#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; }
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);
int kvm_arch_set_memory_region(struct kvm *kvm,
				struct kvm_userspace_memory_region *mem,
				struct kvm_memory_slot old,
				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_clean(struct page *page);
void kvm_release_page_dirty(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);
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
void kvm_arch_vcpu_destroy(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);

int kvm_cpu_get_interrupt(struct kvm_vcpu *v);
int kvm_cpu_has_interrupt(struct kvm_vcpu *v);

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;
}

static inline gpa_t gfn_to_gpa(gfn_t gfn)
{
	return (gpa_t)gfn << PAGE_SHIFT;
}

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[];

#if defined(CONFIG_X86)
#include "x86.h"
#endif

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