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

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

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

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

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
85f455f7 ED	276	static inline struct kvm_pic pic_irqchip(struct kvm kvm)
	277	{
	278	return kvm->vpic;
	279	}
	280
1fd4f2a5 ED	281	static inline struct kvm_ioapic ioapic_irqchip(struct kvm kvm)
	282	{
	283	return kvm->vioapic;
	284	}
	285
85f455f7 ED	286	static inline int irqchip_in_kernel(struct kvm *kvm)
85f455f7 ED	287	{
56919c5c	288	return pic_irqchip(kvm) != NULL;
85f455f7 ED	289	}
85f455f7 ED	290
f0242478 RR	291	/* The guest did something we don't support. */
	292	#define pr_unimpl(vcpu, fmt, ...) \
	293	do { \
	294	if (printk_ratelimit()) \
	295	printk(KERN_ERR "kvm: %i: cpu%i " fmt, \
	296	current->tgid, (vcpu)->vcpu_id , ## __VA_ARGS__); \
d77c26fc	297	} while (0)
f0242478	298
6aa8b732 AK	299	#define kvm_printf(kvm, fmt ...) printk(KERN_DEBUG fmt)
	300	#define vcpu_printf(vcpu, fmt...) kvm_printf(vcpu->kvm, fmt)
	301
fb3f0f51 RR	302	int kvm_vcpu_init(struct kvm_vcpu vcpu, struct kvm kvm, unsigned id);
	303	void kvm_vcpu_uninit(struct kvm_vcpu *vcpu);
	304
313a3dc7 CO	305	void vcpu_load(struct kvm_vcpu *vcpu);
	306	void vcpu_put(struct kvm_vcpu *vcpu);
	307
e9b11c17 ZX	308	void decache_vcpus_on_cpu(int cpu);
e9b11c17 ZX	309
313a3dc7	310
f8c16bba	311	int kvm_init(void *opaque, unsigned int vcpu_size,
c16f862d	312	struct module *module);
cb498ea2	313	void kvm_exit(void);
6aa8b732	314
6aa8b732 AK	315	#define HPA_MSB ((sizeof(hpa_t) * 8) - 1)
	316	#define HPA_ERR_MASK ((hpa_t)1 << HPA_MSB)
	317	static inline int is_error_hpa(hpa_t hpa) { return hpa >> HPA_MSB; }
039576c0	318	struct page gva_to_page(struct kvm_vcpu vcpu, gva_t gva);
6aa8b732	319
cea7bb21	320	extern struct page *bad_page;
6aa8b732	321
cea7bb21	322	int is_error_page(struct page *page);
f9d46eb0	323	int kvm_is_error_hva(unsigned long addr);
210c7c4d IE	324	int kvm_set_memory_region(struct kvm *kvm,
	325	struct kvm_userspace_memory_region *mem,
	326	int user_alloc);
f78e0e2e SY	327	int __kvm_set_memory_region(struct kvm *kvm,
	328	struct kvm_userspace_memory_region *mem,
	329	int user_alloc);
0de10343 ZX	330	int kvm_arch_set_memory_region(struct kvm *kvm,
	331	struct kvm_userspace_memory_region *mem,
	332	struct kvm_memory_slot old,
	333	int user_alloc);
290fc38d	334	gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn);
954bbbc2	335	struct page gfn_to_page(struct kvm kvm, gfn_t gfn);
b4231d61 IE	336	void kvm_release_page_clean(struct page *page);
b4231d61 IE	337	void kvm_release_page_dirty(struct page *page);
195aefde IE	338	int kvm_read_guest_page(struct kvm kvm, gfn_t gfn, void data, int offset,
	339	int len);
	340	int kvm_read_guest(struct kvm kvm, gpa_t gpa, void data, unsigned long len);
	341	int kvm_write_guest_page(struct kvm kvm, gfn_t gfn, const void data,
	342	int offset, int len);
	343	int kvm_write_guest(struct kvm kvm, gpa_t gpa, const void data,
	344	unsigned long len);
	345	int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
	346	int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
6aa8b732	347	struct kvm_memory_slot gfn_to_memslot(struct kvm kvm, gfn_t gfn);
e0d62c7f	348	int kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
6aa8b732 AK	349	void mark_page_dirty(struct kvm *kvm, gfn_t gfn);
6aa8b732 AK	350
8776e519	351	void kvm_vcpu_block(struct kvm_vcpu *vcpu);
6aa8b732	352	void kvm_resched(struct kvm_vcpu *vcpu);
7702fd1f AK	353	void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
7702fd1f AK	354	void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
d9e368d6	355	void kvm_flush_remote_tlbs(struct kvm *kvm);
6aa8b732	356
043405e1 CO	357	long kvm_arch_dev_ioctl(struct file *filp,
043405e1 CO	358	unsigned int ioctl, unsigned long arg);
313a3dc7 CO	359	long kvm_arch_vcpu_ioctl(struct file *filp,
	360	unsigned int ioctl, unsigned long arg);
	361	void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
	362	void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
018d00d2 ZX	363
	364	int kvm_dev_ioctl_check_extension(long ext);
	365
5bb064dc ZX	366	int kvm_get_dirty_log(struct kvm *kvm,
	367	struct kvm_dirty_log log, int is_dirty);
	368	int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
	369	struct kvm_dirty_log *log);
	370
1fe779f8 CO	371	int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
	372	struct
	373	kvm_userspace_memory_region *mem,
	374	int user_alloc);
	375	long kvm_arch_vm_ioctl(struct file *filp,
	376	unsigned int ioctl, unsigned long arg);
	377	void kvm_arch_destroy_vm(struct kvm *kvm);
313a3dc7	378
d0752060 HB	379	int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu vcpu, struct kvm_fpu fpu);
	380	int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu vcpu, struct kvm_fpu fpu);
	381
8b006791 ZX	382	int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
	383	struct kvm_translation *tr);
	384
b6c7a5dc HB	385	int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu vcpu, struct kvm_regs regs);
	386	int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu vcpu, struct kvm_regs regs);
	387	int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
	388	struct kvm_sregs *sregs);
	389	int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
	390	struct kvm_sregs *sregs);
	391	int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu,
	392	struct kvm_debug_guest *dbg);
	393	int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu vcpu, struct kvm_run kvm_run);
	394
f8c16bba ZX	395	int kvm_arch_init(void *opaque);
f8c16bba ZX	396	void kvm_arch_exit(void);
043405e1	397
e9b11c17 ZX	398	int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu);
	399	void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu);
	400
	401	void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu);
	402	void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
	403	void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
	404	struct kvm_vcpu kvm_arch_vcpu_create(struct kvm kvm, unsigned int id);
26e5215f	405	int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
d40ccc62	406	void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
e9b11c17 ZX	407
	408	int kvm_arch_vcpu_reset(struct kvm_vcpu *vcpu);
	409	void kvm_arch_hardware_enable(void *garbage);
	410	void kvm_arch_hardware_disable(void *garbage);
	411	int kvm_arch_hardware_setup(void);
	412	void kvm_arch_hardware_unsetup(void);
	413	void kvm_arch_check_processor_compat(void *rtn);
	414
d19a9cd2 ZX	415	void kvm_free_physmem(struct kvm *kvm);
	416
	417	struct kvm *kvm_arch_create_vm(void);
	418	void kvm_arch_destroy_vm(struct kvm *kvm);
e9b11c17	419
d172fcd3 LV	420	static inline void kvm_guest_enter(void)
d172fcd3 LV	421	{
e56a7a28	422	account_system_vtime(current);
d172fcd3 LV	423	current->flags \|= PF_VCPU;
	424	}
	425
	426	static inline void kvm_guest_exit(void)
	427	{
e56a7a28	428	account_system_vtime(current);
d172fcd3 LV	429	current->flags &= ~PF_VCPU;
	430	}
	431
6aa8b732 AK	432	static inline int memslot_id(struct kvm kvm, struct kvm_memory_slot slot)
	433	{
	434	return slot - kvm->memslots;
	435	}
	436
1755fbcc AK	437	static inline gpa_t gfn_to_gpa(gfn_t gfn)
	438	{
	439	return (gpa_t)gfn << PAGE_SHIFT;
	440	}
6aa8b732	441
ba1389b7 AK	442	enum kvm_stat_kind {
	443	KVM_STAT_VM,
	444	KVM_STAT_VCPU,
	445	};
	446
417bc304 HB	447	struct kvm_stats_debugfs_item {
	448	const char *name;
	449	int offset;
ba1389b7	450	enum kvm_stat_kind kind;
417bc304 HB	451	struct dentry *dentry;
	452	};
	453	extern struct kvm_stats_debugfs_item debugfs_entries[];
	454
e01a1b57 HB	455	#if defined(CONFIG_X86)
	456	#include "x86.h"
	457	#endif
	458
6aa8b732	459	#endif