blob: 531f47cbf1f826950ec8afa62fb98320ac63aabf [file] [log] [blame]
Vegard Nossuma656c8e2008-07-22 21:27:11 +02001/*
Carsten Otte043405e2007-10-10 17:16:19 +02002 * Kernel-based Virtual Machine driver for Linux
3 *
4 * This header defines architecture specific interfaces, x86 version
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2. See
7 * the COPYING file in the top-level directory.
8 *
9 */
10
H. Peter Anvin1965aae2008-10-22 22:26:29 -070011#ifndef _ASM_X86_KVM_HOST_H
12#define _ASM_X86_KVM_HOST_H
Carsten Otte043405e2007-10-10 17:16:19 +020013
Zhang Xiantao34c16ee2007-10-20 15:34:38 +080014#include <linux/types.h>
15#include <linux/mm.h>
Andrea Arcangelie930bff2008-07-25 16:24:52 +020016#include <linux/mmu_notifier.h>
Marcelo Tosatti229456f2009-06-17 09:22:14 -030017#include <linux/tracepoint.h>
Sheng Yangf5f48ee2010-06-30 12:25:15 +080018#include <linux/cpumask.h>
Gleb Natapovf5132b02011-11-10 14:57:22 +020019#include <linux/irq_work.h>
Zhang Xiantao34c16ee2007-10-20 15:34:38 +080020
21#include <linux/kvm.h>
22#include <linux/kvm_para.h>
Avi Kivityedf88412007-12-16 11:02:48 +020023#include <linux/kvm_types.h>
Gleb Natapovf5132b02011-11-10 14:57:22 +020024#include <linux/perf_event.h>
Marcelo Tosattid8281992012-11-27 23:29:01 -020025#include <linux/pvclock_gtod.h>
26#include <linux/clocksource.h>
Zhang Xiantao34c16ee2007-10-20 15:34:38 +080027
Gerd Hoffmann50d0a0f2008-06-03 16:17:31 +020028#include <asm/pvclock-abi.h>
Hollis Blancharde01a1b52007-12-03 15:30:25 -060029#include <asm/desc.h>
Sheng Yang0bed3b52008-10-09 16:01:54 +080030#include <asm/mtrr.h>
Alexander Graf9962d032008-11-25 20:17:02 +010031#include <asm/msr-index.h>
H. Peter Anvin3ee89722012-04-20 13:41:59 -070032#include <asm/asm.h>
Hollis Blancharde01a1b52007-12-03 15:30:25 -060033
Chegu Vinodcbf64352013-04-27 18:31:04 -070034#define KVM_MAX_VCPUS 255
Marcelo Tosattia59cb292012-02-03 12:28:31 -020035#define KVM_SOFT_MAX_VCPUS 160
Alex Williamson0f888f52012-12-10 10:33:38 -070036#define KVM_USER_MEM_SLOTS 125
Alex Williamson07432472012-12-10 10:33:15 -070037/* memory slots that are not exposed to userspace */
38#define KVM_PRIVATE_MEM_SLOTS 3
Alex Williamsonbbacc0c2012-12-10 10:33:09 -070039#define KVM_MEM_SLOTS_NUM (KVM_USER_MEM_SLOTS + KVM_PRIVATE_MEM_SLOTS)
Xiao Guangrong93a5cef2011-11-24 17:37:48 +080040
Avi Kivitycef4dea2010-01-20 12:01:20 +020041#define KVM_MMIO_SIZE 16
Avi Kivity69a9f692008-03-21 12:38:23 +020042
43#define KVM_PIO_PAGE_OFFSET 1
Laurent Vivier542472b2008-05-30 16:05:55 +020044#define KVM_COALESCED_MMIO_PAGE_OFFSET 2
Avi Kivity69a9f692008-03-21 12:38:23 +020045
Alexander Graf8175e5b2013-04-15 10:42:33 +020046#define KVM_IRQCHIP_NUM_PINS KVM_IOAPIC_NUM_PINS
47
Joerg Roedelcfec82c2011-04-04 12:39:28 +020048#define CR0_RESERVED_BITS \
49 (~(unsigned long)(X86_CR0_PE | X86_CR0_MP | X86_CR0_EM | X86_CR0_TS \
50 | X86_CR0_ET | X86_CR0_NE | X86_CR0_WP | X86_CR0_AM \
51 | X86_CR0_NW | X86_CR0_CD | X86_CR0_PG))
52
Zhang Xiantaocd6e8f82007-11-19 14:33:37 +080053#define CR3_PAE_RESERVED_BITS ((X86_CR3_PWT | X86_CR3_PCD) - 1)
54#define CR3_NONPAE_RESERVED_BITS ((PAGE_SIZE-1) & ~(X86_CR3_PWT | X86_CR3_PCD))
Mao, Junjiead756a12012-07-02 01:18:48 +000055#define CR3_PCID_ENABLED_RESERVED_BITS 0xFFFFFF0000000000ULL
Joe Perches7d76b4d2008-03-23 01:02:34 -070056#define CR3_L_MODE_RESERVED_BITS (CR3_NONPAE_RESERVED_BITS | \
57 0xFFFFFF0000000000ULL)
Joerg Roedelcfec82c2011-04-04 12:39:28 +020058#define CR4_RESERVED_BITS \
59 (~(unsigned long)(X86_CR4_VME | X86_CR4_PVI | X86_CR4_TSD | X86_CR4_DE\
60 | X86_CR4_PSE | X86_CR4_PAE | X86_CR4_MCE \
Mao, Junjiead756a12012-07-02 01:18:48 +000061 | X86_CR4_PGE | X86_CR4_PCE | X86_CR4_OSFXSR | X86_CR4_PCIDE \
H. Peter Anvinafcbf132013-04-27 16:37:47 -070062 | X86_CR4_OSXSAVE | X86_CR4_SMEP | X86_CR4_FSGSBASE \
Joerg Roedelcfec82c2011-04-04 12:39:28 +020063 | X86_CR4_OSXMMEXCPT | X86_CR4_VMXE))
64
65#define CR8_RESERVED_BITS (~(unsigned long)X86_CR8_TPR)
66
67
Zhang Xiantaocd6e8f82007-11-19 14:33:37 +080068
Zhang Xiantaocd6e8f82007-11-19 14:33:37 +080069#define INVALID_PAGE (~(hpa_t)0)
Xiao Guangrongdd180b32010-07-03 16:02:42 +080070#define VALID_PAGE(x) ((x) != INVALID_PAGE)
71
Zhang Xiantaocd6e8f82007-11-19 14:33:37 +080072#define UNMAPPED_GVA (~(gpa_t)0)
73
Joerg Roedelec04b262009-06-19 15:16:23 +020074/* KVM Hugepage definitions for x86 */
Joerg Roedel04326ca2009-07-27 16:30:47 +020075#define KVM_NR_PAGE_SIZES 3
Joerg Roedel82855412010-07-01 16:00:11 +020076#define KVM_HPAGE_GFN_SHIFT(x) (((x) - 1) * 9)
77#define KVM_HPAGE_SHIFT(x) (PAGE_SHIFT + KVM_HPAGE_GFN_SHIFT(x))
Joerg Roedelec04b262009-06-19 15:16:23 +020078#define KVM_HPAGE_SIZE(x) (1UL << KVM_HPAGE_SHIFT(x))
79#define KVM_HPAGE_MASK(x) (~(KVM_HPAGE_SIZE(x) - 1))
80#define KVM_PAGES_PER_HPAGE(x) (KVM_HPAGE_SIZE(x) / PAGE_SIZE)
Marcelo Tosatti05da4552008-02-23 11:44:30 -030081
Zhang Xiantaocd6e8f82007-11-19 14:33:37 +080082#define SELECTOR_TI_MASK (1 << 2)
83#define SELECTOR_RPL_MASK 0x03
84
85#define IOPL_SHIFT 12
86
Zhang Xiantaod657a982007-12-14 09:41:22 +080087#define KVM_PERMILLE_MMU_PAGES 20
88#define KVM_MIN_ALLOC_MMU_PAGES 64
Dong, Eddie1ae0a132008-01-07 13:20:25 +020089#define KVM_MMU_HASH_SHIFT 10
90#define KVM_NUM_MMU_PAGES (1 << KVM_MMU_HASH_SHIFT)
Zhang Xiantaod657a982007-12-14 09:41:22 +080091#define KVM_MIN_FREE_MMU_PAGES 5
92#define KVM_REFILL_PAGES 25
Andre Przywara73c11602010-12-01 12:17:44 +010093#define KVM_MAX_CPUID_ENTRIES 80
Sheng Yang0bed3b52008-10-09 16:01:54 +080094#define KVM_NR_FIXED_MTRR_REGION 88
Avi Kivity9ba075a2008-05-26 20:06:35 +030095#define KVM_NR_VAR_MTRR 8
Zhang Xiantaod657a982007-12-14 09:41:22 +080096
Gleb Natapovaf585b92010-10-14 11:22:46 +020097#define ASYNC_PF_PER_VCPU 64
98
Zhang Xiantaod657a982007-12-14 09:41:22 +080099struct kvm_vcpu;
100struct kvm;
Gleb Natapovaf585b92010-10-14 11:22:46 +0200101struct kvm_async_pf;
Zhang Xiantaod657a982007-12-14 09:41:22 +0800102
Marcelo Tosatti5fdbf972008-06-27 14:58:02 -0300103enum kvm_reg {
Zhang Xiantao2b3ccfa2007-11-19 14:56:05 +0800104 VCPU_REGS_RAX = 0,
105 VCPU_REGS_RCX = 1,
106 VCPU_REGS_RDX = 2,
107 VCPU_REGS_RBX = 3,
108 VCPU_REGS_RSP = 4,
109 VCPU_REGS_RBP = 5,
110 VCPU_REGS_RSI = 6,
111 VCPU_REGS_RDI = 7,
112#ifdef CONFIG_X86_64
113 VCPU_REGS_R8 = 8,
114 VCPU_REGS_R9 = 9,
115 VCPU_REGS_R10 = 10,
116 VCPU_REGS_R11 = 11,
117 VCPU_REGS_R12 = 12,
118 VCPU_REGS_R13 = 13,
119 VCPU_REGS_R14 = 14,
120 VCPU_REGS_R15 = 15,
121#endif
Marcelo Tosatti5fdbf972008-06-27 14:58:02 -0300122 VCPU_REGS_RIP,
Zhang Xiantao2b3ccfa2007-11-19 14:56:05 +0800123 NR_VCPU_REGS
124};
125
Avi Kivity6de4f3a2009-05-31 22:58:47 +0300126enum kvm_reg_ex {
127 VCPU_EXREG_PDPTR = NR_VCPU_REGS,
Avi Kivityaff48ba2010-12-05 18:56:11 +0200128 VCPU_EXREG_CR3,
Avi Kivity6de12732011-03-07 12:51:22 +0200129 VCPU_EXREG_RFLAGS,
Avi Kivity69c73022011-03-07 15:26:44 +0200130 VCPU_EXREG_CPL,
Avi Kivity2fb92db2011-04-27 19:42:18 +0300131 VCPU_EXREG_SEGMENTS,
Avi Kivity6de4f3a2009-05-31 22:58:47 +0300132};
133
Zhang Xiantao2b3ccfa2007-11-19 14:56:05 +0800134enum {
Zhang Xiantao2b3ccfa2007-11-19 14:56:05 +0800135 VCPU_SREG_ES,
Avi Kivity81609e32008-05-27 16:26:01 +0300136 VCPU_SREG_CS,
137 VCPU_SREG_SS,
138 VCPU_SREG_DS,
Zhang Xiantao2b3ccfa2007-11-19 14:56:05 +0800139 VCPU_SREG_FS,
140 VCPU_SREG_GS,
Zhang Xiantao2b3ccfa2007-11-19 14:56:05 +0800141 VCPU_SREG_TR,
142 VCPU_SREG_LDTR,
143};
144
Avi Kivity56e82312009-08-12 15:04:37 +0300145#include <asm/kvm_emulate.h>
Zhang Xiantao2b3ccfa2007-11-19 14:56:05 +0800146
Zhang Xiantaod657a982007-12-14 09:41:22 +0800147#define KVM_NR_MEM_OBJS 40
148
Jan Kiszka42dbaa52008-12-15 13:52:10 +0100149#define KVM_NR_DB_REGS 4
150
151#define DR6_BD (1 << 13)
152#define DR6_BS (1 << 14)
153#define DR6_FIXED_1 0xffff0ff0
154#define DR6_VOLATILE 0x0000e00f
155
156#define DR7_BP_EN_MASK 0x000000ff
157#define DR7_GE (1 << 9)
158#define DR7_GD (1 << 13)
159#define DR7_FIXED_1 0x00000400
160#define DR7_VOLATILE 0xffff23ff
161
Gleb Natapov41383772012-04-19 14:06:29 +0300162/* apic attention bits */
163#define KVM_APIC_CHECK_VAPIC 0
Michael S. Tsirkinae7a2a32012-06-24 19:25:07 +0300164/*
165 * The following bit is set with PV-EOI, unset on EOI.
166 * We detect PV-EOI changes by guest by comparing
167 * this bit with PV-EOI in guest memory.
168 * See the implementation in apic_update_pv_eoi.
169 */
170#define KVM_APIC_PV_EOI_PENDING 1
Gleb Natapov41383772012-04-19 14:06:29 +0300171
Zhang Xiantaod657a982007-12-14 09:41:22 +0800172/*
173 * We don't want allocation failures within the mmu code, so we preallocate
174 * enough memory for a single page fault in a cache.
175 */
176struct kvm_mmu_memory_cache {
177 int nobjs;
178 void *objects[KVM_NR_MEM_OBJS];
179};
180
Zhang Xiantaod657a982007-12-14 09:41:22 +0800181/*
182 * kvm_mmu_page_role, below, is defined as:
183 *
184 * bits 0:3 - total guest paging levels (2-4, or zero for real mode)
185 * bits 4:7 - page table level for this shadow (1-4)
186 * bits 8:9 - page table quadrant for 2-level guests
Avi Kivityf6e2c02b2009-01-11 13:02:10 +0200187 * bit 16 - direct mapping of virtual to physical mapping at gfn
188 * used for real mode and two-dimensional paging
Zhang Xiantaod657a982007-12-14 09:41:22 +0800189 * bits 17:19 - common access permissions for all ptes in this shadow page
190 */
191union kvm_mmu_page_role {
192 unsigned word;
193 struct {
Joe Perches7d76b4d2008-03-23 01:02:34 -0700194 unsigned level:4;
Avi Kivity5b7e0102010-04-14 19:20:03 +0300195 unsigned cr4_pae:1;
Joe Perches7d76b4d2008-03-23 01:02:34 -0700196 unsigned quadrant:2;
197 unsigned pad_for_nice_hex_output:6;
Avi Kivityf6e2c02b2009-01-11 13:02:10 +0200198 unsigned direct:1;
Joe Perches7d76b4d2008-03-23 01:02:34 -0700199 unsigned access:3;
Marcelo Tosatti2e53d632008-02-20 14:47:24 -0500200 unsigned invalid:1;
Avi Kivity9645bb562009-03-31 11:31:54 +0300201 unsigned nxe:1;
Avi Kivity3dbe1412010-05-12 11:48:18 +0300202 unsigned cr0_wp:1;
Avi Kivity411c5882011-06-06 16:11:54 +0300203 unsigned smep_andnot_wp:1;
Zhang Xiantaod657a982007-12-14 09:41:22 +0800204 };
205};
206
207struct kvm_mmu_page {
208 struct list_head link;
209 struct hlist_node hash_link;
210
211 /*
212 * The following two entries are used to key the shadow page in the
213 * hash table.
214 */
215 gfn_t gfn;
216 union kvm_mmu_page_role role;
217
218 u64 *spt;
219 /* hold the gfn of each spte inside spt */
220 gfn_t *gfns;
Marcelo Tosatti4731d4c2008-09-23 13:18:39 -0300221 bool unsync;
Xiao Guangrong0571d362010-04-16 21:27:54 +0800222 int root_count; /* Currently serving as active root */
Marcelo Tosatti60c8aec2008-12-01 22:32:02 -0200223 unsigned int unsync_children;
Xiao Guangrong67052b32011-05-15 23:27:08 +0800224 unsigned long parent_ptes; /* Reverse mapping for parent_pte */
Xiao Guangrongf6f8ade2013-06-19 17:09:24 +0800225
226 /* The page is obsolete if mmu_valid_gen != kvm->arch.mmu_valid_gen. */
Xiao Guangrong5304b8d2013-05-31 08:36:22 +0800227 unsigned long mmu_valid_gen;
Xiao Guangrongf6f8ade2013-06-19 17:09:24 +0800228
Marcelo Tosatti0074ff62008-09-23 13:18:40 -0300229 DECLARE_BITMAP(unsync_child_bitmap, 512);
Xiao Guangrongc2a2ac22011-07-12 03:32:13 +0800230
231#ifdef CONFIG_X86_32
Xiao Guangrongaccaefe2013-06-19 17:09:20 +0800232 /*
233 * Used out of the mmu-lock to avoid reading spte values while an
234 * update is in progress; see the comments in __get_spte_lockless().
235 */
Xiao Guangrongc2a2ac22011-07-12 03:32:13 +0800236 int clear_spte_count;
237#endif
238
Xiao Guangrong0cbf8e42013-06-19 17:09:21 +0800239 /* Number of writes since the last time traversal visited this page. */
Xiao Guangronga30f47c2011-09-22 16:58:36 +0800240 int write_flooding_count;
Zhang Xiantaod657a982007-12-14 09:41:22 +0800241};
242
Avi Kivity1c083642009-01-04 12:39:07 +0200243struct kvm_pio_request {
244 unsigned long count;
Avi Kivity1c083642009-01-04 12:39:07 +0200245 int in;
246 int port;
247 int size;
Avi Kivity1c083642009-01-04 12:39:07 +0200248};
249
Zhang Xiantaod657a982007-12-14 09:41:22 +0800250/*
251 * x86 supports 3 paging modes (4-level 64-bit, 3-level 64-bit, and 2-level
252 * 32-bit). The kvm_mmu structure abstracts the details of the current mmu
253 * mode.
254 */
255struct kvm_mmu {
256 void (*new_cr3)(struct kvm_vcpu *vcpu);
Joerg Roedelf43addd2010-09-10 17:30:40 +0200257 void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long root);
Joerg Roedel5777ed32010-09-10 17:30:42 +0200258 unsigned long (*get_cr3)(struct kvm_vcpu *vcpu);
Avi Kivitye4e517b2011-07-28 11:36:17 +0300259 u64 (*get_pdptr)(struct kvm_vcpu *vcpu, int index);
Xiao Guangrong78b2c542010-12-07 10:48:06 +0800260 int (*page_fault)(struct kvm_vcpu *vcpu, gva_t gva, u32 err,
261 bool prefault);
Avi Kivity6389ee92010-11-29 16:12:30 +0200262 void (*inject_page_fault)(struct kvm_vcpu *vcpu,
263 struct x86_exception *fault);
Zhang Xiantaod657a982007-12-14 09:41:22 +0800264 void (*free)(struct kvm_vcpu *vcpu);
Gleb Natapov1871c602010-02-10 14:21:32 +0200265 gpa_t (*gva_to_gpa)(struct kvm_vcpu *vcpu, gva_t gva, u32 access,
Avi Kivityab9ae312010-11-22 17:53:26 +0200266 struct x86_exception *exception);
Joerg Roedelc30a3582010-09-10 17:30:48 +0200267 gpa_t (*translate_gpa)(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access);
Marcelo Tosattie8bc2172008-09-23 13:18:33 -0300268 int (*sync_page)(struct kvm_vcpu *vcpu,
Xiao Guangronga4a8e6f2010-11-19 17:04:03 +0800269 struct kvm_mmu_page *sp);
Marcelo Tosattia7052892008-09-23 13:18:35 -0300270 void (*invlpg)(struct kvm_vcpu *vcpu, gva_t gva);
Xiao Guangrong0f53b5b2011-03-09 15:43:51 +0800271 void (*update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp,
Xiao Guangrong7c562522011-03-28 10:29:27 +0800272 u64 *spte, const void *pte);
Zhang Xiantaod657a982007-12-14 09:41:22 +0800273 hpa_t root_hpa;
274 int root_level;
275 int shadow_root_level;
Avi Kivitya770f6f2008-12-21 19:20:09 +0200276 union kvm_mmu_page_role base_role;
Joerg Roedelc5a78f2b2010-09-10 17:30:39 +0200277 bool direct_map;
Zhang Xiantaod657a982007-12-14 09:41:22 +0800278
Avi Kivity97d64b72012-09-12 14:52:00 +0300279 /*
280 * Bitmap; bit set = permission fault
281 * Byte index: page fault error code [4:1]
282 * Bit index: pte permissions in ACC_* format
283 */
284 u8 permissions[16];
285
Zhang Xiantaod657a982007-12-14 09:41:22 +0800286 u64 *pae_root;
Joerg Roedel81407ca2010-09-10 17:31:00 +0200287 u64 *lm_root;
Dong, Eddie82725b22009-03-30 16:21:08 +0800288 u64 rsvd_bits_mask[2][4];
Joerg Roedelff03a072010-09-10 17:30:57 +0200289
Avi Kivity6fd01b72012-09-12 20:46:56 +0300290 /*
291 * Bitmap: bit set = last pte in walk
292 * index[0:1]: level (zero-based)
293 * index[2]: pte.ps
294 */
295 u8 last_pte_bitmap;
296
Joerg Roedel2d48a982010-09-10 17:31:01 +0200297 bool nx;
298
Joerg Roedelff03a072010-09-10 17:30:57 +0200299 u64 pdptrs[4]; /* pae */
Zhang Xiantaod657a982007-12-14 09:41:22 +0800300};
301
Gleb Natapovf5132b02011-11-10 14:57:22 +0200302enum pmc_type {
303 KVM_PMC_GP = 0,
304 KVM_PMC_FIXED,
305};
306
307struct kvm_pmc {
308 enum pmc_type type;
309 u8 idx;
310 u64 counter;
311 u64 eventsel;
312 struct perf_event *perf_event;
313 struct kvm_vcpu *vcpu;
314};
315
316struct kvm_pmu {
317 unsigned nr_arch_gp_counters;
318 unsigned nr_arch_fixed_counters;
319 unsigned available_event_types;
320 u64 fixed_ctr_ctrl;
321 u64 global_ctrl;
322 u64 global_status;
323 u64 global_ovf_ctrl;
324 u64 counter_bitmask[2];
325 u64 global_ctrl_mask;
Andi Kleen103af0a2013-07-18 15:57:02 -0700326 u64 reserved_bits;
Gleb Natapovf5132b02011-11-10 14:57:22 +0200327 u8 version;
Robert Richter15c7ad52012-06-20 20:46:33 +0200328 struct kvm_pmc gp_counters[INTEL_PMC_MAX_GENERIC];
329 struct kvm_pmc fixed_counters[INTEL_PMC_MAX_FIXED];
Gleb Natapovf5132b02011-11-10 14:57:22 +0200330 struct irq_work irq_work;
331 u64 reprogram_pmi;
332};
333
Zhang Xiantaoad312c72007-12-13 23:50:52 +0800334struct kvm_vcpu_arch {
Marcelo Tosatti5fdbf972008-06-27 14:58:02 -0300335 /*
336 * rip and regs accesses must go through
337 * kvm_{register,rip}_{read,write} functions.
338 */
339 unsigned long regs[NR_VCPU_REGS];
340 u32 regs_avail;
341 u32 regs_dirty;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800342
343 unsigned long cr0;
Avi Kivitye8467fd2009-12-29 18:43:06 +0200344 unsigned long cr0_guest_owned_bits;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800345 unsigned long cr2;
346 unsigned long cr3;
347 unsigned long cr4;
Avi Kivityfc78f512009-12-07 12:16:48 +0200348 unsigned long cr4_guest_owned_bits;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800349 unsigned long cr8;
Alexander Graf1371d902008-11-25 20:17:04 +0100350 u32 hflags;
Avi Kivityf6801df2010-01-21 15:31:50 +0200351 u64 efer;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800352 u64 apic_base;
353 struct kvm_lapic *apic; /* kernel irqchip context */
Gleb Natapov41383772012-04-19 14:06:29 +0300354 unsigned long apic_attention;
Gleb Natapove1035712009-03-05 16:34:59 +0200355 int32_t apic_arb_prio;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800356 int mp_state;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800357 u64 ia32_misc_enable_msr;
Avi Kivityb209749f2007-10-22 16:50:39 +0200358 bool tpr_access_reporting;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800359
Joerg Roedel14dfe852010-09-10 17:30:49 +0200360 /*
361 * Paging state of the vcpu
362 *
363 * If the vcpu runs in guest mode with two level paging this still saves
364 * the paging mode of the l1 guest. This context is always used to
365 * handle faults.
366 */
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800367 struct kvm_mmu mmu;
Joerg Roedel8df25a32010-09-10 17:30:46 +0200368
369 /*
Joerg Roedel6539e732010-09-10 17:30:50 +0200370 * Paging state of an L2 guest (used for nested npt)
371 *
372 * This context will save all necessary information to walk page tables
373 * of the an L2 guest. This context is only initialized for page table
374 * walking and not for faulting since we never handle l2 page faults on
375 * the host.
376 */
377 struct kvm_mmu nested_mmu;
378
379 /*
Joerg Roedel14dfe852010-09-10 17:30:49 +0200380 * Pointer to the mmu context currently used for
381 * gva_to_gpa translations.
382 */
383 struct kvm_mmu *walk_mmu;
384
Xiao Guangrong53c07b12011-05-15 23:26:20 +0800385 struct kvm_mmu_memory_cache mmu_pte_list_desc_cache;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800386 struct kvm_mmu_memory_cache mmu_page_cache;
387 struct kvm_mmu_memory_cache mmu_page_header_cache;
388
Sheng Yang98918832010-05-17 17:08:28 +0800389 struct fpu guest_fpu;
Dexuan Cui2acf9232010-06-10 11:27:12 +0800390 u64 xcr0;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800391
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800392 struct kvm_pio_request pio;
393 void *pio_data;
394
Gleb Natapov66fd3f72009-05-11 13:35:50 +0300395 u8 event_exit_inst_len;
396
Avi Kivity298101d2007-11-25 13:41:11 +0200397 struct kvm_queued_exception {
398 bool pending;
399 bool has_error_code;
Joerg Roedelce7ddec2010-04-22 12:33:13 +0200400 bool reinject;
Avi Kivity298101d2007-11-25 13:41:11 +0200401 u8 nr;
402 u32 error_code;
403 } exception;
404
Avi Kivity937a7ea2008-07-03 15:17:01 +0300405 struct kvm_queued_interrupt {
406 bool pending;
Gleb Natapov66fd3f72009-05-11 13:35:50 +0300407 bool soft;
Avi Kivity937a7ea2008-07-03 15:17:01 +0300408 u8 nr;
409 } interrupt;
410
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800411 int halt_request; /* real mode on Intel only */
412
413 int cpuid_nent;
Dan Kenigsberg07716712007-11-21 17:10:04 +0200414 struct kvm_cpuid_entry2 cpuid_entries[KVM_MAX_CPUID_ENTRIES];
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800415 /* emulate context */
416
417 struct x86_emulate_ctxt emulate_ctxt;
Gleb Natapov7ae441e2011-03-31 12:06:41 +0200418 bool emulate_regs_need_sync_to_vcpu;
419 bool emulate_regs_need_sync_from_vcpu;
Gleb Natapov716d51a2012-09-03 15:24:26 +0300420 int (*complete_userspace_io)(struct kvm_vcpu *vcpu);
Glauber de Oliveira Costa18068522008-02-15 17:52:47 -0200421
422 gpa_t time;
Gerd Hoffmann50d0a0f2008-06-03 16:17:31 +0200423 struct pvclock_vcpu_time_info hv_clock;
Zachary Amsdene48672f2010-08-19 22:07:23 -1000424 unsigned int hw_tsc_khz;
Andy Honig0b794592013-02-20 14:48:10 -0800425 struct gfn_to_hva_cache pv_time;
426 bool pv_time_enabled;
Marcelo Tosatti51d59c62012-08-03 15:57:49 -0300427 /* set guest stopped flag in pvclock flags field */
428 bool pvclock_set_guest_stopped_request;
Glauber Costac9aaa892011-07-11 15:28:14 -0400429
430 struct {
431 u64 msr_val;
432 u64 last_steal;
433 u64 accum_steal;
434 struct gfn_to_hva_cache stime;
435 struct kvm_steal_time steal;
436 } st;
437
Zachary Amsden1d5f0662010-08-19 22:07:30 -1000438 u64 last_guest_tsc;
439 u64 last_kernel_ns;
Zachary Amsden6f526ec2012-02-03 15:43:54 -0200440 u64 last_host_tsc;
Zachary Amsden0dd6a6e2012-02-03 15:43:56 -0200441 u64 tsc_offset_adjustment;
Zachary Amsdene26101b2012-02-03 15:43:57 -0200442 u64 this_tsc_nsec;
443 u64 this_tsc_write;
444 u8 this_tsc_generation;
Zachary Amsdenc2855452010-09-18 14:38:15 -1000445 bool tsc_catchup;
Zachary Amsdencc578282012-02-03 15:43:50 -0200446 bool tsc_always_catchup;
447 s8 virtual_tsc_shift;
448 u32 virtual_tsc_mult;
449 u32 virtual_tsc_khz;
Will Auldba904632012-11-29 12:42:50 -0800450 s64 ia32_tsc_adjust_msr;
Sheng Yang3419ffc2008-05-15 09:52:48 +0800451
Avi Kivity7460fb4a2011-09-20 13:43:14 +0300452 atomic_t nmi_queued; /* unprocessed asynchronous NMIs */
453 unsigned nmi_pending; /* NMI queued after currently running handler */
454 bool nmi_injected; /* Trying to inject an NMI this entry */
Avi Kivity9ba075a2008-05-26 20:06:35 +0300455
Sheng Yang0bed3b52008-10-09 16:01:54 +0800456 struct mtrr_state_type mtrr_state;
457 u32 pat;
Jan Kiszka42dbaa52008-12-15 13:52:10 +0100458
459 int switch_db_regs;
Jan Kiszka42dbaa52008-12-15 13:52:10 +0100460 unsigned long db[KVM_NR_DB_REGS];
461 unsigned long dr6;
462 unsigned long dr7;
463 unsigned long eff_db[KVM_NR_DB_REGS];
Jan Kiszkac8639012012-09-21 05:42:55 +0200464 unsigned long guest_debug_dr7;
Huang Ying890ca9a2009-05-11 16:48:15 +0800465
466 u64 mcg_cap;
467 u64 mcg_status;
468 u64 mcg_ctl;
469 u64 *mce_banks;
Jan Kiszka94fe45d2009-10-18 13:24:44 +0200470
Xiao Guangrongbebb1062011-07-12 03:23:20 +0800471 /* Cache MMIO info */
472 u64 mmio_gva;
473 unsigned access;
474 gfn_t mmio_gfn;
475
Gleb Natapovf5132b02011-11-10 14:57:22 +0200476 struct kvm_pmu pmu;
477
Jan Kiszka94fe45d2009-10-18 13:24:44 +0200478 /* used for guest single stepping over the given code position */
Jan Kiszka94fe45d2009-10-18 13:24:44 +0200479 unsigned long singlestep_rip;
Jan Kiszkaf92653e2010-02-23 17:47:55 +0100480
Gleb Natapov10388a02010-01-17 15:51:23 +0200481 /* fields used by HYPER-V emulation */
482 u64 hv_vapic;
Sheng Yangf5f48ee2010-06-30 12:25:15 +0800483
484 cpumask_var_t wbinvd_dirty_mask;
Gleb Natapovaf585b92010-10-14 11:22:46 +0200485
Xiao Guangrong1cb3f3a2011-09-22 17:02:48 +0800486 unsigned long last_retry_eip;
487 unsigned long last_retry_addr;
488
Gleb Natapovaf585b92010-10-14 11:22:46 +0200489 struct {
490 bool halted;
491 gfn_t gfns[roundup_pow_of_two(ASYNC_PF_PER_VCPU)];
Gleb Natapov344d9582010-10-14 11:22:50 +0200492 struct gfn_to_hva_cache data;
493 u64 msr_val;
Gleb Natapov7c907052010-10-14 11:22:53 +0200494 u32 id;
Gleb Natapov6adba522010-10-14 11:22:55 +0200495 bool send_user_only;
Gleb Natapovaf585b92010-10-14 11:22:46 +0200496 } apf;
Boris Ostrovsky2b036c62012-01-09 14:00:35 -0500497
498 /* OSVW MSRs (AMD only) */
499 struct {
500 u64 length;
501 u64 status;
502 } osvw;
Michael S. Tsirkinae7a2a32012-06-24 19:25:07 +0300503
504 struct {
505 u64 msr_val;
506 struct gfn_to_hva_cache data;
507 } pv_eoi;
Xiao Guangrong93c05d32013-01-13 23:49:07 +0800508
509 /*
510 * Indicate whether the access faults on its page table in guest
511 * which is set when fix page fault and used to detect unhandeable
512 * instruction.
513 */
514 bool write_fault_to_shadow_pgtable;
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800515};
516
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +0900517struct kvm_lpage_info {
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +0900518 int write_count;
519};
520
521struct kvm_arch_memory_slot {
Takuya Yoshikawad89cc612012-08-01 18:03:28 +0900522 unsigned long *rmap[KVM_NR_PAGE_SIZES];
Takuya Yoshikawadb3fe4e2012-02-08 13:02:18 +0900523 struct kvm_lpage_info *lpage_info[KVM_NR_PAGE_SIZES - 1];
524};
525
Gleb Natapov1e08ec42012-09-13 17:19:24 +0300526struct kvm_apic_map {
527 struct rcu_head rcu;
528 u8 ldr_bits;
529 /* fields bellow are used to decode ldr values in different modes */
530 u32 cid_shift, cid_mask, lid_mask;
531 struct kvm_lapic *phys_map[256];
532 /* first index is cluster id second is cpu id in a cluster */
533 struct kvm_lapic *logical_map[16][16];
534};
535
Marcelo Tosattifef9cce2009-12-23 14:35:17 -0200536struct kvm_arch {
Dave Hansen49d5ca22010-08-19 18:11:28 -0700537 unsigned int n_used_mmu_pages;
Zhang Xiantaof05e70a2007-12-14 10:01:48 +0800538 unsigned int n_requested_mmu_pages;
Dave Hansen39de71e2010-08-19 18:11:14 -0700539 unsigned int n_max_mmu_pages;
Xiao Guangrong332b2072011-05-15 23:20:27 +0800540 unsigned int indirect_shadow_pages;
Xiao Guangrong5304b8d2013-05-31 08:36:22 +0800541 unsigned long mmu_valid_gen;
Zhang Xiantaof05e70a2007-12-14 10:01:48 +0800542 struct hlist_head mmu_page_hash[KVM_NUM_MMU_PAGES];
543 /*
544 * Hash table of struct kvm_mmu_page.
545 */
546 struct list_head active_mmu_pages;
Xiao Guangrong365c8862013-05-31 08:36:29 +0800547 struct list_head zapped_obsolete_pages;
548
Ben-Ami Yassour4d5c5d02008-07-28 19:26:26 +0300549 struct list_head assigned_dev_head;
Joerg Roedel19de40a2008-12-03 14:43:34 +0100550 struct iommu_domain *iommu_domain;
Sheng Yang522c68c2009-04-27 20:35:43 +0800551 int iommu_flags;
Zhang Xiantaod7deeeb02007-12-14 10:17:34 +0800552 struct kvm_pic *vpic;
553 struct kvm_ioapic *vioapic;
Sheng Yang78376992008-01-28 05:10:22 +0800554 struct kvm_pit *vpit;
Jan Kiszkacc6e4622008-10-20 10:20:03 +0200555 int vapics_in_nmi_mode;
Gleb Natapov1e08ec42012-09-13 17:19:24 +0300556 struct mutex apic_map_lock;
557 struct kvm_apic_map *apic_map;
Zhang Xiantaobfc6d222007-12-14 10:20:16 +0800558
Zhang Xiantaobfc6d222007-12-14 10:20:16 +0800559 unsigned int tss_addr;
560 struct page *apic_access_page;
Glauber de Oliveira Costa18068522008-02-15 17:52:47 -0200561
562 gpa_t wall_clock;
Sheng Yangb7ebfb02008-04-25 21:44:52 +0800563
564 struct page *ept_identity_pagetable;
565 bool ept_identity_pagetable_done;
Sheng Yangb927a3c2009-07-21 10:42:48 +0800566 gpa_t ept_identity_map_addr;
Sheng Yang5550af42008-10-15 20:15:06 +0800567
568 unsigned long irq_sources_bitmap;
Glauber Costaafbcf7a2009-10-16 15:28:36 -0400569 s64 kvmclock_offset;
Jan Kiszka038f8c12011-02-04 10:49:11 +0100570 raw_spinlock_t tsc_write_lock;
Zachary Amsdenf38e0982010-08-19 22:07:20 -1000571 u64 last_tsc_nsec;
Zachary Amsdenf38e0982010-08-19 22:07:20 -1000572 u64 last_tsc_write;
Zachary Amsden5d3cb0f62012-02-03 15:43:51 -0200573 u32 last_tsc_khz;
Zachary Amsdene26101b2012-02-03 15:43:57 -0200574 u64 cur_tsc_nsec;
575 u64 cur_tsc_write;
576 u64 cur_tsc_offset;
577 u8 cur_tsc_generation;
Marcelo Tosattib48aa972012-11-27 23:29:03 -0200578 int nr_vcpus_matched_tsc;
Ed Swierkffde22a2009-10-15 15:21:43 -0700579
Marcelo Tosattid8281992012-11-27 23:29:01 -0200580 spinlock_t pvclock_gtod_sync_lock;
581 bool use_master_clock;
582 u64 master_kernel_ns;
583 cycle_t master_cycle_now;
584
Ed Swierkffde22a2009-10-15 15:21:43 -0700585 struct kvm_xen_hvm_config xen_hvm_config;
Gleb Natapov55cd8e52010-01-17 15:51:22 +0200586
587 /* fields used by HYPER-V emulation */
588 u64 hv_guest_os_id;
589 u64 hv_hypercall;
Xiao Guangrongb034cf02010-12-23 16:08:35 +0800590
591 #ifdef CONFIG_KVM_MMU_AUDIT
592 int audit_point;
593 #endif
Zhang Xiantaod69fb812007-12-14 09:54:20 +0800594};
595
Zhang Xiantao07114562007-12-14 10:23:23 +0800596struct kvm_vm_stat {
597 u32 mmu_shadow_zapped;
598 u32 mmu_pte_write;
599 u32 mmu_pte_updated;
600 u32 mmu_pde_zapped;
601 u32 mmu_flooded;
602 u32 mmu_recycled;
Avi Kivitydfc5aa02007-12-18 19:47:18 +0200603 u32 mmu_cache_miss;
Marcelo Tosatti4731d4c2008-09-23 13:18:39 -0300604 u32 mmu_unsync;
Zhang Xiantao07114562007-12-14 10:23:23 +0800605 u32 remote_tlb_flush;
Marcelo Tosatti05da4552008-02-23 11:44:30 -0300606 u32 lpages;
Zhang Xiantao07114562007-12-14 10:23:23 +0800607};
608
Zhang Xiantao77b4c252007-12-14 09:49:26 +0800609struct kvm_vcpu_stat {
610 u32 pf_fixed;
611 u32 pf_guest;
612 u32 tlb_flush;
613 u32 invlpg;
614
615 u32 exits;
616 u32 io_exits;
617 u32 mmio_exits;
618 u32 signal_exits;
619 u32 irq_window_exits;
Sheng Yangf08864b2008-05-15 18:23:25 +0800620 u32 nmi_window_exits;
Zhang Xiantao77b4c252007-12-14 09:49:26 +0800621 u32 halt_exits;
622 u32 halt_wakeup;
623 u32 request_irq_exits;
624 u32 irq_exits;
625 u32 host_state_reload;
626 u32 efer_reload;
627 u32 fpu_reload;
628 u32 insn_emulation;
629 u32 insn_emulation_fail;
Amit Shahf11c3a82008-02-21 01:00:30 +0530630 u32 hypercalls;
Avi Kivityfa89a812008-09-01 15:57:51 +0300631 u32 irq_injections;
Jan Kiszkac4abb7c2008-09-26 09:30:55 +0200632 u32 nmi_injections;
Zhang Xiantao77b4c252007-12-14 09:49:26 +0800633};
Zhang Xiantaoad312c72007-12-13 23:50:52 +0800634
Joerg Roedel8a76d7f2011-04-04 12:39:27 +0200635struct x86_instruction_info;
636
Will Auld8fe8ab42012-11-29 12:42:12 -0800637struct msr_data {
638 bool host_initiated;
639 u32 index;
640 u64 data;
641};
642
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800643struct kvm_x86_ops {
644 int (*cpu_has_kvm_support)(void); /* __init */
645 int (*disabled_by_bios)(void); /* __init */
Alexander Graf10474ae2009-09-15 11:37:46 +0200646 int (*hardware_enable)(void *dummy);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800647 void (*hardware_disable)(void *dummy);
648 void (*check_processor_compatibility)(void *rtn);
649 int (*hardware_setup)(void); /* __init */
650 void (*hardware_unsetup)(void); /* __exit */
Avi Kivity774ead32007-12-26 13:57:04 +0200651 bool (*cpu_has_accelerated_tpr)(void);
Sheng Yang0e851882009-12-18 16:48:46 +0800652 void (*cpuid_update)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800653
654 /* Create, but do not attach this VCPU */
655 struct kvm_vcpu *(*vcpu_create)(struct kvm *kvm, unsigned id);
656 void (*vcpu_free)(struct kvm_vcpu *vcpu);
Jan Kiszka57f252f2013-03-12 10:20:24 +0100657 void (*vcpu_reset)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800658
659 void (*prepare_guest_switch)(struct kvm_vcpu *vcpu);
660 void (*vcpu_load)(struct kvm_vcpu *vcpu, int cpu);
661 void (*vcpu_put)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800662
Jan Kiszkac8639012012-09-21 05:42:55 +0200663 void (*update_db_bp_intercept)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800664 int (*get_msr)(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata);
Will Auld8fe8ab42012-11-29 12:42:12 -0800665 int (*set_msr)(struct kvm_vcpu *vcpu, struct msr_data *msr);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800666 u64 (*get_segment_base)(struct kvm_vcpu *vcpu, int seg);
667 void (*get_segment)(struct kvm_vcpu *vcpu,
668 struct kvm_segment *var, int seg);
Izik Eidus2e4d2652008-03-24 19:38:34 +0200669 int (*get_cpl)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800670 void (*set_segment)(struct kvm_vcpu *vcpu,
671 struct kvm_segment *var, int seg);
672 void (*get_cs_db_l_bits)(struct kvm_vcpu *vcpu, int *db, int *l);
Avi Kivitye8467fd2009-12-29 18:43:06 +0200673 void (*decache_cr0_guest_bits)(struct kvm_vcpu *vcpu);
Avi Kivityaff48ba2010-12-05 18:56:11 +0200674 void (*decache_cr3)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800675 void (*decache_cr4_guest_bits)(struct kvm_vcpu *vcpu);
676 void (*set_cr0)(struct kvm_vcpu *vcpu, unsigned long cr0);
677 void (*set_cr3)(struct kvm_vcpu *vcpu, unsigned long cr3);
Nadav Har'El5e1746d2011-05-25 23:03:24 +0300678 int (*set_cr4)(struct kvm_vcpu *vcpu, unsigned long cr4);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800679 void (*set_efer)(struct kvm_vcpu *vcpu, u64 efer);
Gleb Natapov89a27f42010-02-16 10:51:48 +0200680 void (*get_idt)(struct kvm_vcpu *vcpu, struct desc_ptr *dt);
681 void (*set_idt)(struct kvm_vcpu *vcpu, struct desc_ptr *dt);
682 void (*get_gdt)(struct kvm_vcpu *vcpu, struct desc_ptr *dt);
683 void (*set_gdt)(struct kvm_vcpu *vcpu, struct desc_ptr *dt);
Gleb Natapov020df072010-04-13 10:05:23 +0300684 void (*set_dr7)(struct kvm_vcpu *vcpu, unsigned long value);
Marcelo Tosatti5fdbf972008-06-27 14:58:02 -0300685 void (*cache_reg)(struct kvm_vcpu *vcpu, enum kvm_reg reg);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800686 unsigned long (*get_rflags)(struct kvm_vcpu *vcpu);
687 void (*set_rflags)(struct kvm_vcpu *vcpu, unsigned long rflags);
Avi Kivity6b52d182010-01-21 15:31:47 +0200688 void (*fpu_activate)(struct kvm_vcpu *vcpu);
Avi Kivity02daab22009-12-30 12:40:26 +0200689 void (*fpu_deactivate)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800690
691 void (*tlb_flush)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800692
Avi Kivity851ba692009-08-24 11:10:17 +0300693 void (*run)(struct kvm_vcpu *vcpu);
694 int (*handle_exit)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800695 void (*skip_emulated_instruction)(struct kvm_vcpu *vcpu);
Glauber Costa2809f5d2009-05-12 16:21:05 -0400696 void (*set_interrupt_shadow)(struct kvm_vcpu *vcpu, int mask);
697 u32 (*get_interrupt_shadow)(struct kvm_vcpu *vcpu, int mask);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800698 void (*patch_hypercall)(struct kvm_vcpu *vcpu,
699 unsigned char *hypercall_addr);
Gleb Natapov66fd3f72009-05-11 13:35:50 +0300700 void (*set_irq)(struct kvm_vcpu *vcpu);
Gleb Natapov95ba8273132009-04-21 17:45:08 +0300701 void (*set_nmi)(struct kvm_vcpu *vcpu);
Avi Kivity298101d2007-11-25 13:41:11 +0200702 void (*queue_exception)(struct kvm_vcpu *vcpu, unsigned nr,
Joerg Roedelce7ddec2010-04-22 12:33:13 +0200703 bool has_error_code, u32 error_code,
704 bool reinject);
Avi Kivityb463a6f2010-07-20 15:06:17 +0300705 void (*cancel_injection)(struct kvm_vcpu *vcpu);
Gleb Natapov78646122009-03-23 12:12:11 +0200706 int (*interrupt_allowed)(struct kvm_vcpu *vcpu);
Gleb Natapov95ba8273132009-04-21 17:45:08 +0300707 int (*nmi_allowed)(struct kvm_vcpu *vcpu);
Jan Kiszka3cfc3092009-11-12 01:04:25 +0100708 bool (*get_nmi_mask)(struct kvm_vcpu *vcpu);
709 void (*set_nmi_mask)(struct kvm_vcpu *vcpu, bool masked);
Jan Kiszka03b28f82013-04-29 16:46:42 +0200710 int (*enable_nmi_window)(struct kvm_vcpu *vcpu);
Jan Kiszka730dca42013-04-28 10:50:52 +0200711 int (*enable_irq_window)(struct kvm_vcpu *vcpu);
Gleb Natapov95ba8273132009-04-21 17:45:08 +0300712 void (*update_cr8_intercept)(struct kvm_vcpu *vcpu, int tpr, int irr);
Yang Zhangc7c9c562013-01-25 10:18:51 +0800713 int (*vm_has_apicv)(struct kvm *kvm);
714 void (*hwapic_irr_update)(struct kvm_vcpu *vcpu, int max_irr);
715 void (*hwapic_isr_update)(struct kvm *kvm, int isr);
716 void (*load_eoi_exitmap)(struct kvm_vcpu *vcpu, u64 *eoi_exit_bitmap);
Yang Zhang8d146952013-01-25 10:18:50 +0800717 void (*set_virtual_x2apic_mode)(struct kvm_vcpu *vcpu, bool set);
Yang Zhanga20ed542013-04-11 19:25:15 +0800718 void (*deliver_posted_interrupt)(struct kvm_vcpu *vcpu, int vector);
719 void (*sync_pir_to_irr)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800720 int (*set_tss_addr)(struct kvm *kvm, unsigned int addr);
Sheng Yang67253af2008-04-25 10:20:22 +0800721 int (*get_tdp_level)(void);
Sheng Yang4b12f0d2009-04-27 20:35:42 +0800722 u64 (*get_mt_mask)(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio);
Sheng Yang17cc3932010-01-05 19:02:27 +0800723 int (*get_lpage_level)(void);
Sheng Yang4e47c7a2009-12-18 16:48:47 +0800724 bool (*rdtscp_supported)(void);
Mao, Junjiead756a12012-07-02 01:18:48 +0000725 bool (*invpcid_supported)(void);
Marcelo Tosattif1e2b262012-02-03 15:43:55 -0200726 void (*adjust_tsc_offset)(struct kvm_vcpu *vcpu, s64 adjustment, bool host);
Joerg Roedel344f4142009-07-27 16:30:48 +0200727
Joerg Roedel1c97f0a2010-09-10 17:30:41 +0200728 void (*set_tdp_cr3)(struct kvm_vcpu *vcpu, unsigned long cr3);
729
Joerg Roedeld4330ef2010-04-22 12:33:11 +0200730 void (*set_supported_cpuid)(u32 func, struct kvm_cpuid_entry2 *entry);
731
Sheng Yangf5f48ee2010-06-30 12:25:15 +0800732 bool (*has_wbinvd_exit)(void);
733
Zachary Amsdencc578282012-02-03 15:43:50 -0200734 void (*set_tsc_khz)(struct kvm_vcpu *vcpu, u32 user_tsc_khz, bool scale);
Will Auldba904632012-11-29 12:42:50 -0800735 u64 (*read_tsc_offset)(struct kvm_vcpu *vcpu);
Zachary Amsden99e3e302010-08-19 22:07:17 -1000736 void (*write_tsc_offset)(struct kvm_vcpu *vcpu, u64 offset);
737
Joerg Roedel857e4092011-03-25 09:44:50 +0100738 u64 (*compute_tsc_offset)(struct kvm_vcpu *vcpu, u64 target_tsc);
Marcelo Tosatti886b4702012-11-27 23:28:58 -0200739 u64 (*read_l1_tsc)(struct kvm_vcpu *vcpu, u64 host_tsc);
Joerg Roedel857e4092011-03-25 09:44:50 +0100740
Avi Kivity586f9602010-11-18 13:09:54 +0200741 void (*get_exit_info)(struct kvm_vcpu *vcpu, u64 *info1, u64 *info2);
Joerg Roedel8a76d7f2011-04-04 12:39:27 +0200742
743 int (*check_intercept)(struct kvm_vcpu *vcpu,
744 struct x86_instruction_info *info,
745 enum x86_intercept_stage stage);
Yang Zhanga547c6d2013-04-11 19:25:10 +0800746 void (*handle_external_intr)(struct kvm_vcpu *vcpu);
Zhang Xiantaoea4a5ff2007-11-19 14:40:47 +0800747};
748
Gleb Natapovaf585b92010-10-14 11:22:46 +0200749struct kvm_arch_async_pf {
Gleb Natapov7c907052010-10-14 11:22:53 +0200750 u32 token;
Gleb Natapovaf585b92010-10-14 11:22:46 +0200751 gfn_t gfn;
Xiao Guangrongfb67e142010-12-07 10:35:25 +0800752 unsigned long cr3;
Xiao Guangrongc4806ac2010-11-12 14:49:55 +0800753 bool direct_map;
Gleb Natapovaf585b92010-10-14 11:22:46 +0200754};
755
Zhang Xiantao97896d02007-11-14 20:09:30 +0800756extern struct kvm_x86_ops *kvm_x86_ops;
757
Marcelo Tosattif1e2b262012-02-03 15:43:55 -0200758static inline void adjust_tsc_offset_guest(struct kvm_vcpu *vcpu,
759 s64 adjustment)
760{
761 kvm_x86_ops->adjust_tsc_offset(vcpu, adjustment, false);
762}
763
764static inline void adjust_tsc_offset_host(struct kvm_vcpu *vcpu, s64 adjustment)
765{
766 kvm_x86_ops->adjust_tsc_offset(vcpu, adjustment, true);
767}
768
Zhang Xiantao54f15852007-11-19 15:24:28 +0800769int kvm_mmu_module_init(void);
770void kvm_mmu_module_exit(void);
771
772void kvm_mmu_destroy(struct kvm_vcpu *vcpu);
773int kvm_mmu_create(struct kvm_vcpu *vcpu);
774int kvm_mmu_setup(struct kvm_vcpu *vcpu);
Sheng Yang7b523452008-04-25 21:13:50 +0800775void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask,
Sheng Yang4b12f0d2009-04-27 20:35:42 +0800776 u64 dirty_mask, u64 nx_mask, u64 x_mask);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800777
778int kvm_mmu_reset_context(struct kvm_vcpu *vcpu);
779void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot);
Takuya Yoshikawa5dc99b232012-03-01 19:32:16 +0900780void kvm_mmu_write_protect_pt_masked(struct kvm *kvm,
781 struct kvm_memory_slot *slot,
782 gfn_t gfn_offset, unsigned long mask);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800783void kvm_mmu_zap_all(struct kvm *kvm);
Xiao Guangrongf8f55942013-06-07 16:51:26 +0800784void kvm_mmu_invalidate_mmio_sptes(struct kvm *kvm);
Zhang Xiantao3ad82a72007-11-20 13:11:38 +0800785unsigned int kvm_mmu_calculate_mmu_pages(struct kvm *kvm);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800786void kvm_mmu_change_mmu_pages(struct kvm *kvm, unsigned int kvm_nr_mmu_pages);
787
Joerg Roedelff03a072010-09-10 17:30:57 +0200788int load_pdptrs(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu, unsigned long cr3);
Joerg Roedelcc4b6872008-02-07 13:47:43 +0100789
Marcelo Tosatti3200f402008-03-29 20:17:59 -0300790int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa,
Avi Kivity9f811282008-03-02 14:06:05 +0200791 const void *val, int bytes);
Sheng Yang4b12f0d2009-04-27 20:35:42 +0800792u8 kvm_get_guest_memory_type(struct kvm_vcpu *vcpu, gfn_t gfn);
Marcelo Tosatti2f333bc2008-02-22 12:21:37 -0500793
794extern bool tdp_enabled;
Avi Kivity9f811282008-03-02 14:06:05 +0200795
Liu, Jinsonga3e06bb2011-09-22 16:55:52 +0800796u64 vcpu_tsc_khz(struct kvm_vcpu *vcpu);
797
Joerg Roedel92a1f122011-03-25 09:44:51 +0100798/* control of guest tsc rate supported? */
799extern bool kvm_has_tsc_control;
800/* minimum supported tsc_khz for guests */
801extern u32 kvm_min_guest_tsc_khz;
802/* maximum supported tsc_khz for guests */
803extern u32 kvm_max_guest_tsc_khz;
804
Zhang Xiantao54f15852007-11-19 15:24:28 +0800805enum emulation_result {
806 EMULATE_DONE, /* no further processing */
807 EMULATE_DO_MMIO, /* kvm_run filled with mmio request */
808 EMULATE_FAIL, /* can't emulate this instruction */
809};
810
Sheng Yang571008d2008-01-02 14:49:22 +0800811#define EMULTYPE_NO_DECODE (1 << 0)
812#define EMULTYPE_TRAP_UD (1 << 1)
Gleb Natapovba8afb62009-04-12 13:36:57 +0300813#define EMULTYPE_SKIP (1 << 2)
Xiao Guangrong1cb3f3a2011-09-22 17:02:48 +0800814#define EMULTYPE_RETRY (1 << 3)
Gleb Natapov991eebf2013-04-11 12:10:51 +0300815#define EMULTYPE_NO_REEXECUTE (1 << 4)
Andre Przywaradc25e892010-12-21 11:12:07 +0100816int x86_emulate_instruction(struct kvm_vcpu *vcpu, unsigned long cr2,
817 int emulation_type, void *insn, int insn_len);
Andre Przywara51d8b662010-12-21 11:12:02 +0100818
819static inline int emulate_instruction(struct kvm_vcpu *vcpu,
820 int emulation_type)
821{
Andre Przywaradc25e892010-12-21 11:12:07 +0100822 return x86_emulate_instruction(vcpu, 0, emulation_type, NULL, 0);
Andre Przywara51d8b662010-12-21 11:12:02 +0100823}
824
Joerg Roedelf2b4b7d2008-01-31 14:57:37 +0100825void kvm_enable_efer_bits(u64);
Jan Kiszka384bb782013-04-20 10:52:36 +0200826bool kvm_valid_efer(struct kvm_vcpu *vcpu, u64 efer);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800827int kvm_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *data);
Will Auld8fe8ab42012-11-29 12:42:12 -0800828int kvm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800829
830struct x86_emulate_ctxt;
831
Gleb Natapovcf8f70b2010-03-18 15:20:23 +0200832int kvm_fast_pio_out(struct kvm_vcpu *vcpu, int size, unsigned short port);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800833void kvm_emulate_cpuid(struct kvm_vcpu *vcpu);
834int kvm_emulate_halt(struct kvm_vcpu *vcpu);
Sheng Yangf5f48ee2010-06-30 12:25:15 +0800835int kvm_emulate_wbinvd(struct kvm_vcpu *vcpu);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800836
Guillaume Thouvenin3e6e0aa2008-05-27 10:18:46 +0200837void kvm_get_segment(struct kvm_vcpu *vcpu, struct kvm_segment *var, int seg);
Gleb Natapovc6975182010-02-18 12:15:01 +0200838int kvm_load_segment_descriptor(struct kvm_vcpu *vcpu, u16 selector, int seg);
Jan Kiszka66450a22013-03-13 12:42:34 +0100839void kvm_vcpu_deliver_sipi_vector(struct kvm_vcpu *vcpu, unsigned int vector);
Guillaume Thouvenin3e6e0aa2008-05-27 10:18:46 +0200840
Kevin Wolf7f3d35f2012-02-08 14:34:38 +0100841int kvm_task_switch(struct kvm_vcpu *vcpu, u16 tss_selector, int idt_index,
842 int reason, bool has_error_code, u32 error_code);
Izik Eidus37817f22008-03-24 23:14:53 +0200843
Avi Kivity49a9b072010-06-10 17:02:14 +0300844int kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0);
Avi Kivity23902182010-06-10 17:02:16 +0300845int kvm_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3);
Avi Kivitya83b29c2010-06-10 17:02:15 +0300846int kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4);
Andre Przywaraeea1cff2010-12-21 11:12:00 +0100847int kvm_set_cr8(struct kvm_vcpu *vcpu, unsigned long cr8);
Gleb Natapov020df072010-04-13 10:05:23 +0300848int kvm_set_dr(struct kvm_vcpu *vcpu, int dr, unsigned long val);
849int kvm_get_dr(struct kvm_vcpu *vcpu, int dr, unsigned long *val);
Avi Kivity2d3ad1f2008-02-24 11:20:43 +0200850unsigned long kvm_get_cr8(struct kvm_vcpu *vcpu);
851void kvm_lmsw(struct kvm_vcpu *vcpu, unsigned long msw);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800852void kvm_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l);
Dexuan Cui2acf9232010-06-10 11:27:12 +0800853int kvm_set_xcr(struct kvm_vcpu *vcpu, u32 index, u64 xcr);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800854
855int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata);
Will Auld8fe8ab42012-11-29 12:42:12 -0800856int kvm_set_msr_common(struct kvm_vcpu *vcpu, struct msr_data *msr);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800857
Jan Kiszka91586a32009-10-05 13:07:21 +0200858unsigned long kvm_get_rflags(struct kvm_vcpu *vcpu);
859void kvm_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags);
Avi Kivity022cd0e2011-11-10 14:57:23 +0200860bool kvm_rdpmc(struct kvm_vcpu *vcpu);
Jan Kiszka91586a32009-10-05 13:07:21 +0200861
Avi Kivity298101d2007-11-25 13:41:11 +0200862void kvm_queue_exception(struct kvm_vcpu *vcpu, unsigned nr);
863void kvm_queue_exception_e(struct kvm_vcpu *vcpu, unsigned nr, u32 error_code);
Joerg Roedelce7ddec2010-04-22 12:33:13 +0200864void kvm_requeue_exception(struct kvm_vcpu *vcpu, unsigned nr);
865void kvm_requeue_exception_e(struct kvm_vcpu *vcpu, unsigned nr, u32 error_code);
Avi Kivity6389ee92010-11-29 16:12:30 +0200866void kvm_inject_page_fault(struct kvm_vcpu *vcpu, struct x86_exception *fault);
Joerg Roedelec92fe42010-09-10 17:30:51 +0200867int kvm_read_guest_page_mmu(struct kvm_vcpu *vcpu, struct kvm_mmu *mmu,
868 gfn_t gfn, void *data, int offset, int len,
869 u32 access);
Avi Kivity6389ee92010-11-29 16:12:30 +0200870void kvm_propagate_fault(struct kvm_vcpu *vcpu, struct x86_exception *fault);
Avi Kivity0a79b002009-09-01 12:03:25 +0300871bool kvm_require_cpl(struct kvm_vcpu *vcpu, int required_cpl);
Avi Kivity298101d2007-11-25 13:41:11 +0200872
Michael S. Tsirkin1a577b722012-07-19 13:45:20 +0300873static inline int __kvm_irq_line_state(unsigned long *irq_state,
874 int irq_source_id, int level)
875{
876 /* Logical OR for level trig interrupt */
877 if (level)
878 __set_bit(irq_source_id, irq_state);
879 else
880 __clear_bit(irq_source_id, irq_state);
881
882 return !!(*irq_state);
883}
884
885int kvm_pic_set_irq(struct kvm_pic *pic, int irq, int irq_source_id, int level);
886void kvm_pic_clear_all(struct kvm_pic *pic, int irq_source_id);
Xiantao Zhang3de42dc2008-10-06 13:48:45 +0800887
Sheng Yang3419ffc2008-05-15 09:52:48 +0800888void kvm_inject_nmi(struct kvm_vcpu *vcpu);
889
Jan Kiszka10ab25c2010-05-25 16:01:50 +0200890int fx_init(struct kvm_vcpu *vcpu);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800891
Avi Kivityd835dfe2007-11-21 02:57:59 +0200892void kvm_mmu_flush_tlb(struct kvm_vcpu *vcpu);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800893void kvm_mmu_pte_write(struct kvm_vcpu *vcpu, gpa_t gpa,
Xiao Guangrongf57f2ef2011-09-22 16:56:39 +0800894 const u8 *new, int bytes);
Xiao Guangrong1cb3f3a2011-09-22 17:02:48 +0800895int kvm_mmu_unprotect_page(struct kvm *kvm, gfn_t gfn);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800896int kvm_mmu_unprotect_page_virt(struct kvm_vcpu *vcpu, gva_t gva);
897void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu);
898int kvm_mmu_load(struct kvm_vcpu *vcpu);
899void kvm_mmu_unload(struct kvm_vcpu *vcpu);
Marcelo Tosatti0ba73cd2008-09-23 13:18:34 -0300900void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu);
Xiao Guangronge459e322011-11-28 20:42:16 +0800901gpa_t translate_nested_gpa(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access);
Avi Kivityab9ae312010-11-22 17:53:26 +0200902gpa_t kvm_mmu_gva_to_gpa_read(struct kvm_vcpu *vcpu, gva_t gva,
903 struct x86_exception *exception);
904gpa_t kvm_mmu_gva_to_gpa_fetch(struct kvm_vcpu *vcpu, gva_t gva,
905 struct x86_exception *exception);
906gpa_t kvm_mmu_gva_to_gpa_write(struct kvm_vcpu *vcpu, gva_t gva,
907 struct x86_exception *exception);
908gpa_t kvm_mmu_gva_to_gpa_system(struct kvm_vcpu *vcpu, gva_t gva,
909 struct x86_exception *exception);
Zhang Xiantao54f15852007-11-19 15:24:28 +0800910
911int kvm_emulate_hypercall(struct kvm_vcpu *vcpu);
912
Andre Przywaradc25e892010-12-21 11:12:07 +0100913int kvm_mmu_page_fault(struct kvm_vcpu *vcpu, gva_t gva, u32 error_code,
914 void *insn, int insn_len);
Marcelo Tosattia7052892008-09-23 13:18:35 -0300915void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva);
Zhang Xiantao34c16ee2007-10-20 15:34:38 +0800916
Joerg Roedel18552672008-02-07 13:47:41 +0100917void kvm_enable_tdp(void);
Joerg Roedel5f4cb662008-07-14 20:36:36 +0200918void kvm_disable_tdp(void);
Joerg Roedel18552672008-02-07 13:47:41 +0100919
Carsten Ottede7d7892007-10-30 18:44:25 +0100920int complete_pio(struct kvm_vcpu *vcpu);
Gleb Natapovf850e2e2010-02-10 14:21:33 +0200921bool kvm_check_iopl(struct kvm_vcpu *vcpu);
Zhang Xiantaoec6d2732007-11-19 15:08:31 +0800922
Xiao Guangronge459e322011-11-28 20:42:16 +0800923static inline gpa_t translate_gpa(struct kvm_vcpu *vcpu, gpa_t gpa, u32 access)
924{
925 return gpa;
926}
927
Zhang Xiantaoec6d2732007-11-19 15:08:31 +0800928static inline struct kvm_mmu_page *page_header(hpa_t shadow_page)
929{
930 struct page *page = pfn_to_page(shadow_page >> PAGE_SHIFT);
931
932 return (struct kvm_mmu_page *)page_private(page);
933}
934
Avi Kivityd6e88ae2008-07-10 16:53:33 +0300935static inline u16 kvm_read_ldt(void)
Zhang Xiantaoec6d2732007-11-19 15:08:31 +0800936{
937 u16 ldt;
938 asm("sldt %0" : "=g"(ldt));
939 return ldt;
940}
941
Avi Kivityd6e88ae2008-07-10 16:53:33 +0300942static inline void kvm_load_ldt(u16 sel)
Zhang Xiantaoec6d2732007-11-19 15:08:31 +0800943{
944 asm("lldt %0" : : "rm"(sel));
945}
Zhang Xiantaoec6d2732007-11-19 15:08:31 +0800946
Zhang Xiantaoec6d2732007-11-19 15:08:31 +0800947#ifdef CONFIG_X86_64
948static inline unsigned long read_msr(unsigned long msr)
949{
950 u64 value;
951
952 rdmsrl(msr, value);
953 return value;
954}
955#endif
956
Zhang Xiantaoec6d2732007-11-19 15:08:31 +0800957static inline u32 get_rdx_init_val(void)
958{
959 return 0x600; /* P6 family */
960}
961
Avi Kivityc1a5d4f2007-11-25 14:12:03 +0200962static inline void kvm_inject_gp(struct kvm_vcpu *vcpu, u32 error_code)
963{
964 kvm_queue_exception_e(vcpu, GP_VECTOR, error_code);
965}
966
Zhang Xiantaoec6d2732007-11-19 15:08:31 +0800967#define TSS_IOPB_BASE_OFFSET 0x66
968#define TSS_BASE_SIZE 0x68
969#define TSS_IOPB_SIZE (65536 / 8)
970#define TSS_REDIRECTION_SIZE (256 / 8)
Joe Perches7d76b4d2008-03-23 01:02:34 -0700971#define RMODE_TSS_SIZE \
972 (TSS_BASE_SIZE + TSS_REDIRECTION_SIZE + TSS_IOPB_SIZE + 1)
Hollis Blanchard53e0aa72007-12-03 16:15:26 -0600973
Izik Eidus37817f22008-03-24 23:14:53 +0200974enum {
975 TASK_SWITCH_CALL = 0,
976 TASK_SWITCH_IRET = 1,
977 TASK_SWITCH_JMP = 2,
978 TASK_SWITCH_GATE = 3,
979};
980
Alexander Graf1371d902008-11-25 20:17:04 +0100981#define HF_GIF_MASK (1 << 0)
Alexander Graf3d6368e2008-11-25 20:17:07 +0100982#define HF_HIF_MASK (1 << 1)
983#define HF_VINTR_MASK (1 << 2)
Gleb Natapov95ba8273132009-04-21 17:45:08 +0300984#define HF_NMI_MASK (1 << 3)
Gleb Natapov44c11432009-05-11 13:35:52 +0300985#define HF_IRET_MASK (1 << 4)
Joerg Roedelec9e60b2010-11-29 17:51:47 +0100986#define HF_GUEST_MASK (1 << 5) /* VCPU is in guest-mode */
Alexander Graf1371d902008-11-25 20:17:04 +0100987
Avi Kivity4ecac3f2008-05-13 13:23:38 +0300988/*
989 * Hardware virtualization extension instructions may fault if a
990 * reboot turns off virtualization while processes are running.
991 * Trap the fault and ignore the instruction if that happens.
992 */
Avi Kivityb7c41452010-12-02 17:52:50 +0200993asmlinkage void kvm_spurious_fault(void);
Avi Kivity4ecac3f2008-05-13 13:23:38 +0300994
Avi Kivity5e520e62011-05-15 10:13:12 -0400995#define ____kvm_handle_fault_on_reboot(insn, cleanup_insn) \
Avi Kivity4ecac3f2008-05-13 13:23:38 +0300996 "666: " insn "\n\t" \
Avi Kivityb7c41452010-12-02 17:52:50 +0200997 "668: \n\t" \
Eduardo Habkost18b13e52008-08-19 20:00:08 -0300998 ".pushsection .fixup, \"ax\" \n" \
Avi Kivity4ecac3f2008-05-13 13:23:38 +0300999 "667: \n\t" \
Avi Kivity5e520e62011-05-15 10:13:12 -04001000 cleanup_insn "\n\t" \
Avi Kivityb7c41452010-12-02 17:52:50 +02001001 "cmpb $0, kvm_rebooting \n\t" \
1002 "jne 668b \n\t" \
Avi Kivity8ceed3472008-08-14 21:25:47 +03001003 __ASM_SIZE(push) " $666b \n\t" \
Avi Kivityb7c41452010-12-02 17:52:50 +02001004 "call kvm_spurious_fault \n\t" \
Avi Kivity4ecac3f2008-05-13 13:23:38 +03001005 ".popsection \n\t" \
H. Peter Anvin3ee89722012-04-20 13:41:59 -07001006 _ASM_EXTABLE(666b, 667b)
Avi Kivity4ecac3f2008-05-13 13:23:38 +03001007
Avi Kivity5e520e62011-05-15 10:13:12 -04001008#define __kvm_handle_fault_on_reboot(insn) \
1009 ____kvm_handle_fault_on_reboot(insn, "")
1010
Andrea Arcangelie930bff2008-07-25 16:24:52 +02001011#define KVM_ARCH_WANT_MMU_NOTIFIER
1012int kvm_unmap_hva(struct kvm *kvm, unsigned long hva);
Takuya Yoshikawab3ae2092012-07-02 17:56:33 +09001013int kvm_unmap_hva_range(struct kvm *kvm, unsigned long start, unsigned long end);
Andrea Arcangelie930bff2008-07-25 16:24:52 +02001014int kvm_age_hva(struct kvm *kvm, unsigned long hva);
Andrea Arcangeli8ee53822011-01-13 15:47:10 -08001015int kvm_test_age_hva(struct kvm *kvm, unsigned long hva);
Izik Eidus3da0dd42009-09-23 21:47:18 +03001016void kvm_set_spte_hva(struct kvm *kvm, unsigned long hva, pte_t pte);
Dong, Eddie82725b22009-03-30 16:21:08 +08001017int cpuid_maxphyaddr(struct kvm_vcpu *vcpu);
Yang Zhangc7c9c562013-01-25 10:18:51 +08001018int kvm_cpu_has_injectable_intr(struct kvm_vcpu *v);
Gleb Natapova1b37102009-07-09 15:33:52 +03001019int kvm_cpu_has_interrupt(struct kvm_vcpu *vcpu);
1020int kvm_arch_interrupt_allowed(struct kvm_vcpu *vcpu);
Gleb Natapov0b717852009-07-09 15:33:53 +03001021int kvm_cpu_get_interrupt(struct kvm_vcpu *v);
Jan Kiszka66450a22013-03-13 12:42:34 +01001022void kvm_vcpu_reset(struct kvm_vcpu *vcpu);
Andrea Arcangelie930bff2008-07-25 16:24:52 +02001023
Avi Kivity18863bd2009-09-07 11:12:18 +03001024void kvm_define_shared_msr(unsigned index, u32 msr);
Avi Kivityd5696722009-12-02 12:28:47 +02001025void kvm_set_shared_msr(unsigned index, u64 val, u64 mask);
Avi Kivity18863bd2009-09-07 11:12:18 +03001026
Jan Kiszkaf92653e2010-02-23 17:47:55 +01001027bool kvm_is_linear_rip(struct kvm_vcpu *vcpu, unsigned long linear_rip);
1028
Gleb Natapovaf585b92010-10-14 11:22:46 +02001029void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,
1030 struct kvm_async_pf *work);
1031void kvm_arch_async_page_present(struct kvm_vcpu *vcpu,
1032 struct kvm_async_pf *work);
Gleb Natapov56028d02010-10-17 18:13:42 +02001033void kvm_arch_async_page_ready(struct kvm_vcpu *vcpu,
1034 struct kvm_async_pf *work);
Gleb Natapov7c907052010-10-14 11:22:53 +02001035bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu *vcpu);
Gleb Natapovaf585b92010-10-14 11:22:46 +02001036extern bool kvm_find_async_pf_gfn(struct kvm_vcpu *vcpu, gfn_t gfn);
1037
Andre Przywaradb8fcef2010-12-21 11:12:01 +01001038void kvm_complete_insn_gp(struct kvm_vcpu *vcpu, int err);
1039
Gleb Natapovf5132b02011-11-10 14:57:22 +02001040int kvm_is_in_guest(void);
1041
1042void kvm_pmu_init(struct kvm_vcpu *vcpu);
1043void kvm_pmu_destroy(struct kvm_vcpu *vcpu);
1044void kvm_pmu_reset(struct kvm_vcpu *vcpu);
1045void kvm_pmu_cpuid_update(struct kvm_vcpu *vcpu);
1046bool kvm_pmu_msr(struct kvm_vcpu *vcpu, u32 msr);
1047int kvm_pmu_get_msr(struct kvm_vcpu *vcpu, u32 msr, u64 *data);
Paolo Bonziniafd80d82013-03-28 17:18:35 +01001048int kvm_pmu_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr_info);
Gleb Natapovf5132b02011-11-10 14:57:22 +02001049int kvm_pmu_read_pmc(struct kvm_vcpu *vcpu, unsigned pmc, u64 *data);
1050void kvm_handle_pmu_event(struct kvm_vcpu *vcpu);
1051void kvm_deliver_pmi(struct kvm_vcpu *vcpu);
1052
H. Peter Anvin1965aae2008-10-22 22:26:29 -07001053#endif /* _ASM_X86_KVM_HOST_H */