vmx.c 135.9 KB
Newer Older
A
Avi Kivity 已提交
1 2 3 4 5 6 7
/*
 * Kernel-based Virtual Machine driver for Linux
 *
 * This module enables machines with Intel VT-x extensions to run virtual
 * machines without emulation or binary translation.
 *
 * Copyright (C) 2006 Qumranet, Inc.
N
Nicolas Kaiser 已提交
8
 * Copyright 2010 Red Hat, Inc. and/or its affiliates.
A
Avi Kivity 已提交
9 10 11 12 13 14 15 16 17 18
 *
 * Authors:
 *   Avi Kivity   <avi@qumranet.com>
 *   Yaniv Kamay  <yaniv@qumranet.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 *
 */

19
#include "irq.h"
20
#include "mmu.h"
A
Avi Kivity 已提交
21

22
#include <linux/kvm_host.h>
A
Avi Kivity 已提交
23
#include <linux/module.h>
24
#include <linux/kernel.h>
A
Avi Kivity 已提交
25 26
#include <linux/mm.h>
#include <linux/highmem.h>
A
Alexey Dobriyan 已提交
27
#include <linux/sched.h>
28
#include <linux/moduleparam.h>
29
#include <linux/ftrace_event.h>
30
#include <linux/slab.h>
31
#include <linux/tboot.h>
32
#include "kvm_cache_regs.h"
33
#include "x86.h"
A
Avi Kivity 已提交
34

A
Avi Kivity 已提交
35
#include <asm/io.h>
A
Anthony Liguori 已提交
36
#include <asm/desc.h>
37
#include <asm/vmx.h>
38
#include <asm/virtext.h>
A
Andi Kleen 已提交
39
#include <asm/mce.h>
40 41
#include <asm/i387.h>
#include <asm/xcr.h>
A
Avi Kivity 已提交
42

43 44
#include "trace.h"

45
#define __ex(x) __kvm_handle_fault_on_reboot(x)
46 47
#define __ex_clear(x, reg) \
	____kvm_handle_fault_on_reboot(x, "xor " reg " , " reg)
48

A
Avi Kivity 已提交
49 50 51
MODULE_AUTHOR("Qumranet");
MODULE_LICENSE("GPL");

52
static int __read_mostly bypass_guest_pf = 1;
53
module_param(bypass_guest_pf, bool, S_IRUGO);
54

55
static int __read_mostly enable_vpid = 1;
56
module_param_named(vpid, enable_vpid, bool, 0444);
57

58
static int __read_mostly flexpriority_enabled = 1;
59
module_param_named(flexpriority, flexpriority_enabled, bool, S_IRUGO);
60

61
static int __read_mostly enable_ept = 1;
62
module_param_named(ept, enable_ept, bool, S_IRUGO);
S
Sheng Yang 已提交
63

64 65 66 67
static int __read_mostly enable_unrestricted_guest = 1;
module_param_named(unrestricted_guest,
			enable_unrestricted_guest, bool, S_IRUGO);

68
static int __read_mostly emulate_invalid_guest_state = 0;
69
module_param(emulate_invalid_guest_state, bool, S_IRUGO);
70

71 72 73
static int __read_mostly vmm_exclusive = 1;
module_param(vmm_exclusive, bool, S_IRUGO);

74 75 76
static int __read_mostly yield_on_hlt = 1;
module_param(yield_on_hlt, bool, S_IRUGO);

77 78 79 80 81 82 83 84
/*
 * If nested=1, nested virtualization is supported, i.e., guests may use
 * VMX and be a hypervisor for its own guests. If nested=0, guests may not
 * use VMX instructions.
 */
static int __read_mostly nested = 0;
module_param(nested, bool, S_IRUGO);

85 86 87 88 89
#define KVM_GUEST_CR0_MASK_UNRESTRICTED_GUEST				\
	(X86_CR0_WP | X86_CR0_NE | X86_CR0_NW | X86_CR0_CD)
#define KVM_GUEST_CR0_MASK						\
	(KVM_GUEST_CR0_MASK_UNRESTRICTED_GUEST | X86_CR0_PG | X86_CR0_PE)
#define KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST				\
90
	(X86_CR0_WP | X86_CR0_NE)
91 92
#define KVM_VM_CR0_ALWAYS_ON						\
	(KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST | X86_CR0_PG | X86_CR0_PE)
93 94 95 96
#define KVM_CR4_GUEST_OWNED_BITS				      \
	(X86_CR4_PVI | X86_CR4_DE | X86_CR4_PCE | X86_CR4_OSFXSR      \
	 | X86_CR4_OSXMMEXCPT)

97 98 99
#define KVM_PMODE_VM_CR4_ALWAYS_ON (X86_CR4_PAE | X86_CR4_VMXE)
#define KVM_RMODE_VM_CR4_ALWAYS_ON (X86_CR4_VME | X86_CR4_PAE | X86_CR4_VMXE)

100 101
#define RMODE_GUEST_OWNED_EFLAGS_BITS (~(X86_EFLAGS_IOPL | X86_EFLAGS_VM))

102 103 104 105
/*
 * These 2 parameters are used to config the controls for Pause-Loop Exiting:
 * ple_gap:    upper bound on the amount of time between two successive
 *             executions of PAUSE in a loop. Also indicate if ple enabled.
106
 *             According to test, this time is usually smaller than 128 cycles.
107 108 109 110 111 112
 * ple_window: upper bound on the amount of time a guest is allowed to execute
 *             in a PAUSE loop. Tests indicate that most spinlocks are held for
 *             less than 2^12 cycles
 * Time is measured based on a counter that runs at the same rate as the TSC,
 * refer SDM volume 3b section 21.6.13 & 22.1.3.
 */
113
#define KVM_VMX_DEFAULT_PLE_GAP    128
114 115 116 117 118 119 120
#define KVM_VMX_DEFAULT_PLE_WINDOW 4096
static int ple_gap = KVM_VMX_DEFAULT_PLE_GAP;
module_param(ple_gap, int, S_IRUGO);

static int ple_window = KVM_VMX_DEFAULT_PLE_WINDOW;
module_param(ple_window, int, S_IRUGO);

121 122
#define NR_AUTOLOAD_MSRS 1

123 124 125 126 127 128
struct vmcs {
	u32 revision_id;
	u32 abort;
	char data[0];
};

129 130 131 132 133 134 135 136 137 138 139 140
/*
 * Track a VMCS that may be loaded on a certain CPU. If it is (cpu!=-1), also
 * remember whether it was VMLAUNCHed, and maintain a linked list of all VMCSs
 * loaded on this CPU (so we can clear them if the CPU goes down).
 */
struct loaded_vmcs {
	struct vmcs *vmcs;
	int cpu;
	int launched;
	struct list_head loaded_vmcss_on_cpu_link;
};

141 142 143
struct shared_msr_entry {
	unsigned index;
	u64 data;
144
	u64 mask;
145 146
};

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
/*
 * struct vmcs12 describes the state that our guest hypervisor (L1) keeps for a
 * single nested guest (L2), hence the name vmcs12. Any VMX implementation has
 * a VMCS structure, and vmcs12 is our emulated VMX's VMCS. This structure is
 * stored in guest memory specified by VMPTRLD, but is opaque to the guest,
 * which must access it using VMREAD/VMWRITE/VMCLEAR instructions.
 * More than one of these structures may exist, if L1 runs multiple L2 guests.
 * nested_vmx_run() will use the data here to build a vmcs02: a VMCS for the
 * underlying hardware which will be used to run L2.
 * This structure is packed to ensure that its layout is identical across
 * machines (necessary for live migration).
 * If there are changes in this struct, VMCS12_REVISION must be changed.
 */
struct __packed vmcs12 {
	/* According to the Intel spec, a VMCS region must start with the
	 * following two fields. Then follow implementation-specific data.
	 */
	u32 revision_id;
	u32 abort;
};

/*
 * VMCS12_REVISION is an arbitrary id that should be changed if the content or
 * layout of struct vmcs12 is changed. MSR_IA32_VMX_BASIC returns this id, and
 * VMPTRLD verifies that the VMCS region that L1 is loading contains this id.
 */
#define VMCS12_REVISION 0x11e57ed0

/*
 * VMCS12_SIZE is the number of bytes L1 should allocate for the VMXON region
 * and any VMCS region. Although only sizeof(struct vmcs12) are used by the
 * current implementation, 4K are reserved to avoid future complications.
 */
#define VMCS12_SIZE 0x1000

182 183 184 185 186 187 188
/*
 * The nested_vmx structure is part of vcpu_vmx, and holds information we need
 * for correct emulation of VMX (i.e., nested VMX) on this vcpu.
 */
struct nested_vmx {
	/* Has the level1 guest done vmxon? */
	bool vmxon;
189 190 191 192 193 194

	/* The guest-physical address of the current VMCS L1 keeps for L2 */
	gpa_t current_vmptr;
	/* The host-usable pointer to the above */
	struct page *current_vmcs12_page;
	struct vmcs12 *current_vmcs12;
195 196
};

197
struct vcpu_vmx {
R
Rusty Russell 已提交
198
	struct kvm_vcpu       vcpu;
199
	unsigned long         host_rsp;
200
	u8                    fail;
A
Avi Kivity 已提交
201
	u8                    cpl;
202
	bool                  nmi_known_unmasked;
203
	u32                   exit_intr_info;
204
	u32                   idt_vectoring_info;
A
Avi Kivity 已提交
205
	ulong                 rflags;
206
	struct shared_msr_entry *guest_msrs;
207 208 209
	int                   nmsrs;
	int                   save_nmsrs;
#ifdef CONFIG_X86_64
210 211
	u64 		      msr_host_kernel_gs_base;
	u64 		      msr_guest_kernel_gs_base;
212
#endif
213 214 215 216 217 218 219 220
	/*
	 * loaded_vmcs points to the VMCS currently used in this vcpu. For a
	 * non-nested (L1) guest, it always points to vmcs01. For a nested
	 * guest (L2), it points to a different VMCS.
	 */
	struct loaded_vmcs    vmcs01;
	struct loaded_vmcs   *loaded_vmcs;
	bool                  __launched; /* temporary, used in vmx_vcpu_run */
221 222 223 224 225
	struct msr_autoload {
		unsigned nr;
		struct vmx_msr_entry guest[NR_AUTOLOAD_MSRS];
		struct vmx_msr_entry host[NR_AUTOLOAD_MSRS];
	} msr_autoload;
226 227 228
	struct {
		int           loaded;
		u16           fs_sel, gs_sel, ldt_sel;
229 230
		int           gs_ldt_reload_needed;
		int           fs_reload_needed;
M
Mike Day 已提交
231
	} host_state;
232
	struct {
233
		int vm86_active;
234
		ulong save_rflags;
235 236 237 238 239 240
		struct kvm_save_segment {
			u16 selector;
			unsigned long base;
			u32 limit;
			u32 ar;
		} tr, es, ds, fs, gs;
241
	} rmode;
A
Avi Kivity 已提交
242 243 244 245
	struct {
		u32 bitmask; /* 4 bits per segment (1 bit per field) */
		struct kvm_save_segment seg[8];
	} segment_cache;
246
	int vpid;
247
	bool emulation_required;
248 249 250 251 252

	/* Support for vnmi-less CPUs */
	int soft_vnmi_blocked;
	ktime_t entry_time;
	s64 vnmi_blocked_time;
A
Andi Kleen 已提交
253
	u32 exit_reason;
254 255

	bool rdtscp_enabled;
256 257 258

	/* Support for a guest hypervisor (nested VMX) */
	struct nested_vmx nested;
259 260
};

A
Avi Kivity 已提交
261 262 263 264 265 266 267 268 269
enum segment_cache_field {
	SEG_FIELD_SEL = 0,
	SEG_FIELD_BASE = 1,
	SEG_FIELD_LIMIT = 2,
	SEG_FIELD_AR = 3,

	SEG_FIELD_NR = 4
};

270 271
static inline struct vcpu_vmx *to_vmx(struct kvm_vcpu *vcpu)
{
R
Rusty Russell 已提交
272
	return container_of(vcpu, struct vcpu_vmx, vcpu);
273 274
}

275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
static inline struct vmcs12 *get_vmcs12(struct kvm_vcpu *vcpu)
{
	return to_vmx(vcpu)->nested.current_vmcs12;
}

static struct page *nested_get_page(struct kvm_vcpu *vcpu, gpa_t addr)
{
	struct page *page = gfn_to_page(vcpu->kvm, addr >> PAGE_SHIFT);
	if (is_error_page(page)) {
		kvm_release_page_clean(page);
		return NULL;
	}
	return page;
}

static void nested_release_page(struct page *page)
{
	kvm_release_page_dirty(page);
}

static void nested_release_page_clean(struct page *page)
{
	kvm_release_page_clean(page);
}

300
static u64 construct_eptp(unsigned long root_hpa);
301 302
static void kvm_cpu_vmxon(u64 addr);
static void kvm_cpu_vmxoff(void);
303
static void vmx_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3);
304
static int vmx_set_tss_addr(struct kvm *kvm, unsigned int addr);
305

A
Avi Kivity 已提交
306 307
static DEFINE_PER_CPU(struct vmcs *, vmxarea);
static DEFINE_PER_CPU(struct vmcs *, current_vmcs);
308 309 310 311 312
/*
 * We maintain a per-CPU linked-list of VMCS loaded on that CPU. This is needed
 * when a CPU is brought down, and we need to VMCLEAR all VMCSs loaded on it.
 */
static DEFINE_PER_CPU(struct list_head, loaded_vmcss_on_cpu);
313
static DEFINE_PER_CPU(struct desc_ptr, host_gdt);
A
Avi Kivity 已提交
314

315 316
static unsigned long *vmx_io_bitmap_a;
static unsigned long *vmx_io_bitmap_b;
317 318
static unsigned long *vmx_msr_bitmap_legacy;
static unsigned long *vmx_msr_bitmap_longmode;
319

A
Avi Kivity 已提交
320 321
static bool cpu_has_load_ia32_efer;

322 323 324
static DECLARE_BITMAP(vmx_vpid_bitmap, VMX_NR_VPIDS);
static DEFINE_SPINLOCK(vmx_vpid_lock);

325
static struct vmcs_config {
A
Avi Kivity 已提交
326 327 328
	int size;
	int order;
	u32 revision_id;
329 330
	u32 pin_based_exec_ctrl;
	u32 cpu_based_exec_ctrl;
331
	u32 cpu_based_2nd_exec_ctrl;
332 333 334
	u32 vmexit_ctrl;
	u32 vmentry_ctrl;
} vmcs_config;
A
Avi Kivity 已提交
335

H
Hannes Eder 已提交
336
static struct vmx_capability {
S
Sheng Yang 已提交
337 338 339 340
	u32 ept;
	u32 vpid;
} vmx_capability;

A
Avi Kivity 已提交
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
#define VMX_SEGMENT_FIELD(seg)					\
	[VCPU_SREG_##seg] = {                                   \
		.selector = GUEST_##seg##_SELECTOR,		\
		.base = GUEST_##seg##_BASE,		   	\
		.limit = GUEST_##seg##_LIMIT,		   	\
		.ar_bytes = GUEST_##seg##_AR_BYTES,	   	\
	}

static struct kvm_vmx_segment_field {
	unsigned selector;
	unsigned base;
	unsigned limit;
	unsigned ar_bytes;
} kvm_vmx_segment_fields[] = {
	VMX_SEGMENT_FIELD(CS),
	VMX_SEGMENT_FIELD(DS),
	VMX_SEGMENT_FIELD(ES),
	VMX_SEGMENT_FIELD(FS),
	VMX_SEGMENT_FIELD(GS),
	VMX_SEGMENT_FIELD(SS),
	VMX_SEGMENT_FIELD(TR),
	VMX_SEGMENT_FIELD(LDTR),
};

365 366
static u64 host_efer;

A
Avi Kivity 已提交
367 368
static void ept_save_pdptrs(struct kvm_vcpu *vcpu);

369
/*
B
Brian Gerst 已提交
370
 * Keep MSR_STAR at the end, as setup_msrs() will try to optimize it
371 372
 * away by decrementing the array size.
 */
A
Avi Kivity 已提交
373
static const u32 vmx_msr_index[] = {
374
#ifdef CONFIG_X86_64
375
	MSR_SYSCALL_MASK, MSR_LSTAR, MSR_CSTAR,
A
Avi Kivity 已提交
376
#endif
B
Brian Gerst 已提交
377
	MSR_EFER, MSR_TSC_AUX, MSR_STAR,
A
Avi Kivity 已提交
378
};
379
#define NR_VMX_MSR ARRAY_SIZE(vmx_msr_index)
A
Avi Kivity 已提交
380

381
static inline bool is_page_fault(u32 intr_info)
A
Avi Kivity 已提交
382 383 384
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
385
		(INTR_TYPE_HARD_EXCEPTION | PF_VECTOR | INTR_INFO_VALID_MASK);
A
Avi Kivity 已提交
386 387
}

388
static inline bool is_no_device(u32 intr_info)
389 390 391
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
392
		(INTR_TYPE_HARD_EXCEPTION | NM_VECTOR | INTR_INFO_VALID_MASK);
393 394
}

395
static inline bool is_invalid_opcode(u32 intr_info)
396 397 398
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
399
		(INTR_TYPE_HARD_EXCEPTION | UD_VECTOR | INTR_INFO_VALID_MASK);
400 401
}

402
static inline bool is_external_interrupt(u32 intr_info)
A
Avi Kivity 已提交
403 404 405 406 407
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VALID_MASK))
		== (INTR_TYPE_EXT_INTR | INTR_INFO_VALID_MASK);
}

408
static inline bool is_machine_check(u32 intr_info)
A
Andi Kleen 已提交
409 410 411 412 413 414
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
		(INTR_TYPE_HARD_EXCEPTION | MC_VECTOR | INTR_INFO_VALID_MASK);
}

415
static inline bool cpu_has_vmx_msr_bitmap(void)
S
Sheng Yang 已提交
416
{
417
	return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS;
S
Sheng Yang 已提交
418 419
}

420
static inline bool cpu_has_vmx_tpr_shadow(void)
421
{
422
	return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW;
423 424
}

425
static inline bool vm_need_tpr_shadow(struct kvm *kvm)
426
{
427
	return (cpu_has_vmx_tpr_shadow()) && (irqchip_in_kernel(kvm));
428 429
}

430
static inline bool cpu_has_secondary_exec_ctrls(void)
431
{
432 433
	return vmcs_config.cpu_based_exec_ctrl &
		CPU_BASED_ACTIVATE_SECONDARY_CONTROLS;
434 435
}

436
static inline bool cpu_has_vmx_virtualize_apic_accesses(void)
437
{
438 439 440 441 442 443 444 445
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES;
}

static inline bool cpu_has_vmx_flexpriority(void)
{
	return cpu_has_vmx_tpr_shadow() &&
		cpu_has_vmx_virtualize_apic_accesses();
446 447
}

448 449
static inline bool cpu_has_vmx_ept_execute_only(void)
{
450
	return vmx_capability.ept & VMX_EPT_EXECUTE_ONLY_BIT;
451 452 453 454
}

static inline bool cpu_has_vmx_eptp_uncacheable(void)
{
455
	return vmx_capability.ept & VMX_EPTP_UC_BIT;
456 457 458 459
}

static inline bool cpu_has_vmx_eptp_writeback(void)
{
460
	return vmx_capability.ept & VMX_EPTP_WB_BIT;
461 462 463 464
}

static inline bool cpu_has_vmx_ept_2m_page(void)
{
465
	return vmx_capability.ept & VMX_EPT_2MB_PAGE_BIT;
466 467
}

468 469
static inline bool cpu_has_vmx_ept_1g_page(void)
{
470
	return vmx_capability.ept & VMX_EPT_1GB_PAGE_BIT;
471 472
}

473 474 475 476 477
static inline bool cpu_has_vmx_ept_4levels(void)
{
	return vmx_capability.ept & VMX_EPT_PAGE_WALK_4_BIT;
}

478
static inline bool cpu_has_vmx_invept_individual_addr(void)
S
Sheng Yang 已提交
479
{
480
	return vmx_capability.ept & VMX_EPT_EXTENT_INDIVIDUAL_BIT;
S
Sheng Yang 已提交
481 482
}

483
static inline bool cpu_has_vmx_invept_context(void)
S
Sheng Yang 已提交
484
{
485
	return vmx_capability.ept & VMX_EPT_EXTENT_CONTEXT_BIT;
S
Sheng Yang 已提交
486 487
}

488
static inline bool cpu_has_vmx_invept_global(void)
S
Sheng Yang 已提交
489
{
490
	return vmx_capability.ept & VMX_EPT_EXTENT_GLOBAL_BIT;
S
Sheng Yang 已提交
491 492
}

493 494 495 496 497
static inline bool cpu_has_vmx_invvpid_single(void)
{
	return vmx_capability.vpid & VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT;
}

498 499 500 501 502
static inline bool cpu_has_vmx_invvpid_global(void)
{
	return vmx_capability.vpid & VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT;
}

503
static inline bool cpu_has_vmx_ept(void)
S
Sheng Yang 已提交
504
{
505 506
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_ENABLE_EPT;
S
Sheng Yang 已提交
507 508
}

509
static inline bool cpu_has_vmx_unrestricted_guest(void)
510 511 512 513 514
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_UNRESTRICTED_GUEST;
}

515
static inline bool cpu_has_vmx_ple(void)
516 517 518 519 520
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_PAUSE_LOOP_EXITING;
}

521
static inline bool vm_need_virtualize_apic_accesses(struct kvm *kvm)
522
{
523
	return flexpriority_enabled && irqchip_in_kernel(kvm);
524 525
}

526
static inline bool cpu_has_vmx_vpid(void)
527
{
528 529
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_ENABLE_VPID;
530 531
}

532
static inline bool cpu_has_vmx_rdtscp(void)
533 534 535 536 537
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_RDTSCP;
}

538
static inline bool cpu_has_virtual_nmis(void)
539 540 541 542
{
	return vmcs_config.pin_based_exec_ctrl & PIN_BASED_VIRTUAL_NMIS;
}

543 544 545 546 547 548
static inline bool cpu_has_vmx_wbinvd_exit(void)
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_WBINVD_EXITING;
}

549 550 551 552 553
static inline bool report_flexpriority(void)
{
	return flexpriority_enabled;
}

R
Rusty Russell 已提交
554
static int __find_msr_index(struct vcpu_vmx *vmx, u32 msr)
555 556 557
{
	int i;

558
	for (i = 0; i < vmx->nmsrs; ++i)
559
		if (vmx_msr_index[vmx->guest_msrs[i].index] == msr)
560 561 562 563
			return i;
	return -1;
}

564 565 566 567 568 569 570 571
static inline void __invvpid(int ext, u16 vpid, gva_t gva)
{
    struct {
	u64 vpid : 16;
	u64 rsvd : 48;
	u64 gva;
    } operand = { vpid, 0, gva };

572
    asm volatile (__ex(ASM_VMX_INVVPID)
573 574 575 576 577
		  /* CF==1 or ZF==1 --> rc = -1 */
		  "; ja 1f ; ud2 ; 1:"
		  : : "a"(&operand), "c"(ext) : "cc", "memory");
}

578 579 580 581 582 583
static inline void __invept(int ext, u64 eptp, gpa_t gpa)
{
	struct {
		u64 eptp, gpa;
	} operand = {eptp, gpa};

584
	asm volatile (__ex(ASM_VMX_INVEPT)
585 586 587 588 589
			/* CF==1 or ZF==1 --> rc = -1 */
			"; ja 1f ; ud2 ; 1:\n"
			: : "a" (&operand), "c" (ext) : "cc", "memory");
}

590
static struct shared_msr_entry *find_msr_entry(struct vcpu_vmx *vmx, u32 msr)
591 592 593
{
	int i;

R
Rusty Russell 已提交
594
	i = __find_msr_index(vmx, msr);
595
	if (i >= 0)
596
		return &vmx->guest_msrs[i];
A
Al Viro 已提交
597
	return NULL;
598 599
}

A
Avi Kivity 已提交
600 601 602 603 604
static void vmcs_clear(struct vmcs *vmcs)
{
	u64 phys_addr = __pa(vmcs);
	u8 error;

605
	asm volatile (__ex(ASM_VMX_VMCLEAR_RAX) "; setna %0"
606
		      : "=qm"(error) : "a"(&phys_addr), "m"(phys_addr)
A
Avi Kivity 已提交
607 608 609 610 611 612
		      : "cc", "memory");
	if (error)
		printk(KERN_ERR "kvm: vmclear fail: %p/%llx\n",
		       vmcs, phys_addr);
}

613 614 615 616 617 618 619
static inline void loaded_vmcs_init(struct loaded_vmcs *loaded_vmcs)
{
	vmcs_clear(loaded_vmcs->vmcs);
	loaded_vmcs->cpu = -1;
	loaded_vmcs->launched = 0;
}

620 621 622 623 624 625
static void vmcs_load(struct vmcs *vmcs)
{
	u64 phys_addr = __pa(vmcs);
	u8 error;

	asm volatile (__ex(ASM_VMX_VMPTRLD_RAX) "; setna %0"
626
			: "=qm"(error) : "a"(&phys_addr), "m"(phys_addr)
627 628 629 630 631 632
			: "cc", "memory");
	if (error)
		printk(KERN_ERR "kvm: vmptrld %p/%llx fail\n",
		       vmcs, phys_addr);
}

633
static void __loaded_vmcs_clear(void *arg)
A
Avi Kivity 已提交
634
{
635
	struct loaded_vmcs *loaded_vmcs = arg;
636
	int cpu = raw_smp_processor_id();
A
Avi Kivity 已提交
637

638 639 640
	if (loaded_vmcs->cpu != cpu)
		return; /* vcpu migration can race with cpu offline */
	if (per_cpu(current_vmcs, cpu) == loaded_vmcs->vmcs)
A
Avi Kivity 已提交
641
		per_cpu(current_vmcs, cpu) = NULL;
642 643
	list_del(&loaded_vmcs->loaded_vmcss_on_cpu_link);
	loaded_vmcs_init(loaded_vmcs);
A
Avi Kivity 已提交
644 645
}

646
static void loaded_vmcs_clear(struct loaded_vmcs *loaded_vmcs)
A
Avi Kivity 已提交
647
{
648 649 650
	if (loaded_vmcs->cpu != -1)
		smp_call_function_single(
			loaded_vmcs->cpu, __loaded_vmcs_clear, loaded_vmcs, 1);
A
Avi Kivity 已提交
651 652
}

653
static inline void vpid_sync_vcpu_single(struct vcpu_vmx *vmx)
654 655 656 657
{
	if (vmx->vpid == 0)
		return;

658 659
	if (cpu_has_vmx_invvpid_single())
		__invvpid(VMX_VPID_EXTENT_SINGLE_CONTEXT, vmx->vpid, 0);
660 661
}

662 663 664 665 666 667 668 669 670
static inline void vpid_sync_vcpu_global(void)
{
	if (cpu_has_vmx_invvpid_global())
		__invvpid(VMX_VPID_EXTENT_ALL_CONTEXT, 0, 0);
}

static inline void vpid_sync_context(struct vcpu_vmx *vmx)
{
	if (cpu_has_vmx_invvpid_single())
671
		vpid_sync_vcpu_single(vmx);
672 673 674 675
	else
		vpid_sync_vcpu_global();
}

676 677 678 679 680 681 682 683
static inline void ept_sync_global(void)
{
	if (cpu_has_vmx_invept_global())
		__invept(VMX_EPT_EXTENT_GLOBAL, 0, 0);
}

static inline void ept_sync_context(u64 eptp)
{
684
	if (enable_ept) {
685 686 687 688 689 690 691 692 693
		if (cpu_has_vmx_invept_context())
			__invept(VMX_EPT_EXTENT_CONTEXT, eptp, 0);
		else
			ept_sync_global();
	}
}

static inline void ept_sync_individual_addr(u64 eptp, gpa_t gpa)
{
694
	if (enable_ept) {
695 696 697 698 699 700 701 702
		if (cpu_has_vmx_invept_individual_addr())
			__invept(VMX_EPT_EXTENT_INDIVIDUAL_ADDR,
					eptp, gpa);
		else
			ept_sync_context(eptp);
	}
}

A
Avi Kivity 已提交
703
static __always_inline unsigned long vmcs_readl(unsigned long field)
A
Avi Kivity 已提交
704
{
705
	unsigned long value;
A
Avi Kivity 已提交
706

707 708
	asm volatile (__ex_clear(ASM_VMX_VMREAD_RDX_RAX, "%0")
		      : "=a"(value) : "d"(field) : "cc");
A
Avi Kivity 已提交
709 710 711
	return value;
}

A
Avi Kivity 已提交
712
static __always_inline u16 vmcs_read16(unsigned long field)
A
Avi Kivity 已提交
713 714 715 716
{
	return vmcs_readl(field);
}

A
Avi Kivity 已提交
717
static __always_inline u32 vmcs_read32(unsigned long field)
A
Avi Kivity 已提交
718 719 720 721
{
	return vmcs_readl(field);
}

A
Avi Kivity 已提交
722
static __always_inline u64 vmcs_read64(unsigned long field)
A
Avi Kivity 已提交
723
{
724
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
725 726 727 728 729 730
	return vmcs_readl(field);
#else
	return vmcs_readl(field) | ((u64)vmcs_readl(field+1) << 32);
#endif
}

731 732 733 734 735 736 737
static noinline void vmwrite_error(unsigned long field, unsigned long value)
{
	printk(KERN_ERR "vmwrite error: reg %lx value %lx (err %d)\n",
	       field, value, vmcs_read32(VM_INSTRUCTION_ERROR));
	dump_stack();
}

A
Avi Kivity 已提交
738 739 740 741
static void vmcs_writel(unsigned long field, unsigned long value)
{
	u8 error;

742
	asm volatile (__ex(ASM_VMX_VMWRITE_RAX_RDX) "; setna %0"
M
Mike Day 已提交
743
		       : "=q"(error) : "a"(value), "d"(field) : "cc");
744 745
	if (unlikely(error))
		vmwrite_error(field, value);
A
Avi Kivity 已提交
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
}

static void vmcs_write16(unsigned long field, u16 value)
{
	vmcs_writel(field, value);
}

static void vmcs_write32(unsigned long field, u32 value)
{
	vmcs_writel(field, value);
}

static void vmcs_write64(unsigned long field, u64 value)
{
	vmcs_writel(field, value);
761
#ifndef CONFIG_X86_64
A
Avi Kivity 已提交
762 763 764 765 766
	asm volatile ("");
	vmcs_writel(field+1, value >> 32);
#endif
}

767 768 769 770 771 772 773 774 775 776
static void vmcs_clear_bits(unsigned long field, u32 mask)
{
	vmcs_writel(field, vmcs_readl(field) & ~mask);
}

static void vmcs_set_bits(unsigned long field, u32 mask)
{
	vmcs_writel(field, vmcs_readl(field) | mask);
}

A
Avi Kivity 已提交
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
static void vmx_segment_cache_clear(struct vcpu_vmx *vmx)
{
	vmx->segment_cache.bitmask = 0;
}

static bool vmx_segment_cache_test_set(struct vcpu_vmx *vmx, unsigned seg,
				       unsigned field)
{
	bool ret;
	u32 mask = 1 << (seg * SEG_FIELD_NR + field);

	if (!(vmx->vcpu.arch.regs_avail & (1 << VCPU_EXREG_SEGMENTS))) {
		vmx->vcpu.arch.regs_avail |= (1 << VCPU_EXREG_SEGMENTS);
		vmx->segment_cache.bitmask = 0;
	}
	ret = vmx->segment_cache.bitmask & mask;
	vmx->segment_cache.bitmask |= mask;
	return ret;
}

static u16 vmx_read_guest_seg_selector(struct vcpu_vmx *vmx, unsigned seg)
{
	u16 *p = &vmx->segment_cache.seg[seg].selector;

	if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_SEL))
		*p = vmcs_read16(kvm_vmx_segment_fields[seg].selector);
	return *p;
}

static ulong vmx_read_guest_seg_base(struct vcpu_vmx *vmx, unsigned seg)
{
	ulong *p = &vmx->segment_cache.seg[seg].base;

	if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_BASE))
		*p = vmcs_readl(kvm_vmx_segment_fields[seg].base);
	return *p;
}

static u32 vmx_read_guest_seg_limit(struct vcpu_vmx *vmx, unsigned seg)
{
	u32 *p = &vmx->segment_cache.seg[seg].limit;

	if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_LIMIT))
		*p = vmcs_read32(kvm_vmx_segment_fields[seg].limit);
	return *p;
}

static u32 vmx_read_guest_seg_ar(struct vcpu_vmx *vmx, unsigned seg)
{
	u32 *p = &vmx->segment_cache.seg[seg].ar;

	if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_AR))
		*p = vmcs_read32(kvm_vmx_segment_fields[seg].ar_bytes);
	return *p;
}

833 834 835 836
static void update_exception_bitmap(struct kvm_vcpu *vcpu)
{
	u32 eb;

J
Jan Kiszka 已提交
837 838 839 840 841 842
	eb = (1u << PF_VECTOR) | (1u << UD_VECTOR) | (1u << MC_VECTOR) |
	     (1u << NM_VECTOR) | (1u << DB_VECTOR);
	if ((vcpu->guest_debug &
	     (KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_SW_BP)) ==
	    (KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_SW_BP))
		eb |= 1u << BP_VECTOR;
843
	if (to_vmx(vcpu)->rmode.vm86_active)
844
		eb = ~0;
845
	if (enable_ept)
846
		eb &= ~(1u << PF_VECTOR); /* bypass_guest_pf = 0 */
847 848
	if (vcpu->fpu_active)
		eb &= ~(1u << NM_VECTOR);
849 850 851
	vmcs_write32(EXCEPTION_BITMAP, eb);
}

852 853 854 855 856
static void clear_atomic_switch_msr(struct vcpu_vmx *vmx, unsigned msr)
{
	unsigned i;
	struct msr_autoload *m = &vmx->msr_autoload;

A
Avi Kivity 已提交
857 858 859 860 861 862
	if (msr == MSR_EFER && cpu_has_load_ia32_efer) {
		vmcs_clear_bits(VM_ENTRY_CONTROLS, VM_ENTRY_LOAD_IA32_EFER);
		vmcs_clear_bits(VM_EXIT_CONTROLS, VM_EXIT_LOAD_IA32_EFER);
		return;
	}

863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881
	for (i = 0; i < m->nr; ++i)
		if (m->guest[i].index == msr)
			break;

	if (i == m->nr)
		return;
	--m->nr;
	m->guest[i] = m->guest[m->nr];
	m->host[i] = m->host[m->nr];
	vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, m->nr);
	vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, m->nr);
}

static void add_atomic_switch_msr(struct vcpu_vmx *vmx, unsigned msr,
				  u64 guest_val, u64 host_val)
{
	unsigned i;
	struct msr_autoload *m = &vmx->msr_autoload;

A
Avi Kivity 已提交
882 883 884 885 886 887 888 889
	if (msr == MSR_EFER && cpu_has_load_ia32_efer) {
		vmcs_write64(GUEST_IA32_EFER, guest_val);
		vmcs_write64(HOST_IA32_EFER, host_val);
		vmcs_set_bits(VM_ENTRY_CONTROLS, VM_ENTRY_LOAD_IA32_EFER);
		vmcs_set_bits(VM_EXIT_CONTROLS, VM_EXIT_LOAD_IA32_EFER);
		return;
	}

890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905
	for (i = 0; i < m->nr; ++i)
		if (m->guest[i].index == msr)
			break;

	if (i == m->nr) {
		++m->nr;
		vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, m->nr);
		vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, m->nr);
	}

	m->guest[i].index = msr;
	m->guest[i].value = guest_val;
	m->host[i].index = msr;
	m->host[i].value = host_val;
}

906 907 908 909 910
static void reload_tss(void)
{
	/*
	 * VT restores TR but not its size.  Useless.
	 */
911
	struct desc_ptr *gdt = &__get_cpu_var(host_gdt);
912
	struct desc_struct *descs;
913

914
	descs = (void *)gdt->address;
915 916 917 918
	descs[GDT_ENTRY_TSS].type = 9; /* available TSS */
	load_TR_desc();
}

A
Avi Kivity 已提交
919
static bool update_transition_efer(struct vcpu_vmx *vmx, int efer_offset)
920
{
R
Roel Kluin 已提交
921
	u64 guest_efer;
922 923
	u64 ignore_bits;

924
	guest_efer = vmx->vcpu.arch.efer;
R
Roel Kluin 已提交
925

926 927 928 929 930 931 932 933 934 935 936 937 938
	/*
	 * NX is emulated; LMA and LME handled by hardware; SCE meaninless
	 * outside long mode
	 */
	ignore_bits = EFER_NX | EFER_SCE;
#ifdef CONFIG_X86_64
	ignore_bits |= EFER_LMA | EFER_LME;
	/* SCE is meaningful only in long mode on Intel */
	if (guest_efer & EFER_LMA)
		ignore_bits &= ~(u64)EFER_SCE;
#endif
	guest_efer &= ~ignore_bits;
	guest_efer |= host_efer & ignore_bits;
939
	vmx->guest_msrs[efer_offset].data = guest_efer;
940
	vmx->guest_msrs[efer_offset].mask = ~ignore_bits;
941 942 943 944 945 946 947 948 949 950 951

	clear_atomic_switch_msr(vmx, MSR_EFER);
	/* On ept, can't emulate nx, and must switch nx atomically */
	if (enable_ept && ((vmx->vcpu.arch.efer ^ host_efer) & EFER_NX)) {
		guest_efer = vmx->vcpu.arch.efer;
		if (!(guest_efer & EFER_LMA))
			guest_efer &= ~EFER_LME;
		add_atomic_switch_msr(vmx, MSR_EFER, guest_efer, host_efer);
		return false;
	}

952
	return true;
953 954
}

955 956
static unsigned long segment_base(u16 selector)
{
957
	struct desc_ptr *gdt = &__get_cpu_var(host_gdt);
958 959 960 961 962 963 964
	struct desc_struct *d;
	unsigned long table_base;
	unsigned long v;

	if (!(selector & ~3))
		return 0;

965
	table_base = gdt->address;
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990

	if (selector & 4) {           /* from ldt */
		u16 ldt_selector = kvm_read_ldt();

		if (!(ldt_selector & ~3))
			return 0;

		table_base = segment_base(ldt_selector);
	}
	d = (struct desc_struct *)(table_base + (selector & ~7));
	v = get_desc_base(d);
#ifdef CONFIG_X86_64
       if (d->s == 0 && (d->type == 2 || d->type == 9 || d->type == 11))
               v |= ((unsigned long)((struct ldttss_desc64 *)d)->base3) << 32;
#endif
	return v;
}

static inline unsigned long kvm_read_tr_base(void)
{
	u16 tr;
	asm("str %0" : "=g"(tr));
	return segment_base(tr);
}

991
static void vmx_save_host_state(struct kvm_vcpu *vcpu)
992
{
993
	struct vcpu_vmx *vmx = to_vmx(vcpu);
994
	int i;
995

996
	if (vmx->host_state.loaded)
997 998
		return;

999
	vmx->host_state.loaded = 1;
1000 1001 1002 1003
	/*
	 * Set host fs and gs selectors.  Unfortunately, 22.2.3 does not
	 * allow segment selectors with cpl > 0 or ti == 1.
	 */
1004
	vmx->host_state.ldt_sel = kvm_read_ldt();
1005
	vmx->host_state.gs_ldt_reload_needed = vmx->host_state.ldt_sel;
1006
	savesegment(fs, vmx->host_state.fs_sel);
1007
	if (!(vmx->host_state.fs_sel & 7)) {
1008
		vmcs_write16(HOST_FS_SELECTOR, vmx->host_state.fs_sel);
1009 1010
		vmx->host_state.fs_reload_needed = 0;
	} else {
1011
		vmcs_write16(HOST_FS_SELECTOR, 0);
1012
		vmx->host_state.fs_reload_needed = 1;
1013
	}
1014
	savesegment(gs, vmx->host_state.gs_sel);
1015 1016
	if (!(vmx->host_state.gs_sel & 7))
		vmcs_write16(HOST_GS_SELECTOR, vmx->host_state.gs_sel);
1017 1018
	else {
		vmcs_write16(HOST_GS_SELECTOR, 0);
1019
		vmx->host_state.gs_ldt_reload_needed = 1;
1020 1021 1022 1023 1024 1025
	}

#ifdef CONFIG_X86_64
	vmcs_writel(HOST_FS_BASE, read_msr(MSR_FS_BASE));
	vmcs_writel(HOST_GS_BASE, read_msr(MSR_GS_BASE));
#else
1026 1027
	vmcs_writel(HOST_FS_BASE, segment_base(vmx->host_state.fs_sel));
	vmcs_writel(HOST_GS_BASE, segment_base(vmx->host_state.gs_sel));
1028
#endif
1029 1030

#ifdef CONFIG_X86_64
1031 1032
	rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base);
	if (is_long_mode(&vmx->vcpu))
1033
		wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base);
1034
#endif
1035 1036
	for (i = 0; i < vmx->save_nmsrs; ++i)
		kvm_set_shared_msr(vmx->guest_msrs[i].index,
1037 1038
				   vmx->guest_msrs[i].data,
				   vmx->guest_msrs[i].mask);
1039 1040
}

1041
static void __vmx_load_host_state(struct vcpu_vmx *vmx)
1042
{
1043
	if (!vmx->host_state.loaded)
1044 1045
		return;

1046
	++vmx->vcpu.stat.host_state_reload;
1047
	vmx->host_state.loaded = 0;
1048 1049 1050 1051
#ifdef CONFIG_X86_64
	if (is_long_mode(&vmx->vcpu))
		rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base);
#endif
1052
	if (vmx->host_state.gs_ldt_reload_needed) {
1053
		kvm_load_ldt(vmx->host_state.ldt_sel);
1054
#ifdef CONFIG_X86_64
1055 1056 1057
		load_gs_index(vmx->host_state.gs_sel);
#else
		loadsegment(gs, vmx->host_state.gs_sel);
1058 1059
#endif
	}
1060 1061
	if (vmx->host_state.fs_reload_needed)
		loadsegment(fs, vmx->host_state.fs_sel);
1062
	reload_tss();
1063
#ifdef CONFIG_X86_64
1064
	wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base);
1065
#endif
1066 1067
	if (current_thread_info()->status & TS_USEDFPU)
		clts();
1068
	load_gdt(&__get_cpu_var(host_gdt));
1069 1070
}

1071 1072 1073 1074 1075 1076 1077
static void vmx_load_host_state(struct vcpu_vmx *vmx)
{
	preempt_disable();
	__vmx_load_host_state(vmx);
	preempt_enable();
}

A
Avi Kivity 已提交
1078 1079 1080 1081
/*
 * Switches to specified vcpu, until a matching vcpu_put(), but assumes
 * vcpu mutex is already taken.
 */
1082
static void vmx_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
A
Avi Kivity 已提交
1083
{
1084
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1085
	u64 phys_addr = __pa(per_cpu(vmxarea, cpu));
A
Avi Kivity 已提交
1086

1087 1088
	if (!vmm_exclusive)
		kvm_cpu_vmxon(phys_addr);
1089 1090
	else if (vmx->loaded_vmcs->cpu != cpu)
		loaded_vmcs_clear(vmx->loaded_vmcs);
A
Avi Kivity 已提交
1091

1092 1093 1094
	if (per_cpu(current_vmcs, cpu) != vmx->loaded_vmcs->vmcs) {
		per_cpu(current_vmcs, cpu) = vmx->loaded_vmcs->vmcs;
		vmcs_load(vmx->loaded_vmcs->vmcs);
A
Avi Kivity 已提交
1095 1096
	}

1097
	if (vmx->loaded_vmcs->cpu != cpu) {
1098
		struct desc_ptr *gdt = &__get_cpu_var(host_gdt);
A
Avi Kivity 已提交
1099 1100
		unsigned long sysenter_esp;

1101
		kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu);
1102
		local_irq_disable();
1103 1104
		list_add(&vmx->loaded_vmcs->loaded_vmcss_on_cpu_link,
			 &per_cpu(loaded_vmcss_on_cpu, cpu));
1105 1106
		local_irq_enable();

A
Avi Kivity 已提交
1107 1108 1109 1110
		/*
		 * Linux uses per-cpu TSS and GDT, so set these when switching
		 * processors.
		 */
1111
		vmcs_writel(HOST_TR_BASE, kvm_read_tr_base()); /* 22.2.4 */
1112
		vmcs_writel(HOST_GDTR_BASE, gdt->address);   /* 22.2.4 */
A
Avi Kivity 已提交
1113 1114 1115

		rdmsrl(MSR_IA32_SYSENTER_ESP, sysenter_esp);
		vmcs_writel(HOST_IA32_SYSENTER_ESP, sysenter_esp); /* 22.2.3 */
1116
		vmx->loaded_vmcs->cpu = cpu;
A
Avi Kivity 已提交
1117 1118 1119 1120 1121
	}
}

static void vmx_vcpu_put(struct kvm_vcpu *vcpu)
{
1122
	__vmx_load_host_state(to_vmx(vcpu));
1123
	if (!vmm_exclusive) {
1124 1125
		__loaded_vmcs_clear(to_vmx(vcpu)->loaded_vmcs);
		vcpu->cpu = -1;
1126 1127
		kvm_cpu_vmxoff();
	}
A
Avi Kivity 已提交
1128 1129
}

1130 1131
static void vmx_fpu_activate(struct kvm_vcpu *vcpu)
{
1132 1133
	ulong cr0;

1134 1135 1136
	if (vcpu->fpu_active)
		return;
	vcpu->fpu_active = 1;
1137 1138 1139 1140
	cr0 = vmcs_readl(GUEST_CR0);
	cr0 &= ~(X86_CR0_TS | X86_CR0_MP);
	cr0 |= kvm_read_cr0_bits(vcpu, X86_CR0_TS | X86_CR0_MP);
	vmcs_writel(GUEST_CR0, cr0);
1141
	update_exception_bitmap(vcpu);
1142 1143
	vcpu->arch.cr0_guest_owned_bits = X86_CR0_TS;
	vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits);
1144 1145
}

1146 1147
static void vmx_decache_cr0_guest_bits(struct kvm_vcpu *vcpu);

1148 1149
static void vmx_fpu_deactivate(struct kvm_vcpu *vcpu)
{
1150
	vmx_decache_cr0_guest_bits(vcpu);
1151
	vmcs_set_bits(GUEST_CR0, X86_CR0_TS | X86_CR0_MP);
1152
	update_exception_bitmap(vcpu);
1153 1154 1155
	vcpu->arch.cr0_guest_owned_bits = 0;
	vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits);
	vmcs_writel(CR0_READ_SHADOW, vcpu->arch.cr0);
1156 1157
}

A
Avi Kivity 已提交
1158 1159
static unsigned long vmx_get_rflags(struct kvm_vcpu *vcpu)
{
1160
	unsigned long rflags, save_rflags;
1161

A
Avi Kivity 已提交
1162 1163 1164 1165 1166 1167 1168 1169 1170
	if (!test_bit(VCPU_EXREG_RFLAGS, (ulong *)&vcpu->arch.regs_avail)) {
		__set_bit(VCPU_EXREG_RFLAGS, (ulong *)&vcpu->arch.regs_avail);
		rflags = vmcs_readl(GUEST_RFLAGS);
		if (to_vmx(vcpu)->rmode.vm86_active) {
			rflags &= RMODE_GUEST_OWNED_EFLAGS_BITS;
			save_rflags = to_vmx(vcpu)->rmode.save_rflags;
			rflags |= save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS;
		}
		to_vmx(vcpu)->rflags = rflags;
1171
	}
A
Avi Kivity 已提交
1172
	return to_vmx(vcpu)->rflags;
A
Avi Kivity 已提交
1173 1174 1175 1176
}

static void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags)
{
A
Avi Kivity 已提交
1177
	__set_bit(VCPU_EXREG_RFLAGS, (ulong *)&vcpu->arch.regs_avail);
A
Avi Kivity 已提交
1178
	__clear_bit(VCPU_EXREG_CPL, (ulong *)&vcpu->arch.regs_avail);
A
Avi Kivity 已提交
1179
	to_vmx(vcpu)->rflags = rflags;
1180 1181
	if (to_vmx(vcpu)->rmode.vm86_active) {
		to_vmx(vcpu)->rmode.save_rflags = rflags;
1182
		rflags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM;
1183
	}
A
Avi Kivity 已提交
1184 1185 1186
	vmcs_writel(GUEST_RFLAGS, rflags);
}

1187 1188 1189 1190 1191 1192
static u32 vmx_get_interrupt_shadow(struct kvm_vcpu *vcpu, int mask)
{
	u32 interruptibility = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO);
	int ret = 0;

	if (interruptibility & GUEST_INTR_STATE_STI)
1193
		ret |= KVM_X86_SHADOW_INT_STI;
1194
	if (interruptibility & GUEST_INTR_STATE_MOV_SS)
1195
		ret |= KVM_X86_SHADOW_INT_MOV_SS;
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206

	return ret & mask;
}

static void vmx_set_interrupt_shadow(struct kvm_vcpu *vcpu, int mask)
{
	u32 interruptibility_old = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO);
	u32 interruptibility = interruptibility_old;

	interruptibility &= ~(GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS);

1207
	if (mask & KVM_X86_SHADOW_INT_MOV_SS)
1208
		interruptibility |= GUEST_INTR_STATE_MOV_SS;
1209
	else if (mask & KVM_X86_SHADOW_INT_STI)
1210 1211 1212 1213 1214 1215
		interruptibility |= GUEST_INTR_STATE_STI;

	if ((interruptibility != interruptibility_old))
		vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, interruptibility);
}

A
Avi Kivity 已提交
1216 1217 1218 1219
static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
{
	unsigned long rip;

1220
	rip = kvm_rip_read(vcpu);
A
Avi Kivity 已提交
1221
	rip += vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
1222
	kvm_rip_write(vcpu, rip);
A
Avi Kivity 已提交
1223

1224 1225
	/* skipping an emulated instruction also counts */
	vmx_set_interrupt_shadow(vcpu, 0);
A
Avi Kivity 已提交
1226 1227
}

1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
static void vmx_clear_hlt(struct kvm_vcpu *vcpu)
{
	/* Ensure that we clear the HLT state in the VMCS.  We don't need to
	 * explicitly skip the instruction because if the HLT state is set, then
	 * the instruction is already executing and RIP has already been
	 * advanced. */
	if (!yield_on_hlt &&
	    vmcs_read32(GUEST_ACTIVITY_STATE) == GUEST_ACTIVITY_HLT)
		vmcs_write32(GUEST_ACTIVITY_STATE, GUEST_ACTIVITY_ACTIVE);
}

1239
static void vmx_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
1240 1241
				bool has_error_code, u32 error_code,
				bool reinject)
1242
{
1243
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1244
	u32 intr_info = nr | INTR_INFO_VALID_MASK;
1245

1246
	if (has_error_code) {
1247
		vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, error_code);
1248 1249
		intr_info |= INTR_INFO_DELIVER_CODE_MASK;
	}
1250

1251
	if (vmx->rmode.vm86_active) {
1252 1253 1254 1255
		int inc_eip = 0;
		if (kvm_exception_is_soft(nr))
			inc_eip = vcpu->arch.event_exit_inst_len;
		if (kvm_inject_realmode_interrupt(vcpu, nr, inc_eip) != EMULATE_DONE)
1256
			kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu);
1257 1258 1259
		return;
	}

1260 1261 1262
	if (kvm_exception_is_soft(nr)) {
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN,
			     vmx->vcpu.arch.event_exit_inst_len);
1263 1264 1265 1266 1267
		intr_info |= INTR_TYPE_SOFT_EXCEPTION;
	} else
		intr_info |= INTR_TYPE_HARD_EXCEPTION;

	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info);
1268
	vmx_clear_hlt(vcpu);
1269 1270
}

1271 1272 1273 1274 1275
static bool vmx_rdtscp_supported(void)
{
	return cpu_has_vmx_rdtscp();
}

1276 1277 1278
/*
 * Swap MSR entry in host/guest MSR entry array.
 */
R
Rusty Russell 已提交
1279
static void move_msr_up(struct vcpu_vmx *vmx, int from, int to)
1280
{
1281
	struct shared_msr_entry tmp;
1282 1283 1284 1285

	tmp = vmx->guest_msrs[to];
	vmx->guest_msrs[to] = vmx->guest_msrs[from];
	vmx->guest_msrs[from] = tmp;
1286 1287
}

1288 1289 1290 1291 1292
/*
 * Set up the vmcs to automatically save and restore system
 * msrs.  Don't touch the 64-bit msrs if the guest is in legacy
 * mode, as fiddling with msrs is very expensive.
 */
R
Rusty Russell 已提交
1293
static void setup_msrs(struct vcpu_vmx *vmx)
1294
{
1295
	int save_nmsrs, index;
1296
	unsigned long *msr_bitmap;
1297

1298
	vmx_load_host_state(vmx);
1299 1300
	save_nmsrs = 0;
#ifdef CONFIG_X86_64
R
Rusty Russell 已提交
1301 1302
	if (is_long_mode(&vmx->vcpu)) {
		index = __find_msr_index(vmx, MSR_SYSCALL_MASK);
1303
		if (index >= 0)
R
Rusty Russell 已提交
1304 1305
			move_msr_up(vmx, index, save_nmsrs++);
		index = __find_msr_index(vmx, MSR_LSTAR);
1306
		if (index >= 0)
R
Rusty Russell 已提交
1307 1308
			move_msr_up(vmx, index, save_nmsrs++);
		index = __find_msr_index(vmx, MSR_CSTAR);
1309
		if (index >= 0)
R
Rusty Russell 已提交
1310
			move_msr_up(vmx, index, save_nmsrs++);
1311 1312 1313
		index = __find_msr_index(vmx, MSR_TSC_AUX);
		if (index >= 0 && vmx->rdtscp_enabled)
			move_msr_up(vmx, index, save_nmsrs++);
1314
		/*
B
Brian Gerst 已提交
1315
		 * MSR_STAR is only needed on long mode guests, and only
1316 1317
		 * if efer.sce is enabled.
		 */
B
Brian Gerst 已提交
1318
		index = __find_msr_index(vmx, MSR_STAR);
1319
		if ((index >= 0) && (vmx->vcpu.arch.efer & EFER_SCE))
R
Rusty Russell 已提交
1320
			move_msr_up(vmx, index, save_nmsrs++);
1321 1322
	}
#endif
A
Avi Kivity 已提交
1323 1324
	index = __find_msr_index(vmx, MSR_EFER);
	if (index >= 0 && update_transition_efer(vmx, index))
1325
		move_msr_up(vmx, index, save_nmsrs++);
1326

1327
	vmx->save_nmsrs = save_nmsrs;
1328 1329 1330 1331 1332 1333 1334 1335 1336

	if (cpu_has_vmx_msr_bitmap()) {
		if (is_long_mode(&vmx->vcpu))
			msr_bitmap = vmx_msr_bitmap_longmode;
		else
			msr_bitmap = vmx_msr_bitmap_legacy;

		vmcs_write64(MSR_BITMAP, __pa(msr_bitmap));
	}
1337 1338
}

A
Avi Kivity 已提交
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
/*
 * reads and returns guest's timestamp counter "register"
 * guest_tsc = host_tsc + tsc_offset    -- 21.3
 */
static u64 guest_read_tsc(void)
{
	u64 host_tsc, tsc_offset;

	rdtscll(host_tsc);
	tsc_offset = vmcs_read64(TSC_OFFSET);
	return host_tsc + tsc_offset;
}

1352 1353 1354 1355 1356 1357 1358 1359 1360 1361
/*
 * Empty call-back. Needs to be implemented when VMX enables the SET_TSC_KHZ
 * ioctl. In this case the call-back should update internal vmx state to make
 * the changes effective.
 */
static void vmx_set_tsc_khz(struct kvm_vcpu *vcpu, u32 user_tsc_khz)
{
	/* Nothing to do here */
}

A
Avi Kivity 已提交
1362
/*
1363
 * writes 'offset' into guest's timestamp counter offset register
A
Avi Kivity 已提交
1364
 */
1365
static void vmx_write_tsc_offset(struct kvm_vcpu *vcpu, u64 offset)
A
Avi Kivity 已提交
1366
{
1367
	vmcs_write64(TSC_OFFSET, offset);
A
Avi Kivity 已提交
1368 1369
}

Z
Zachary Amsden 已提交
1370 1371 1372 1373 1374 1375
static void vmx_adjust_tsc_offset(struct kvm_vcpu *vcpu, s64 adjustment)
{
	u64 offset = vmcs_read64(TSC_OFFSET);
	vmcs_write64(TSC_OFFSET, offset + adjustment);
}

1376 1377 1378 1379 1380
static u64 vmx_compute_tsc_offset(struct kvm_vcpu *vcpu, u64 target_tsc)
{
	return target_tsc - native_read_tsc();
}

1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
static bool guest_cpuid_has_vmx(struct kvm_vcpu *vcpu)
{
	struct kvm_cpuid_entry2 *best = kvm_find_cpuid_entry(vcpu, 1, 0);
	return best && (best->ecx & (1 << (X86_FEATURE_VMX & 31)));
}

/*
 * nested_vmx_allowed() checks whether a guest should be allowed to use VMX
 * instructions and MSRs (i.e., nested VMX). Nested VMX is disabled for
 * all guests if the "nested" module option is off, and can also be disabled
 * for a single guest by disabling its VMX cpuid bit.
 */
static inline bool nested_vmx_allowed(struct kvm_vcpu *vcpu)
{
	return nested && guest_cpuid_has_vmx(vcpu);
}

1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
/*
 * nested_vmx_setup_ctls_msrs() sets up variables containing the values to be
 * returned for the various VMX controls MSRs when nested VMX is enabled.
 * The same values should also be used to verify that vmcs12 control fields are
 * valid during nested entry from L1 to L2.
 * Each of these control msrs has a low and high 32-bit half: A low bit is on
 * if the corresponding bit in the (32-bit) control field *must* be on, and a
 * bit in the high half is on if the corresponding bit in the control field
 * may be on. See also vmx_control_verify().
 * TODO: allow these variables to be modified (downgraded) by module options
 * or other means.
 */
static u32 nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high;
static u32 nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high;
static u32 nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high;
static u32 nested_vmx_exit_ctls_low, nested_vmx_exit_ctls_high;
static u32 nested_vmx_entry_ctls_low, nested_vmx_entry_ctls_high;
static __init void nested_vmx_setup_ctls_msrs(void)
{
	/*
	 * Note that as a general rule, the high half of the MSRs (bits in
	 * the control fields which may be 1) should be initialized by the
	 * intersection of the underlying hardware's MSR (i.e., features which
	 * can be supported) and the list of features we want to expose -
	 * because they are known to be properly supported in our code.
	 * Also, usually, the low half of the MSRs (bits which must be 1) can
	 * be set to 0, meaning that L1 may turn off any of these bits. The
	 * reason is that if one of these bits is necessary, it will appear
	 * in vmcs01 and prepare_vmcs02, when it bitwise-or's the control
	 * fields of vmcs01 and vmcs02, will turn these bits off - and
	 * nested_vmx_exit_handled() will not pass related exits to L1.
	 * These rules have exceptions below.
	 */

	/* pin-based controls */
	/*
	 * According to the Intel spec, if bit 55 of VMX_BASIC is off (as it is
	 * in our case), bits 1, 2 and 4 (i.e., 0x16) must be 1 in this MSR.
	 */
	nested_vmx_pinbased_ctls_low = 0x16 ;
	nested_vmx_pinbased_ctls_high = 0x16 |
		PIN_BASED_EXT_INTR_MASK | PIN_BASED_NMI_EXITING |
		PIN_BASED_VIRTUAL_NMIS;

	/* exit controls */
	nested_vmx_exit_ctls_low = 0;
#ifdef CONFIG_X86_64
	nested_vmx_exit_ctls_high = VM_EXIT_HOST_ADDR_SPACE_SIZE;
#else
	nested_vmx_exit_ctls_high = 0;
#endif

	/* entry controls */
	rdmsr(MSR_IA32_VMX_ENTRY_CTLS,
		nested_vmx_entry_ctls_low, nested_vmx_entry_ctls_high);
	nested_vmx_entry_ctls_low = 0;
	nested_vmx_entry_ctls_high &=
		VM_ENTRY_LOAD_IA32_PAT | VM_ENTRY_IA32E_MODE;

	/* cpu-based controls */
	rdmsr(MSR_IA32_VMX_PROCBASED_CTLS,
		nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high);
	nested_vmx_procbased_ctls_low = 0;
	nested_vmx_procbased_ctls_high &=
		CPU_BASED_VIRTUAL_INTR_PENDING | CPU_BASED_USE_TSC_OFFSETING |
		CPU_BASED_HLT_EXITING | CPU_BASED_INVLPG_EXITING |
		CPU_BASED_MWAIT_EXITING | CPU_BASED_CR3_LOAD_EXITING |
		CPU_BASED_CR3_STORE_EXITING |
#ifdef CONFIG_X86_64
		CPU_BASED_CR8_LOAD_EXITING | CPU_BASED_CR8_STORE_EXITING |
#endif
		CPU_BASED_MOV_DR_EXITING | CPU_BASED_UNCOND_IO_EXITING |
		CPU_BASED_USE_IO_BITMAPS | CPU_BASED_MONITOR_EXITING |
		CPU_BASED_ACTIVATE_SECONDARY_CONTROLS;
	/*
	 * We can allow some features even when not supported by the
	 * hardware. For example, L1 can specify an MSR bitmap - and we
	 * can use it to avoid exits to L1 - even when L0 runs L2
	 * without MSR bitmaps.
	 */
	nested_vmx_procbased_ctls_high |= CPU_BASED_USE_MSR_BITMAPS;

	/* secondary cpu-based controls */
	rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2,
		nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high);
	nested_vmx_secondary_ctls_low = 0;
	nested_vmx_secondary_ctls_high &=
		SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES;
}

static inline bool vmx_control_verify(u32 control, u32 low, u32 high)
{
	/*
	 * Bits 0 in high must be 0, and bits 1 in low must be 1.
	 */
	return ((control & high) | low) == control;
}

static inline u64 vmx_control_msr(u32 low, u32 high)
{
	return low | ((u64)high << 32);
}

/*
 * If we allow our guest to use VMX instructions (i.e., nested VMX), we should
 * also let it use VMX-specific MSRs.
 * vmx_get_vmx_msr() and vmx_set_vmx_msr() return 1 when we handled a
 * VMX-specific MSR, or 0 when we haven't (and the caller should handle it
 * like all other MSRs).
 */
static int vmx_get_vmx_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
{
	if (!nested_vmx_allowed(vcpu) && msr_index >= MSR_IA32_VMX_BASIC &&
		     msr_index <= MSR_IA32_VMX_TRUE_ENTRY_CTLS) {
		/*
		 * According to the spec, processors which do not support VMX
		 * should throw a #GP(0) when VMX capability MSRs are read.
		 */
		kvm_queue_exception_e(vcpu, GP_VECTOR, 0);
		return 1;
	}

	switch (msr_index) {
	case MSR_IA32_FEATURE_CONTROL:
		*pdata = 0;
		break;
	case MSR_IA32_VMX_BASIC:
		/*
		 * This MSR reports some information about VMX support. We
		 * should return information about the VMX we emulate for the
		 * guest, and the VMCS structure we give it - not about the
		 * VMX support of the underlying hardware.
		 */
		*pdata = VMCS12_REVISION |
			   ((u64)VMCS12_SIZE << VMX_BASIC_VMCS_SIZE_SHIFT) |
			   (VMX_BASIC_MEM_TYPE_WB << VMX_BASIC_MEM_TYPE_SHIFT);
		break;
	case MSR_IA32_VMX_TRUE_PINBASED_CTLS:
	case MSR_IA32_VMX_PINBASED_CTLS:
		*pdata = vmx_control_msr(nested_vmx_pinbased_ctls_low,
					nested_vmx_pinbased_ctls_high);
		break;
	case MSR_IA32_VMX_TRUE_PROCBASED_CTLS:
	case MSR_IA32_VMX_PROCBASED_CTLS:
		*pdata = vmx_control_msr(nested_vmx_procbased_ctls_low,
					nested_vmx_procbased_ctls_high);
		break;
	case MSR_IA32_VMX_TRUE_EXIT_CTLS:
	case MSR_IA32_VMX_EXIT_CTLS:
		*pdata = vmx_control_msr(nested_vmx_exit_ctls_low,
					nested_vmx_exit_ctls_high);
		break;
	case MSR_IA32_VMX_TRUE_ENTRY_CTLS:
	case MSR_IA32_VMX_ENTRY_CTLS:
		*pdata = vmx_control_msr(nested_vmx_entry_ctls_low,
					nested_vmx_entry_ctls_high);
		break;
	case MSR_IA32_VMX_MISC:
		*pdata = 0;
		break;
	/*
	 * These MSRs specify bits which the guest must keep fixed (on or off)
	 * while L1 is in VMXON mode (in L1's root mode, or running an L2).
	 * We picked the standard core2 setting.
	 */
#define VMXON_CR0_ALWAYSON	(X86_CR0_PE | X86_CR0_PG | X86_CR0_NE)
#define VMXON_CR4_ALWAYSON	X86_CR4_VMXE
	case MSR_IA32_VMX_CR0_FIXED0:
		*pdata = VMXON_CR0_ALWAYSON;
		break;
	case MSR_IA32_VMX_CR0_FIXED1:
		*pdata = -1ULL;
		break;
	case MSR_IA32_VMX_CR4_FIXED0:
		*pdata = VMXON_CR4_ALWAYSON;
		break;
	case MSR_IA32_VMX_CR4_FIXED1:
		*pdata = -1ULL;
		break;
	case MSR_IA32_VMX_VMCS_ENUM:
		*pdata = 0x1f;
		break;
	case MSR_IA32_VMX_PROCBASED_CTLS2:
		*pdata = vmx_control_msr(nested_vmx_secondary_ctls_low,
					nested_vmx_secondary_ctls_high);
		break;
	case MSR_IA32_VMX_EPT_VPID_CAP:
		/* Currently, no nested ept or nested vpid */
		*pdata = 0;
		break;
	default:
		return 0;
	}

	return 1;
}

static int vmx_set_vmx_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data)
{
	if (!nested_vmx_allowed(vcpu))
		return 0;

	if (msr_index == MSR_IA32_FEATURE_CONTROL)
		/* TODO: the right thing. */
		return 1;
	/*
	 * No need to treat VMX capability MSRs specially: If we don't handle
	 * them, handle_wrmsr will #GP(0), which is correct (they are readonly)
	 */
	return 0;
}

A
Avi Kivity 已提交
1610 1611 1612 1613 1614 1615 1616 1617
/*
 * Reads an msr value (of 'msr_index') into 'pdata'.
 * Returns 0 on success, non-0 otherwise.
 * Assumes vcpu_load() was already called.
 */
static int vmx_get_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 *pdata)
{
	u64 data;
1618
	struct shared_msr_entry *msr;
A
Avi Kivity 已提交
1619 1620 1621 1622 1623 1624 1625

	if (!pdata) {
		printk(KERN_ERR "BUG: get_msr called with NULL pdata\n");
		return -EINVAL;
	}

	switch (msr_index) {
1626
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
1627 1628 1629 1630 1631 1632
	case MSR_FS_BASE:
		data = vmcs_readl(GUEST_FS_BASE);
		break;
	case MSR_GS_BASE:
		data = vmcs_readl(GUEST_GS_BASE);
		break;
1633 1634 1635 1636
	case MSR_KERNEL_GS_BASE:
		vmx_load_host_state(to_vmx(vcpu));
		data = to_vmx(vcpu)->msr_guest_kernel_gs_base;
		break;
1637
#endif
A
Avi Kivity 已提交
1638
	case MSR_EFER:
1639
		return kvm_get_msr_common(vcpu, msr_index, pdata);
1640
	case MSR_IA32_TSC:
A
Avi Kivity 已提交
1641 1642 1643 1644 1645 1646
		data = guest_read_tsc();
		break;
	case MSR_IA32_SYSENTER_CS:
		data = vmcs_read32(GUEST_SYSENTER_CS);
		break;
	case MSR_IA32_SYSENTER_EIP:
A
Avi Kivity 已提交
1647
		data = vmcs_readl(GUEST_SYSENTER_EIP);
A
Avi Kivity 已提交
1648 1649
		break;
	case MSR_IA32_SYSENTER_ESP:
A
Avi Kivity 已提交
1650
		data = vmcs_readl(GUEST_SYSENTER_ESP);
A
Avi Kivity 已提交
1651
		break;
1652 1653 1654 1655
	case MSR_TSC_AUX:
		if (!to_vmx(vcpu)->rdtscp_enabled)
			return 1;
		/* Otherwise falls through */
A
Avi Kivity 已提交
1656
	default:
1657
		vmx_load_host_state(to_vmx(vcpu));
1658 1659
		if (vmx_get_vmx_msr(vcpu, msr_index, pdata))
			return 0;
R
Rusty Russell 已提交
1660
		msr = find_msr_entry(to_vmx(vcpu), msr_index);
1661
		if (msr) {
1662
			vmx_load_host_state(to_vmx(vcpu));
1663 1664
			data = msr->data;
			break;
A
Avi Kivity 已提交
1665
		}
1666
		return kvm_get_msr_common(vcpu, msr_index, pdata);
A
Avi Kivity 已提交
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
	}

	*pdata = data;
	return 0;
}

/*
 * Writes msr value into into the appropriate "register".
 * Returns 0 on success, non-0 otherwise.
 * Assumes vcpu_load() was already called.
 */
static int vmx_set_msr(struct kvm_vcpu *vcpu, u32 msr_index, u64 data)
{
1680
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1681
	struct shared_msr_entry *msr;
1682 1683
	int ret = 0;

A
Avi Kivity 已提交
1684
	switch (msr_index) {
1685
	case MSR_EFER:
1686
		vmx_load_host_state(vmx);
1687 1688
		ret = kvm_set_msr_common(vcpu, msr_index, data);
		break;
1689
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
1690
	case MSR_FS_BASE:
A
Avi Kivity 已提交
1691
		vmx_segment_cache_clear(vmx);
A
Avi Kivity 已提交
1692 1693 1694
		vmcs_writel(GUEST_FS_BASE, data);
		break;
	case MSR_GS_BASE:
A
Avi Kivity 已提交
1695
		vmx_segment_cache_clear(vmx);
A
Avi Kivity 已提交
1696 1697
		vmcs_writel(GUEST_GS_BASE, data);
		break;
1698 1699 1700 1701
	case MSR_KERNEL_GS_BASE:
		vmx_load_host_state(vmx);
		vmx->msr_guest_kernel_gs_base = data;
		break;
A
Avi Kivity 已提交
1702 1703 1704 1705 1706
#endif
	case MSR_IA32_SYSENTER_CS:
		vmcs_write32(GUEST_SYSENTER_CS, data);
		break;
	case MSR_IA32_SYSENTER_EIP:
A
Avi Kivity 已提交
1707
		vmcs_writel(GUEST_SYSENTER_EIP, data);
A
Avi Kivity 已提交
1708 1709
		break;
	case MSR_IA32_SYSENTER_ESP:
A
Avi Kivity 已提交
1710
		vmcs_writel(GUEST_SYSENTER_ESP, data);
A
Avi Kivity 已提交
1711
		break;
1712
	case MSR_IA32_TSC:
1713
		kvm_write_tsc(vcpu, data);
A
Avi Kivity 已提交
1714
		break;
S
Sheng Yang 已提交
1715 1716 1717 1718 1719 1720
	case MSR_IA32_CR_PAT:
		if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) {
			vmcs_write64(GUEST_IA32_PAT, data);
			vcpu->arch.pat = data;
			break;
		}
1721 1722 1723 1724 1725 1726 1727 1728 1729
		ret = kvm_set_msr_common(vcpu, msr_index, data);
		break;
	case MSR_TSC_AUX:
		if (!vmx->rdtscp_enabled)
			return 1;
		/* Check reserved bit, higher 32 bits should be zero */
		if ((data >> 32) != 0)
			return 1;
		/* Otherwise falls through */
A
Avi Kivity 已提交
1730
	default:
1731 1732
		if (vmx_set_vmx_msr(vcpu, msr_index, data))
			break;
R
Rusty Russell 已提交
1733
		msr = find_msr_entry(vmx, msr_index);
1734
		if (msr) {
1735
			vmx_load_host_state(vmx);
1736 1737
			msr->data = data;
			break;
A
Avi Kivity 已提交
1738
		}
1739
		ret = kvm_set_msr_common(vcpu, msr_index, data);
A
Avi Kivity 已提交
1740 1741
	}

1742
	return ret;
A
Avi Kivity 已提交
1743 1744
}

1745
static void vmx_cache_reg(struct kvm_vcpu *vcpu, enum kvm_reg reg)
A
Avi Kivity 已提交
1746
{
1747 1748 1749 1750 1751 1752 1753 1754
	__set_bit(reg, (unsigned long *)&vcpu->arch.regs_avail);
	switch (reg) {
	case VCPU_REGS_RSP:
		vcpu->arch.regs[VCPU_REGS_RSP] = vmcs_readl(GUEST_RSP);
		break;
	case VCPU_REGS_RIP:
		vcpu->arch.regs[VCPU_REGS_RIP] = vmcs_readl(GUEST_RIP);
		break;
A
Avi Kivity 已提交
1755 1756 1757 1758
	case VCPU_EXREG_PDPTR:
		if (enable_ept)
			ept_save_pdptrs(vcpu);
		break;
1759 1760 1761
	default:
		break;
	}
A
Avi Kivity 已提交
1762 1763
}

1764
static void set_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg)
A
Avi Kivity 已提交
1765
{
1766 1767 1768 1769 1770
	if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP)
		vmcs_writel(GUEST_DR7, dbg->arch.debugreg[7]);
	else
		vmcs_writel(GUEST_DR7, vcpu->arch.dr7);

1771
	update_exception_bitmap(vcpu);
A
Avi Kivity 已提交
1772 1773 1774 1775
}

static __init int cpu_has_kvm_support(void)
{
1776
	return cpu_has_vmx();
A
Avi Kivity 已提交
1777 1778 1779 1780 1781 1782 1783
}

static __init int vmx_disabled_by_bios(void)
{
	u64 msr;

	rdmsrl(MSR_IA32_FEATURE_CONTROL, msr);
1784
	if (msr & FEATURE_CONTROL_LOCKED) {
1785
		/* launched w/ TXT and VMX disabled */
1786 1787 1788
		if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX)
			&& tboot_enabled())
			return 1;
1789
		/* launched w/o TXT and VMX only enabled w/ TXT */
1790
		if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX)
1791
			&& (msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX)
1792 1793
			&& !tboot_enabled()) {
			printk(KERN_WARNING "kvm: disable TXT in the BIOS or "
1794
				"activate TXT before enabling KVM\n");
1795
			return 1;
1796
		}
1797 1798 1799 1800
		/* launched w/o TXT and VMX disabled */
		if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX)
			&& !tboot_enabled())
			return 1;
1801 1802 1803
	}

	return 0;
A
Avi Kivity 已提交
1804 1805
}

1806 1807 1808 1809 1810 1811 1812
static void kvm_cpu_vmxon(u64 addr)
{
	asm volatile (ASM_VMX_VMXON_RAX
			: : "a"(&addr), "m"(addr)
			: "memory", "cc");
}

1813
static int hardware_enable(void *garbage)
A
Avi Kivity 已提交
1814 1815 1816
{
	int cpu = raw_smp_processor_id();
	u64 phys_addr = __pa(per_cpu(vmxarea, cpu));
1817
	u64 old, test_bits;
A
Avi Kivity 已提交
1818

1819 1820 1821
	if (read_cr4() & X86_CR4_VMXE)
		return -EBUSY;

1822
	INIT_LIST_HEAD(&per_cpu(loaded_vmcss_on_cpu, cpu));
A
Avi Kivity 已提交
1823
	rdmsrl(MSR_IA32_FEATURE_CONTROL, old);
1824 1825 1826 1827 1828 1829 1830

	test_bits = FEATURE_CONTROL_LOCKED;
	test_bits |= FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX;
	if (tboot_enabled())
		test_bits |= FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX;

	if ((old & test_bits) != test_bits) {
A
Avi Kivity 已提交
1831
		/* enable and lock */
1832 1833
		wrmsrl(MSR_IA32_FEATURE_CONTROL, old | test_bits);
	}
1834
	write_cr4(read_cr4() | X86_CR4_VMXE); /* FIXME: not cpu hotplug safe */
1835

1836 1837 1838 1839
	if (vmm_exclusive) {
		kvm_cpu_vmxon(phys_addr);
		ept_sync_global();
	}
1840

1841 1842
	store_gdt(&__get_cpu_var(host_gdt));

1843
	return 0;
A
Avi Kivity 已提交
1844 1845
}

1846
static void vmclear_local_loaded_vmcss(void)
1847 1848
{
	int cpu = raw_smp_processor_id();
1849
	struct loaded_vmcs *v, *n;
1850

1851 1852 1853
	list_for_each_entry_safe(v, n, &per_cpu(loaded_vmcss_on_cpu, cpu),
				 loaded_vmcss_on_cpu_link)
		__loaded_vmcs_clear(v);
1854 1855
}

1856 1857 1858 1859 1860

/* Just like cpu_vmxoff(), but with the __kvm_handle_fault_on_reboot()
 * tricks.
 */
static void kvm_cpu_vmxoff(void)
A
Avi Kivity 已提交
1861
{
1862
	asm volatile (__ex(ASM_VMX_VMXOFF) : : : "cc");
A
Avi Kivity 已提交
1863 1864
}

1865 1866
static void hardware_disable(void *garbage)
{
1867
	if (vmm_exclusive) {
1868
		vmclear_local_loaded_vmcss();
1869 1870
		kvm_cpu_vmxoff();
	}
1871
	write_cr4(read_cr4() & ~X86_CR4_VMXE);
1872 1873
}

1874
static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt,
M
Mike Day 已提交
1875
				      u32 msr, u32 *result)
1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
{
	u32 vmx_msr_low, vmx_msr_high;
	u32 ctl = ctl_min | ctl_opt;

	rdmsr(msr, vmx_msr_low, vmx_msr_high);

	ctl &= vmx_msr_high; /* bit == 0 in high word ==> must be zero */
	ctl |= vmx_msr_low;  /* bit == 1 in low word  ==> must be one  */

	/* Ensure minimum (required) set of control bits are supported. */
	if (ctl_min & ~ctl)
Y
Yang, Sheng 已提交
1887
		return -EIO;
1888 1889 1890 1891 1892

	*result = ctl;
	return 0;
}

A
Avi Kivity 已提交
1893 1894 1895 1896 1897 1898 1899 1900
static __init bool allow_1_setting(u32 msr, u32 ctl)
{
	u32 vmx_msr_low, vmx_msr_high;

	rdmsr(msr, vmx_msr_low, vmx_msr_high);
	return vmx_msr_high & ctl;
}

Y
Yang, Sheng 已提交
1901
static __init int setup_vmcs_config(struct vmcs_config *vmcs_conf)
A
Avi Kivity 已提交
1902 1903
{
	u32 vmx_msr_low, vmx_msr_high;
S
Sheng Yang 已提交
1904
	u32 min, opt, min2, opt2;
1905 1906
	u32 _pin_based_exec_control = 0;
	u32 _cpu_based_exec_control = 0;
1907
	u32 _cpu_based_2nd_exec_control = 0;
1908 1909 1910 1911
	u32 _vmexit_control = 0;
	u32 _vmentry_control = 0;

	min = PIN_BASED_EXT_INTR_MASK | PIN_BASED_NMI_EXITING;
1912
	opt = PIN_BASED_VIRTUAL_NMIS;
1913 1914
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PINBASED_CTLS,
				&_pin_based_exec_control) < 0)
Y
Yang, Sheng 已提交
1915
		return -EIO;
1916

1917
	min =
1918 1919 1920 1921
#ifdef CONFIG_X86_64
	      CPU_BASED_CR8_LOAD_EXITING |
	      CPU_BASED_CR8_STORE_EXITING |
#endif
S
Sheng Yang 已提交
1922 1923
	      CPU_BASED_CR3_LOAD_EXITING |
	      CPU_BASED_CR3_STORE_EXITING |
1924 1925
	      CPU_BASED_USE_IO_BITMAPS |
	      CPU_BASED_MOV_DR_EXITING |
M
Marcelo Tosatti 已提交
1926
	      CPU_BASED_USE_TSC_OFFSETING |
1927 1928
	      CPU_BASED_MWAIT_EXITING |
	      CPU_BASED_MONITOR_EXITING |
M
Marcelo Tosatti 已提交
1929
	      CPU_BASED_INVLPG_EXITING;
1930 1931 1932 1933

	if (yield_on_hlt)
		min |= CPU_BASED_HLT_EXITING;

1934
	opt = CPU_BASED_TPR_SHADOW |
S
Sheng Yang 已提交
1935
	      CPU_BASED_USE_MSR_BITMAPS |
1936
	      CPU_BASED_ACTIVATE_SECONDARY_CONTROLS;
1937 1938
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PROCBASED_CTLS,
				&_cpu_based_exec_control) < 0)
Y
Yang, Sheng 已提交
1939
		return -EIO;
1940 1941 1942 1943 1944
#ifdef CONFIG_X86_64
	if ((_cpu_based_exec_control & CPU_BASED_TPR_SHADOW))
		_cpu_based_exec_control &= ~CPU_BASED_CR8_LOAD_EXITING &
					   ~CPU_BASED_CR8_STORE_EXITING;
#endif
1945
	if (_cpu_based_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) {
S
Sheng Yang 已提交
1946 1947
		min2 = 0;
		opt2 = SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES |
1948
			SECONDARY_EXEC_WBINVD_EXITING |
S
Sheng Yang 已提交
1949
			SECONDARY_EXEC_ENABLE_VPID |
1950
			SECONDARY_EXEC_ENABLE_EPT |
1951
			SECONDARY_EXEC_UNRESTRICTED_GUEST |
1952 1953
			SECONDARY_EXEC_PAUSE_LOOP_EXITING |
			SECONDARY_EXEC_RDTSCP;
S
Sheng Yang 已提交
1954 1955
		if (adjust_vmx_controls(min2, opt2,
					MSR_IA32_VMX_PROCBASED_CTLS2,
1956 1957 1958 1959 1960 1961 1962 1963
					&_cpu_based_2nd_exec_control) < 0)
			return -EIO;
	}
#ifndef CONFIG_X86_64
	if (!(_cpu_based_2nd_exec_control &
				SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES))
		_cpu_based_exec_control &= ~CPU_BASED_TPR_SHADOW;
#endif
S
Sheng Yang 已提交
1964
	if (_cpu_based_2nd_exec_control & SECONDARY_EXEC_ENABLE_EPT) {
M
Marcelo Tosatti 已提交
1965 1966
		/* CR3 accesses and invlpg don't need to cause VM Exits when EPT
		   enabled */
1967 1968 1969
		_cpu_based_exec_control &= ~(CPU_BASED_CR3_LOAD_EXITING |
					     CPU_BASED_CR3_STORE_EXITING |
					     CPU_BASED_INVLPG_EXITING);
S
Sheng Yang 已提交
1970 1971 1972
		rdmsr(MSR_IA32_VMX_EPT_VPID_CAP,
		      vmx_capability.ept, vmx_capability.vpid);
	}
1973 1974 1975 1976 1977

	min = 0;
#ifdef CONFIG_X86_64
	min |= VM_EXIT_HOST_ADDR_SPACE_SIZE;
#endif
S
Sheng Yang 已提交
1978
	opt = VM_EXIT_SAVE_IA32_PAT | VM_EXIT_LOAD_IA32_PAT;
1979 1980
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_EXIT_CTLS,
				&_vmexit_control) < 0)
Y
Yang, Sheng 已提交
1981
		return -EIO;
1982

S
Sheng Yang 已提交
1983 1984
	min = 0;
	opt = VM_ENTRY_LOAD_IA32_PAT;
1985 1986
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_ENTRY_CTLS,
				&_vmentry_control) < 0)
Y
Yang, Sheng 已提交
1987
		return -EIO;
A
Avi Kivity 已提交
1988

N
Nguyen Anh Quynh 已提交
1989
	rdmsr(MSR_IA32_VMX_BASIC, vmx_msr_low, vmx_msr_high);
1990 1991 1992

	/* IA-32 SDM Vol 3B: VMCS size is never greater than 4kB. */
	if ((vmx_msr_high & 0x1fff) > PAGE_SIZE)
Y
Yang, Sheng 已提交
1993
		return -EIO;
1994 1995 1996 1997

#ifdef CONFIG_X86_64
	/* IA-32 SDM Vol 3B: 64-bit CPUs always have VMX_BASIC_MSR[48]==0. */
	if (vmx_msr_high & (1u<<16))
Y
Yang, Sheng 已提交
1998
		return -EIO;
1999 2000 2001 2002
#endif

	/* Require Write-Back (WB) memory type for VMCS accesses. */
	if (((vmx_msr_high >> 18) & 15) != 6)
Y
Yang, Sheng 已提交
2003
		return -EIO;
2004

Y
Yang, Sheng 已提交
2005 2006 2007
	vmcs_conf->size = vmx_msr_high & 0x1fff;
	vmcs_conf->order = get_order(vmcs_config.size);
	vmcs_conf->revision_id = vmx_msr_low;
2008

Y
Yang, Sheng 已提交
2009 2010
	vmcs_conf->pin_based_exec_ctrl = _pin_based_exec_control;
	vmcs_conf->cpu_based_exec_ctrl = _cpu_based_exec_control;
2011
	vmcs_conf->cpu_based_2nd_exec_ctrl = _cpu_based_2nd_exec_control;
Y
Yang, Sheng 已提交
2012 2013
	vmcs_conf->vmexit_ctrl         = _vmexit_control;
	vmcs_conf->vmentry_ctrl        = _vmentry_control;
2014

A
Avi Kivity 已提交
2015 2016 2017 2018 2019 2020
	cpu_has_load_ia32_efer =
		allow_1_setting(MSR_IA32_VMX_ENTRY_CTLS,
				VM_ENTRY_LOAD_IA32_EFER)
		&& allow_1_setting(MSR_IA32_VMX_EXIT_CTLS,
				   VM_EXIT_LOAD_IA32_EFER);

2021
	return 0;
N
Nguyen Anh Quynh 已提交
2022
}
A
Avi Kivity 已提交
2023 2024 2025 2026 2027 2028 2029

static struct vmcs *alloc_vmcs_cpu(int cpu)
{
	int node = cpu_to_node(cpu);
	struct page *pages;
	struct vmcs *vmcs;

2030
	pages = alloc_pages_exact_node(node, GFP_KERNEL, vmcs_config.order);
A
Avi Kivity 已提交
2031 2032 2033
	if (!pages)
		return NULL;
	vmcs = page_address(pages);
2034 2035
	memset(vmcs, 0, vmcs_config.size);
	vmcs->revision_id = vmcs_config.revision_id; /* vmcs revision id */
A
Avi Kivity 已提交
2036 2037 2038 2039 2040
	return vmcs;
}

static struct vmcs *alloc_vmcs(void)
{
2041
	return alloc_vmcs_cpu(raw_smp_processor_id());
A
Avi Kivity 已提交
2042 2043 2044 2045
}

static void free_vmcs(struct vmcs *vmcs)
{
2046
	free_pages((unsigned long)vmcs, vmcs_config.order);
A
Avi Kivity 已提交
2047 2048
}

2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060
/*
 * Free a VMCS, but before that VMCLEAR it on the CPU where it was last loaded
 */
static void free_loaded_vmcs(struct loaded_vmcs *loaded_vmcs)
{
	if (!loaded_vmcs->vmcs)
		return;
	loaded_vmcs_clear(loaded_vmcs);
	free_vmcs(loaded_vmcs->vmcs);
	loaded_vmcs->vmcs = NULL;
}

2061
static void free_kvm_area(void)
A
Avi Kivity 已提交
2062 2063 2064
{
	int cpu;

Z
Zachary Amsden 已提交
2065
	for_each_possible_cpu(cpu) {
A
Avi Kivity 已提交
2066
		free_vmcs(per_cpu(vmxarea, cpu));
Z
Zachary Amsden 已提交
2067 2068
		per_cpu(vmxarea, cpu) = NULL;
	}
A
Avi Kivity 已提交
2069 2070 2071 2072 2073 2074
}

static __init int alloc_kvm_area(void)
{
	int cpu;

Z
Zachary Amsden 已提交
2075
	for_each_possible_cpu(cpu) {
A
Avi Kivity 已提交
2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090
		struct vmcs *vmcs;

		vmcs = alloc_vmcs_cpu(cpu);
		if (!vmcs) {
			free_kvm_area();
			return -ENOMEM;
		}

		per_cpu(vmxarea, cpu) = vmcs;
	}
	return 0;
}

static __init int hardware_setup(void)
{
Y
Yang, Sheng 已提交
2091 2092
	if (setup_vmcs_config(&vmcs_config) < 0)
		return -EIO;
2093 2094 2095 2096

	if (boot_cpu_has(X86_FEATURE_NX))
		kvm_enable_efer_bits(EFER_NX);

S
Sheng Yang 已提交
2097 2098 2099
	if (!cpu_has_vmx_vpid())
		enable_vpid = 0;

2100 2101
	if (!cpu_has_vmx_ept() ||
	    !cpu_has_vmx_ept_4levels()) {
S
Sheng Yang 已提交
2102
		enable_ept = 0;
2103 2104 2105 2106 2107
		enable_unrestricted_guest = 0;
	}

	if (!cpu_has_vmx_unrestricted_guest())
		enable_unrestricted_guest = 0;
S
Sheng Yang 已提交
2108 2109 2110 2111

	if (!cpu_has_vmx_flexpriority())
		flexpriority_enabled = 0;

2112 2113 2114
	if (!cpu_has_vmx_tpr_shadow())
		kvm_x86_ops->update_cr8_intercept = NULL;

2115 2116 2117
	if (enable_ept && !cpu_has_vmx_ept_2m_page())
		kvm_disable_largepages();

2118 2119 2120
	if (!cpu_has_vmx_ple())
		ple_gap = 0;

2121 2122 2123
	if (nested)
		nested_vmx_setup_ctls_msrs();

A
Avi Kivity 已提交
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
	return alloc_kvm_area();
}

static __exit void hardware_unsetup(void)
{
	free_kvm_area();
}

static void fix_pmode_dataseg(int seg, struct kvm_save_segment *save)
{
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];

2136
	if (vmcs_readl(sf->base) == save->base && (save->base & AR_S_MASK)) {
A
Avi Kivity 已提交
2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
		vmcs_write16(sf->selector, save->selector);
		vmcs_writel(sf->base, save->base);
		vmcs_write32(sf->limit, save->limit);
		vmcs_write32(sf->ar_bytes, save->ar);
	} else {
		u32 dpl = (vmcs_read16(sf->selector) & SELECTOR_RPL_MASK)
			<< AR_DPL_SHIFT;
		vmcs_write32(sf->ar_bytes, 0x93 | dpl);
	}
}

static void enter_pmode(struct kvm_vcpu *vcpu)
{
	unsigned long flags;
2151
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Avi Kivity 已提交
2152

2153
	vmx->emulation_required = 1;
2154
	vmx->rmode.vm86_active = 0;
A
Avi Kivity 已提交
2155

A
Avi Kivity 已提交
2156 2157
	vmx_segment_cache_clear(vmx);

2158
	vmcs_write16(GUEST_TR_SELECTOR, vmx->rmode.tr.selector);
2159 2160 2161
	vmcs_writel(GUEST_TR_BASE, vmx->rmode.tr.base);
	vmcs_write32(GUEST_TR_LIMIT, vmx->rmode.tr.limit);
	vmcs_write32(GUEST_TR_AR_BYTES, vmx->rmode.tr.ar);
A
Avi Kivity 已提交
2162 2163

	flags = vmcs_readl(GUEST_RFLAGS);
2164 2165
	flags &= RMODE_GUEST_OWNED_EFLAGS_BITS;
	flags |= vmx->rmode.save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS;
A
Avi Kivity 已提交
2166 2167
	vmcs_writel(GUEST_RFLAGS, flags);

2168 2169
	vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~X86_CR4_VME) |
			(vmcs_readl(CR4_READ_SHADOW) & X86_CR4_VME));
A
Avi Kivity 已提交
2170 2171 2172

	update_exception_bitmap(vcpu);

2173 2174 2175
	if (emulate_invalid_guest_state)
		return;

2176 2177 2178 2179
	fix_pmode_dataseg(VCPU_SREG_ES, &vmx->rmode.es);
	fix_pmode_dataseg(VCPU_SREG_DS, &vmx->rmode.ds);
	fix_pmode_dataseg(VCPU_SREG_GS, &vmx->rmode.gs);
	fix_pmode_dataseg(VCPU_SREG_FS, &vmx->rmode.fs);
A
Avi Kivity 已提交
2180

A
Avi Kivity 已提交
2181 2182
	vmx_segment_cache_clear(vmx);

A
Avi Kivity 已提交
2183 2184 2185 2186 2187 2188 2189 2190
	vmcs_write16(GUEST_SS_SELECTOR, 0);
	vmcs_write32(GUEST_SS_AR_BYTES, 0x93);

	vmcs_write16(GUEST_CS_SELECTOR,
		     vmcs_read16(GUEST_CS_SELECTOR) & ~SELECTOR_RPL_MASK);
	vmcs_write32(GUEST_CS_AR_BYTES, 0x9b);
}

M
Mike Day 已提交
2191
static gva_t rmode_tss_base(struct kvm *kvm)
A
Avi Kivity 已提交
2192
{
2193
	if (!kvm->arch.tss_addr) {
2194 2195 2196
		struct kvm_memslots *slots;
		gfn_t base_gfn;

2197
		slots = kvm_memslots(kvm);
2198
		base_gfn = slots->memslots[0].base_gfn +
2199
				 kvm->memslots->memslots[0].npages - 3;
2200 2201
		return base_gfn << PAGE_SHIFT;
	}
2202
	return kvm->arch.tss_addr;
A
Avi Kivity 已提交
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
}

static void fix_rmode_seg(int seg, struct kvm_save_segment *save)
{
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];

	save->selector = vmcs_read16(sf->selector);
	save->base = vmcs_readl(sf->base);
	save->limit = vmcs_read32(sf->limit);
	save->ar = vmcs_read32(sf->ar_bytes);
2213
	vmcs_write16(sf->selector, save->base >> 4);
2214
	vmcs_write32(sf->base, save->base & 0xffff0);
A
Avi Kivity 已提交
2215 2216
	vmcs_write32(sf->limit, 0xffff);
	vmcs_write32(sf->ar_bytes, 0xf3);
2217 2218 2219 2220
	if (save->base & 0xf)
		printk_once(KERN_WARNING "kvm: segment base is not paragraph"
			    " aligned when entering protected mode (seg=%d)",
			    seg);
A
Avi Kivity 已提交
2221 2222 2223 2224 2225
}

static void enter_rmode(struct kvm_vcpu *vcpu)
{
	unsigned long flags;
2226
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Avi Kivity 已提交
2227

2228 2229 2230
	if (enable_unrestricted_guest)
		return;

2231
	vmx->emulation_required = 1;
2232
	vmx->rmode.vm86_active = 1;
A
Avi Kivity 已提交
2233

2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245
	/*
	 * Very old userspace does not call KVM_SET_TSS_ADDR before entering
	 * vcpu. Call it here with phys address pointing 16M below 4G.
	 */
	if (!vcpu->kvm->arch.tss_addr) {
		printk_once(KERN_WARNING "kvm: KVM_SET_TSS_ADDR need to be "
			     "called before entering vcpu\n");
		srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx);
		vmx_set_tss_addr(vcpu->kvm, 0xfeffd000);
		vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
	}

A
Avi Kivity 已提交
2246 2247
	vmx_segment_cache_clear(vmx);

2248
	vmx->rmode.tr.selector = vmcs_read16(GUEST_TR_SELECTOR);
2249
	vmx->rmode.tr.base = vmcs_readl(GUEST_TR_BASE);
A
Avi Kivity 已提交
2250 2251
	vmcs_writel(GUEST_TR_BASE, rmode_tss_base(vcpu->kvm));

2252
	vmx->rmode.tr.limit = vmcs_read32(GUEST_TR_LIMIT);
A
Avi Kivity 已提交
2253 2254
	vmcs_write32(GUEST_TR_LIMIT, RMODE_TSS_SIZE - 1);

2255
	vmx->rmode.tr.ar = vmcs_read32(GUEST_TR_AR_BYTES);
A
Avi Kivity 已提交
2256 2257 2258
	vmcs_write32(GUEST_TR_AR_BYTES, 0x008b);

	flags = vmcs_readl(GUEST_RFLAGS);
2259
	vmx->rmode.save_rflags = flags;
A
Avi Kivity 已提交
2260

2261
	flags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM;
A
Avi Kivity 已提交
2262 2263

	vmcs_writel(GUEST_RFLAGS, flags);
2264
	vmcs_writel(GUEST_CR4, vmcs_readl(GUEST_CR4) | X86_CR4_VME);
A
Avi Kivity 已提交
2265 2266
	update_exception_bitmap(vcpu);

2267 2268 2269
	if (emulate_invalid_guest_state)
		goto continue_rmode;

A
Avi Kivity 已提交
2270 2271 2272 2273 2274
	vmcs_write16(GUEST_SS_SELECTOR, vmcs_readl(GUEST_SS_BASE) >> 4);
	vmcs_write32(GUEST_SS_LIMIT, 0xffff);
	vmcs_write32(GUEST_SS_AR_BYTES, 0xf3);

	vmcs_write32(GUEST_CS_AR_BYTES, 0xf3);
2275
	vmcs_write32(GUEST_CS_LIMIT, 0xffff);
2276 2277
	if (vmcs_readl(GUEST_CS_BASE) == 0xffff0000)
		vmcs_writel(GUEST_CS_BASE, 0xf0000);
A
Avi Kivity 已提交
2278 2279
	vmcs_write16(GUEST_CS_SELECTOR, vmcs_readl(GUEST_CS_BASE) >> 4);

2280 2281 2282 2283
	fix_rmode_seg(VCPU_SREG_ES, &vmx->rmode.es);
	fix_rmode_seg(VCPU_SREG_DS, &vmx->rmode.ds);
	fix_rmode_seg(VCPU_SREG_GS, &vmx->rmode.gs);
	fix_rmode_seg(VCPU_SREG_FS, &vmx->rmode.fs);
2284

2285
continue_rmode:
2286
	kvm_mmu_reset_context(vcpu);
A
Avi Kivity 已提交
2287 2288
}

2289 2290 2291
static void vmx_set_efer(struct kvm_vcpu *vcpu, u64 efer)
{
	struct vcpu_vmx *vmx = to_vmx(vcpu);
2292 2293 2294 2295
	struct shared_msr_entry *msr = find_msr_entry(vmx, MSR_EFER);

	if (!msr)
		return;
2296

2297 2298 2299 2300 2301
	/*
	 * Force kernel_gs_base reloading before EFER changes, as control
	 * of this msr depends on is_long_mode().
	 */
	vmx_load_host_state(to_vmx(vcpu));
2302
	vcpu->arch.efer = efer;
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317
	if (efer & EFER_LMA) {
		vmcs_write32(VM_ENTRY_CONTROLS,
			     vmcs_read32(VM_ENTRY_CONTROLS) |
			     VM_ENTRY_IA32E_MODE);
		msr->data = efer;
	} else {
		vmcs_write32(VM_ENTRY_CONTROLS,
			     vmcs_read32(VM_ENTRY_CONTROLS) &
			     ~VM_ENTRY_IA32E_MODE);

		msr->data = efer & ~EFER_LME;
	}
	setup_msrs(vmx);
}

2318
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
2319 2320 2321 2322 2323

static void enter_lmode(struct kvm_vcpu *vcpu)
{
	u32 guest_tr_ar;

A
Avi Kivity 已提交
2324 2325
	vmx_segment_cache_clear(to_vmx(vcpu));

A
Avi Kivity 已提交
2326 2327 2328
	guest_tr_ar = vmcs_read32(GUEST_TR_AR_BYTES);
	if ((guest_tr_ar & AR_TYPE_MASK) != AR_TYPE_BUSY_64_TSS) {
		printk(KERN_DEBUG "%s: tss fixup for long mode. \n",
2329
		       __func__);
A
Avi Kivity 已提交
2330 2331 2332 2333
		vmcs_write32(GUEST_TR_AR_BYTES,
			     (guest_tr_ar & ~AR_TYPE_MASK)
			     | AR_TYPE_BUSY_64_TSS);
	}
2334
	vmx_set_efer(vcpu, vcpu->arch.efer | EFER_LMA);
A
Avi Kivity 已提交
2335 2336 2337 2338 2339 2340
}

static void exit_lmode(struct kvm_vcpu *vcpu)
{
	vmcs_write32(VM_ENTRY_CONTROLS,
		     vmcs_read32(VM_ENTRY_CONTROLS)
2341
		     & ~VM_ENTRY_IA32E_MODE);
2342
	vmx_set_efer(vcpu, vcpu->arch.efer & ~EFER_LMA);
A
Avi Kivity 已提交
2343 2344 2345 2346
}

#endif

2347 2348
static void vmx_flush_tlb(struct kvm_vcpu *vcpu)
{
2349
	vpid_sync_context(to_vmx(vcpu));
2350 2351 2352
	if (enable_ept) {
		if (!VALID_PAGE(vcpu->arch.mmu.root_hpa))
			return;
2353
		ept_sync_context(construct_eptp(vcpu->arch.mmu.root_hpa));
2354
	}
2355 2356
}

2357 2358 2359 2360 2361 2362 2363 2364
static void vmx_decache_cr0_guest_bits(struct kvm_vcpu *vcpu)
{
	ulong cr0_guest_owned_bits = vcpu->arch.cr0_guest_owned_bits;

	vcpu->arch.cr0 &= ~cr0_guest_owned_bits;
	vcpu->arch.cr0 |= vmcs_readl(GUEST_CR0) & cr0_guest_owned_bits;
}

2365 2366 2367 2368 2369 2370 2371
static void vmx_decache_cr3(struct kvm_vcpu *vcpu)
{
	if (enable_ept && is_paging(vcpu))
		vcpu->arch.cr3 = vmcs_readl(GUEST_CR3);
	__set_bit(VCPU_EXREG_CR3, (ulong *)&vcpu->arch.regs_avail);
}

2372
static void vmx_decache_cr4_guest_bits(struct kvm_vcpu *vcpu)
2373
{
2374 2375 2376 2377
	ulong cr4_guest_owned_bits = vcpu->arch.cr4_guest_owned_bits;

	vcpu->arch.cr4 &= ~cr4_guest_owned_bits;
	vcpu->arch.cr4 |= vmcs_readl(GUEST_CR4) & cr4_guest_owned_bits;
2378 2379
}

2380 2381
static void ept_load_pdptrs(struct kvm_vcpu *vcpu)
{
A
Avi Kivity 已提交
2382 2383 2384 2385
	if (!test_bit(VCPU_EXREG_PDPTR,
		      (unsigned long *)&vcpu->arch.regs_dirty))
		return;

2386
	if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) {
2387 2388 2389 2390
		vmcs_write64(GUEST_PDPTR0, vcpu->arch.mmu.pdptrs[0]);
		vmcs_write64(GUEST_PDPTR1, vcpu->arch.mmu.pdptrs[1]);
		vmcs_write64(GUEST_PDPTR2, vcpu->arch.mmu.pdptrs[2]);
		vmcs_write64(GUEST_PDPTR3, vcpu->arch.mmu.pdptrs[3]);
2391 2392 2393
	}
}

2394 2395 2396
static void ept_save_pdptrs(struct kvm_vcpu *vcpu)
{
	if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) {
2397 2398 2399 2400
		vcpu->arch.mmu.pdptrs[0] = vmcs_read64(GUEST_PDPTR0);
		vcpu->arch.mmu.pdptrs[1] = vmcs_read64(GUEST_PDPTR1);
		vcpu->arch.mmu.pdptrs[2] = vmcs_read64(GUEST_PDPTR2);
		vcpu->arch.mmu.pdptrs[3] = vmcs_read64(GUEST_PDPTR3);
2401
	}
A
Avi Kivity 已提交
2402 2403 2404 2405 2406

	__set_bit(VCPU_EXREG_PDPTR,
		  (unsigned long *)&vcpu->arch.regs_avail);
	__set_bit(VCPU_EXREG_PDPTR,
		  (unsigned long *)&vcpu->arch.regs_dirty);
2407 2408
}

2409
static int vmx_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4);
2410 2411 2412 2413 2414

static void ept_update_paging_mode_cr0(unsigned long *hw_cr0,
					unsigned long cr0,
					struct kvm_vcpu *vcpu)
{
2415 2416
	if (!test_bit(VCPU_EXREG_CR3, (ulong *)&vcpu->arch.regs_avail))
		vmx_decache_cr3(vcpu);
2417 2418 2419
	if (!(cr0 & X86_CR0_PG)) {
		/* From paging/starting to nonpaging */
		vmcs_write32(CPU_BASED_VM_EXEC_CONTROL,
2420
			     vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) |
2421 2422 2423
			     (CPU_BASED_CR3_LOAD_EXITING |
			      CPU_BASED_CR3_STORE_EXITING));
		vcpu->arch.cr0 = cr0;
2424
		vmx_set_cr4(vcpu, kvm_read_cr4(vcpu));
2425 2426 2427
	} else if (!is_paging(vcpu)) {
		/* From nonpaging to paging */
		vmcs_write32(CPU_BASED_VM_EXEC_CONTROL,
2428
			     vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) &
2429 2430 2431
			     ~(CPU_BASED_CR3_LOAD_EXITING |
			       CPU_BASED_CR3_STORE_EXITING));
		vcpu->arch.cr0 = cr0;
2432
		vmx_set_cr4(vcpu, kvm_read_cr4(vcpu));
2433
	}
2434 2435 2436

	if (!(cr0 & X86_CR0_WP))
		*hw_cr0 &= ~X86_CR0_WP;
2437 2438
}

A
Avi Kivity 已提交
2439 2440
static void vmx_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
{
2441
	struct vcpu_vmx *vmx = to_vmx(vcpu);
2442 2443 2444 2445 2446 2447 2448
	unsigned long hw_cr0;

	if (enable_unrestricted_guest)
		hw_cr0 = (cr0 & ~KVM_GUEST_CR0_MASK_UNRESTRICTED_GUEST)
			| KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST;
	else
		hw_cr0 = (cr0 & ~KVM_GUEST_CR0_MASK) | KVM_VM_CR0_ALWAYS_ON;
2449

2450
	if (vmx->rmode.vm86_active && (cr0 & X86_CR0_PE))
A
Avi Kivity 已提交
2451 2452
		enter_pmode(vcpu);

2453
	if (!vmx->rmode.vm86_active && !(cr0 & X86_CR0_PE))
A
Avi Kivity 已提交
2454 2455
		enter_rmode(vcpu);

2456
#ifdef CONFIG_X86_64
2457
	if (vcpu->arch.efer & EFER_LME) {
2458
		if (!is_paging(vcpu) && (cr0 & X86_CR0_PG))
A
Avi Kivity 已提交
2459
			enter_lmode(vcpu);
2460
		if (is_paging(vcpu) && !(cr0 & X86_CR0_PG))
A
Avi Kivity 已提交
2461 2462 2463 2464
			exit_lmode(vcpu);
	}
#endif

2465
	if (enable_ept)
2466 2467
		ept_update_paging_mode_cr0(&hw_cr0, cr0, vcpu);

2468
	if (!vcpu->fpu_active)
2469
		hw_cr0 |= X86_CR0_TS | X86_CR0_MP;
2470

A
Avi Kivity 已提交
2471
	vmcs_writel(CR0_READ_SHADOW, cr0);
2472
	vmcs_writel(GUEST_CR0, hw_cr0);
2473
	vcpu->arch.cr0 = cr0;
A
Avi Kivity 已提交
2474
	__clear_bit(VCPU_EXREG_CPL, (ulong *)&vcpu->arch.regs_avail);
A
Avi Kivity 已提交
2475 2476
}

2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488
static u64 construct_eptp(unsigned long root_hpa)
{
	u64 eptp;

	/* TODO write the value reading from MSR */
	eptp = VMX_EPT_DEFAULT_MT |
		VMX_EPT_DEFAULT_GAW << VMX_EPT_GAW_EPTP_SHIFT;
	eptp |= (root_hpa & PAGE_MASK);

	return eptp;
}

A
Avi Kivity 已提交
2489 2490
static void vmx_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
{
2491 2492 2493 2494
	unsigned long guest_cr3;
	u64 eptp;

	guest_cr3 = cr3;
2495
	if (enable_ept) {
2496 2497
		eptp = construct_eptp(cr3);
		vmcs_write64(EPT_POINTER, eptp);
2498
		guest_cr3 = is_paging(vcpu) ? kvm_read_cr3(vcpu) :
2499
			vcpu->kvm->arch.ept_identity_map_addr;
2500
		ept_load_pdptrs(vcpu);
2501 2502
	}

2503
	vmx_flush_tlb(vcpu);
2504
	vmcs_writel(GUEST_CR3, guest_cr3);
A
Avi Kivity 已提交
2505 2506
}

2507
static int vmx_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
A
Avi Kivity 已提交
2508
{
2509
	unsigned long hw_cr4 = cr4 | (to_vmx(vcpu)->rmode.vm86_active ?
2510 2511
		    KVM_RMODE_VM_CR4_ALWAYS_ON : KVM_PMODE_VM_CR4_ALWAYS_ON);

2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523
	if (cr4 & X86_CR4_VMXE) {
		/*
		 * To use VMXON (and later other VMX instructions), a guest
		 * must first be able to turn on cr4.VMXE (see handle_vmon()).
		 * So basically the check on whether to allow nested VMX
		 * is here.
		 */
		if (!nested_vmx_allowed(vcpu))
			return 1;
	} else if (to_vmx(vcpu)->nested.vmxon)
		return 1;

2524
	vcpu->arch.cr4 = cr4;
2525 2526 2527 2528 2529 2530 2531 2532
	if (enable_ept) {
		if (!is_paging(vcpu)) {
			hw_cr4 &= ~X86_CR4_PAE;
			hw_cr4 |= X86_CR4_PSE;
		} else if (!(cr4 & X86_CR4_PAE)) {
			hw_cr4 &= ~X86_CR4_PAE;
		}
	}
2533 2534 2535

	vmcs_writel(CR4_READ_SHADOW, cr4);
	vmcs_writel(GUEST_CR4, hw_cr4);
2536
	return 0;
A
Avi Kivity 已提交
2537 2538 2539 2540 2541
}

static void vmx_get_segment(struct kvm_vcpu *vcpu,
			    struct kvm_segment *var, int seg)
{
2542 2543
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	struct kvm_save_segment *save;
A
Avi Kivity 已提交
2544 2545
	u32 ar;

2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563
	if (vmx->rmode.vm86_active
	    && (seg == VCPU_SREG_TR || seg == VCPU_SREG_ES
		|| seg == VCPU_SREG_DS || seg == VCPU_SREG_FS
		|| seg == VCPU_SREG_GS)
	    && !emulate_invalid_guest_state) {
		switch (seg) {
		case VCPU_SREG_TR: save = &vmx->rmode.tr; break;
		case VCPU_SREG_ES: save = &vmx->rmode.es; break;
		case VCPU_SREG_DS: save = &vmx->rmode.ds; break;
		case VCPU_SREG_FS: save = &vmx->rmode.fs; break;
		case VCPU_SREG_GS: save = &vmx->rmode.gs; break;
		default: BUG();
		}
		var->selector = save->selector;
		var->base = save->base;
		var->limit = save->limit;
		ar = save->ar;
		if (seg == VCPU_SREG_TR
A
Avi Kivity 已提交
2564
		    || var->selector == vmx_read_guest_seg_selector(vmx, seg))
2565 2566
			goto use_saved_rmode_seg;
	}
A
Avi Kivity 已提交
2567 2568 2569 2570
	var->base = vmx_read_guest_seg_base(vmx, seg);
	var->limit = vmx_read_guest_seg_limit(vmx, seg);
	var->selector = vmx_read_guest_seg_selector(vmx, seg);
	ar = vmx_read_guest_seg_ar(vmx, seg);
2571
use_saved_rmode_seg:
2572
	if ((ar & AR_UNUSABLE_MASK) && !emulate_invalid_guest_state)
A
Avi Kivity 已提交
2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
		ar = 0;
	var->type = ar & 15;
	var->s = (ar >> 4) & 1;
	var->dpl = (ar >> 5) & 3;
	var->present = (ar >> 7) & 1;
	var->avl = (ar >> 12) & 1;
	var->l = (ar >> 13) & 1;
	var->db = (ar >> 14) & 1;
	var->g = (ar >> 15) & 1;
	var->unusable = (ar >> 16) & 1;
}

2585 2586 2587 2588 2589 2590 2591 2592
static u64 vmx_get_segment_base(struct kvm_vcpu *vcpu, int seg)
{
	struct kvm_segment s;

	if (to_vmx(vcpu)->rmode.vm86_active) {
		vmx_get_segment(vcpu, &s, seg);
		return s.base;
	}
A
Avi Kivity 已提交
2593
	return vmx_read_guest_seg_base(to_vmx(vcpu), seg);
2594 2595
}

A
Avi Kivity 已提交
2596
static int __vmx_get_cpl(struct kvm_vcpu *vcpu)
2597
{
2598
	if (!is_protmode(vcpu))
2599 2600
		return 0;

A
Avi Kivity 已提交
2601 2602
	if (!is_long_mode(vcpu)
	    && (kvm_get_rflags(vcpu) & X86_EFLAGS_VM)) /* if virtual 8086 */
2603 2604
		return 3;

A
Avi Kivity 已提交
2605
	return vmx_read_guest_seg_selector(to_vmx(vcpu), VCPU_SREG_CS) & 3;
2606 2607
}

A
Avi Kivity 已提交
2608 2609 2610 2611 2612 2613 2614 2615 2616 2617
static int vmx_get_cpl(struct kvm_vcpu *vcpu)
{
	if (!test_bit(VCPU_EXREG_CPL, (ulong *)&vcpu->arch.regs_avail)) {
		__set_bit(VCPU_EXREG_CPL, (ulong *)&vcpu->arch.regs_avail);
		to_vmx(vcpu)->cpl = __vmx_get_cpl(vcpu);
	}
	return to_vmx(vcpu)->cpl;
}


2618
static u32 vmx_segment_access_rights(struct kvm_segment *var)
A
Avi Kivity 已提交
2619 2620 2621
{
	u32 ar;

2622
	if (var->unusable)
A
Avi Kivity 已提交
2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633
		ar = 1 << 16;
	else {
		ar = var->type & 15;
		ar |= (var->s & 1) << 4;
		ar |= (var->dpl & 3) << 5;
		ar |= (var->present & 1) << 7;
		ar |= (var->avl & 1) << 12;
		ar |= (var->l & 1) << 13;
		ar |= (var->db & 1) << 14;
		ar |= (var->g & 1) << 15;
	}
2634 2635
	if (ar == 0) /* a 0 value means unusable */
		ar = AR_UNUSABLE_MASK;
2636 2637 2638 2639 2640 2641 2642

	return ar;
}

static void vmx_set_segment(struct kvm_vcpu *vcpu,
			    struct kvm_segment *var, int seg)
{
2643
	struct vcpu_vmx *vmx = to_vmx(vcpu);
2644 2645 2646
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
	u32 ar;

A
Avi Kivity 已提交
2647 2648
	vmx_segment_cache_clear(vmx);

2649
	if (vmx->rmode.vm86_active && seg == VCPU_SREG_TR) {
2650
		vmcs_write16(sf->selector, var->selector);
2651 2652 2653 2654
		vmx->rmode.tr.selector = var->selector;
		vmx->rmode.tr.base = var->base;
		vmx->rmode.tr.limit = var->limit;
		vmx->rmode.tr.ar = vmx_segment_access_rights(var);
2655 2656 2657 2658 2659
		return;
	}
	vmcs_writel(sf->base, var->base);
	vmcs_write32(sf->limit, var->limit);
	vmcs_write16(sf->selector, var->selector);
2660
	if (vmx->rmode.vm86_active && var->s) {
2661 2662 2663 2664 2665 2666 2667 2668
		/*
		 * Hack real-mode segments into vm86 compatibility.
		 */
		if (var->base == 0xffff0000 && var->selector == 0xf000)
			vmcs_writel(sf->base, 0xf0000);
		ar = 0xf3;
	} else
		ar = vmx_segment_access_rights(var);
2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683

	/*
	 *   Fix the "Accessed" bit in AR field of segment registers for older
	 * qemu binaries.
	 *   IA32 arch specifies that at the time of processor reset the
	 * "Accessed" bit in the AR field of segment registers is 1. And qemu
	 * is setting it to 0 in the usedland code. This causes invalid guest
	 * state vmexit when "unrestricted guest" mode is turned on.
	 *    Fix for this setup issue in cpu_reset is being pushed in the qemu
	 * tree. Newer qemu binaries with that qemu fix would not need this
	 * kvm hack.
	 */
	if (enable_unrestricted_guest && (seg != VCPU_SREG_LDTR))
		ar |= 0x1; /* Accessed */

A
Avi Kivity 已提交
2684
	vmcs_write32(sf->ar_bytes, ar);
A
Avi Kivity 已提交
2685
	__clear_bit(VCPU_EXREG_CPL, (ulong *)&vcpu->arch.regs_avail);
A
Avi Kivity 已提交
2686 2687 2688 2689
}

static void vmx_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l)
{
A
Avi Kivity 已提交
2690
	u32 ar = vmx_read_guest_seg_ar(to_vmx(vcpu), VCPU_SREG_CS);
A
Avi Kivity 已提交
2691 2692 2693 2694 2695

	*db = (ar >> 14) & 1;
	*l = (ar >> 13) & 1;
}

2696
static void vmx_get_idt(struct kvm_vcpu *vcpu, struct desc_ptr *dt)
A
Avi Kivity 已提交
2697
{
2698 2699
	dt->size = vmcs_read32(GUEST_IDTR_LIMIT);
	dt->address = vmcs_readl(GUEST_IDTR_BASE);
A
Avi Kivity 已提交
2700 2701
}

2702
static void vmx_set_idt(struct kvm_vcpu *vcpu, struct desc_ptr *dt)
A
Avi Kivity 已提交
2703
{
2704 2705
	vmcs_write32(GUEST_IDTR_LIMIT, dt->size);
	vmcs_writel(GUEST_IDTR_BASE, dt->address);
A
Avi Kivity 已提交
2706 2707
}

2708
static void vmx_get_gdt(struct kvm_vcpu *vcpu, struct desc_ptr *dt)
A
Avi Kivity 已提交
2709
{
2710 2711
	dt->size = vmcs_read32(GUEST_GDTR_LIMIT);
	dt->address = vmcs_readl(GUEST_GDTR_BASE);
A
Avi Kivity 已提交
2712 2713
}

2714
static void vmx_set_gdt(struct kvm_vcpu *vcpu, struct desc_ptr *dt)
A
Avi Kivity 已提交
2715
{
2716 2717
	vmcs_write32(GUEST_GDTR_LIMIT, dt->size);
	vmcs_writel(GUEST_GDTR_BASE, dt->address);
A
Avi Kivity 已提交
2718 2719
}

2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745
static bool rmode_segment_valid(struct kvm_vcpu *vcpu, int seg)
{
	struct kvm_segment var;
	u32 ar;

	vmx_get_segment(vcpu, &var, seg);
	ar = vmx_segment_access_rights(&var);

	if (var.base != (var.selector << 4))
		return false;
	if (var.limit != 0xffff)
		return false;
	if (ar != 0xf3)
		return false;

	return true;
}

static bool code_segment_valid(struct kvm_vcpu *vcpu)
{
	struct kvm_segment cs;
	unsigned int cs_rpl;

	vmx_get_segment(vcpu, &cs, VCPU_SREG_CS);
	cs_rpl = cs.selector & SELECTOR_RPL_MASK;

2746 2747
	if (cs.unusable)
		return false;
2748 2749 2750 2751
	if (~cs.type & (AR_TYPE_CODE_MASK|AR_TYPE_ACCESSES_MASK))
		return false;
	if (!cs.s)
		return false;
2752
	if (cs.type & AR_TYPE_WRITEABLE_MASK) {
2753 2754
		if (cs.dpl > cs_rpl)
			return false;
2755
	} else {
2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773
		if (cs.dpl != cs_rpl)
			return false;
	}
	if (!cs.present)
		return false;

	/* TODO: Add Reserved field check, this'll require a new member in the kvm_segment_field structure */
	return true;
}

static bool stack_segment_valid(struct kvm_vcpu *vcpu)
{
	struct kvm_segment ss;
	unsigned int ss_rpl;

	vmx_get_segment(vcpu, &ss, VCPU_SREG_SS);
	ss_rpl = ss.selector & SELECTOR_RPL_MASK;

2774 2775 2776
	if (ss.unusable)
		return true;
	if (ss.type != 3 && ss.type != 7)
2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
		return false;
	if (!ss.s)
		return false;
	if (ss.dpl != ss_rpl) /* DPL != RPL */
		return false;
	if (!ss.present)
		return false;

	return true;
}

static bool data_segment_valid(struct kvm_vcpu *vcpu, int seg)
{
	struct kvm_segment var;
	unsigned int rpl;

	vmx_get_segment(vcpu, &var, seg);
	rpl = var.selector & SELECTOR_RPL_MASK;

2796 2797
	if (var.unusable)
		return true;
2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818
	if (!var.s)
		return false;
	if (!var.present)
		return false;
	if (~var.type & (AR_TYPE_CODE_MASK|AR_TYPE_WRITEABLE_MASK)) {
		if (var.dpl < rpl) /* DPL < RPL */
			return false;
	}

	/* TODO: Add other members to kvm_segment_field to allow checking for other access
	 * rights flags
	 */
	return true;
}

static bool tr_valid(struct kvm_vcpu *vcpu)
{
	struct kvm_segment tr;

	vmx_get_segment(vcpu, &tr, VCPU_SREG_TR);

2819 2820
	if (tr.unusable)
		return false;
2821 2822
	if (tr.selector & SELECTOR_TI_MASK)	/* TI = 1 */
		return false;
2823
	if (tr.type != 3 && tr.type != 11) /* TODO: Check if guest is in IA32e mode */
2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
		return false;
	if (!tr.present)
		return false;

	return true;
}

static bool ldtr_valid(struct kvm_vcpu *vcpu)
{
	struct kvm_segment ldtr;

	vmx_get_segment(vcpu, &ldtr, VCPU_SREG_LDTR);

2837 2838
	if (ldtr.unusable)
		return true;
2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867
	if (ldtr.selector & SELECTOR_TI_MASK)	/* TI = 1 */
		return false;
	if (ldtr.type != 2)
		return false;
	if (!ldtr.present)
		return false;

	return true;
}

static bool cs_ss_rpl_check(struct kvm_vcpu *vcpu)
{
	struct kvm_segment cs, ss;

	vmx_get_segment(vcpu, &cs, VCPU_SREG_CS);
	vmx_get_segment(vcpu, &ss, VCPU_SREG_SS);

	return ((cs.selector & SELECTOR_RPL_MASK) ==
		 (ss.selector & SELECTOR_RPL_MASK));
}

/*
 * Check if guest state is valid. Returns true if valid, false if
 * not.
 * We assume that registers are always usable
 */
static bool guest_state_valid(struct kvm_vcpu *vcpu)
{
	/* real mode guest state checks */
2868
	if (!is_protmode(vcpu)) {
2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909
		if (!rmode_segment_valid(vcpu, VCPU_SREG_CS))
			return false;
		if (!rmode_segment_valid(vcpu, VCPU_SREG_SS))
			return false;
		if (!rmode_segment_valid(vcpu, VCPU_SREG_DS))
			return false;
		if (!rmode_segment_valid(vcpu, VCPU_SREG_ES))
			return false;
		if (!rmode_segment_valid(vcpu, VCPU_SREG_FS))
			return false;
		if (!rmode_segment_valid(vcpu, VCPU_SREG_GS))
			return false;
	} else {
	/* protected mode guest state checks */
		if (!cs_ss_rpl_check(vcpu))
			return false;
		if (!code_segment_valid(vcpu))
			return false;
		if (!stack_segment_valid(vcpu))
			return false;
		if (!data_segment_valid(vcpu, VCPU_SREG_DS))
			return false;
		if (!data_segment_valid(vcpu, VCPU_SREG_ES))
			return false;
		if (!data_segment_valid(vcpu, VCPU_SREG_FS))
			return false;
		if (!data_segment_valid(vcpu, VCPU_SREG_GS))
			return false;
		if (!tr_valid(vcpu))
			return false;
		if (!ldtr_valid(vcpu))
			return false;
	}
	/* TODO:
	 * - Add checks on RIP
	 * - Add checks on RFLAGS
	 */

	return true;
}

M
Mike Day 已提交
2910
static int init_rmode_tss(struct kvm *kvm)
A
Avi Kivity 已提交
2911
{
2912
	gfn_t fn;
2913
	u16 data = 0;
2914
	int r, idx, ret = 0;
A
Avi Kivity 已提交
2915

2916 2917
	idx = srcu_read_lock(&kvm->srcu);
	fn = rmode_tss_base(kvm) >> PAGE_SHIFT;
2918 2919
	r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
	if (r < 0)
2920
		goto out;
2921
	data = TSS_BASE_SIZE + TSS_REDIRECTION_SIZE;
2922 2923
	r = kvm_write_guest_page(kvm, fn++, &data,
			TSS_IOPB_BASE_OFFSET, sizeof(u16));
2924
	if (r < 0)
2925
		goto out;
2926 2927
	r = kvm_clear_guest_page(kvm, fn++, 0, PAGE_SIZE);
	if (r < 0)
2928
		goto out;
2929 2930
	r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
	if (r < 0)
2931
		goto out;
2932
	data = ~0;
2933 2934 2935
	r = kvm_write_guest_page(kvm, fn, &data,
				 RMODE_TSS_SIZE - 2 * PAGE_SIZE - 1,
				 sizeof(u8));
2936
	if (r < 0)
2937 2938 2939 2940
		goto out;

	ret = 1;
out:
2941
	srcu_read_unlock(&kvm->srcu, idx);
2942
	return ret;
A
Avi Kivity 已提交
2943 2944
}

2945 2946
static int init_rmode_identity_map(struct kvm *kvm)
{
2947
	int i, idx, r, ret;
2948 2949 2950
	pfn_t identity_map_pfn;
	u32 tmp;

2951
	if (!enable_ept)
2952 2953 2954 2955 2956 2957 2958 2959 2960
		return 1;
	if (unlikely(!kvm->arch.ept_identity_pagetable)) {
		printk(KERN_ERR "EPT: identity-mapping pagetable "
			"haven't been allocated!\n");
		return 0;
	}
	if (likely(kvm->arch.ept_identity_pagetable_done))
		return 1;
	ret = 0;
2961
	identity_map_pfn = kvm->arch.ept_identity_map_addr >> PAGE_SHIFT;
2962
	idx = srcu_read_lock(&kvm->srcu);
2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977
	r = kvm_clear_guest_page(kvm, identity_map_pfn, 0, PAGE_SIZE);
	if (r < 0)
		goto out;
	/* Set up identity-mapping pagetable for EPT in real mode */
	for (i = 0; i < PT32_ENT_PER_PAGE; i++) {
		tmp = (i << 22) + (_PAGE_PRESENT | _PAGE_RW | _PAGE_USER |
			_PAGE_ACCESSED | _PAGE_DIRTY | _PAGE_PSE);
		r = kvm_write_guest_page(kvm, identity_map_pfn,
				&tmp, i * sizeof(tmp), sizeof(tmp));
		if (r < 0)
			goto out;
	}
	kvm->arch.ept_identity_pagetable_done = true;
	ret = 1;
out:
2978
	srcu_read_unlock(&kvm->srcu, idx);
2979 2980 2981
	return ret;
}

A
Avi Kivity 已提交
2982 2983 2984
static void seg_setup(int seg)
{
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
2985
	unsigned int ar;
A
Avi Kivity 已提交
2986 2987 2988 2989

	vmcs_write16(sf->selector, 0);
	vmcs_writel(sf->base, 0);
	vmcs_write32(sf->limit, 0xffff);
2990 2991 2992 2993 2994 2995 2996 2997
	if (enable_unrestricted_guest) {
		ar = 0x93;
		if (seg == VCPU_SREG_CS)
			ar |= 0x08; /* code segment */
	} else
		ar = 0xf3;

	vmcs_write32(sf->ar_bytes, ar);
A
Avi Kivity 已提交
2998 2999
}

3000 3001 3002 3003 3004
static int alloc_apic_access_page(struct kvm *kvm)
{
	struct kvm_userspace_memory_region kvm_userspace_mem;
	int r = 0;

3005
	mutex_lock(&kvm->slots_lock);
3006
	if (kvm->arch.apic_access_page)
3007 3008 3009 3010 3011 3012 3013 3014
		goto out;
	kvm_userspace_mem.slot = APIC_ACCESS_PAGE_PRIVATE_MEMSLOT;
	kvm_userspace_mem.flags = 0;
	kvm_userspace_mem.guest_phys_addr = 0xfee00000ULL;
	kvm_userspace_mem.memory_size = PAGE_SIZE;
	r = __kvm_set_memory_region(kvm, &kvm_userspace_mem, 0);
	if (r)
		goto out;
3015

3016
	kvm->arch.apic_access_page = gfn_to_page(kvm, 0xfee00);
3017
out:
3018
	mutex_unlock(&kvm->slots_lock);
3019 3020 3021
	return r;
}

3022 3023 3024 3025 3026
static int alloc_identity_pagetable(struct kvm *kvm)
{
	struct kvm_userspace_memory_region kvm_userspace_mem;
	int r = 0;

3027
	mutex_lock(&kvm->slots_lock);
3028 3029 3030 3031
	if (kvm->arch.ept_identity_pagetable)
		goto out;
	kvm_userspace_mem.slot = IDENTITY_PAGETABLE_PRIVATE_MEMSLOT;
	kvm_userspace_mem.flags = 0;
3032 3033
	kvm_userspace_mem.guest_phys_addr =
		kvm->arch.ept_identity_map_addr;
3034 3035 3036 3037 3038 3039
	kvm_userspace_mem.memory_size = PAGE_SIZE;
	r = __kvm_set_memory_region(kvm, &kvm_userspace_mem, 0);
	if (r)
		goto out;

	kvm->arch.ept_identity_pagetable = gfn_to_page(kvm,
3040
			kvm->arch.ept_identity_map_addr >> PAGE_SHIFT);
3041
out:
3042
	mutex_unlock(&kvm->slots_lock);
3043 3044 3045
	return r;
}

3046 3047 3048 3049 3050
static void allocate_vpid(struct vcpu_vmx *vmx)
{
	int vpid;

	vmx->vpid = 0;
3051
	if (!enable_vpid)
3052 3053 3054 3055 3056 3057 3058 3059 3060 3061
		return;
	spin_lock(&vmx_vpid_lock);
	vpid = find_first_zero_bit(vmx_vpid_bitmap, VMX_NR_VPIDS);
	if (vpid < VMX_NR_VPIDS) {
		vmx->vpid = vpid;
		__set_bit(vpid, vmx_vpid_bitmap);
	}
	spin_unlock(&vmx_vpid_lock);
}

3062 3063 3064 3065 3066 3067 3068 3069 3070 3071
static void free_vpid(struct vcpu_vmx *vmx)
{
	if (!enable_vpid)
		return;
	spin_lock(&vmx_vpid_lock);
	if (vmx->vpid != 0)
		__clear_bit(vmx->vpid, vmx_vpid_bitmap);
	spin_unlock(&vmx_vpid_lock);
}

3072
static void __vmx_disable_intercept_for_msr(unsigned long *msr_bitmap, u32 msr)
S
Sheng Yang 已提交
3073
{
3074
	int f = sizeof(unsigned long);
S
Sheng Yang 已提交
3075 3076 3077 3078 3079 3080 3081 3082 3083 3084

	if (!cpu_has_vmx_msr_bitmap())
		return;

	/*
	 * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals
	 * have the write-low and read-high bitmap offsets the wrong way round.
	 * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff.
	 */
	if (msr <= 0x1fff) {
3085 3086
		__clear_bit(msr, msr_bitmap + 0x000 / f); /* read-low */
		__clear_bit(msr, msr_bitmap + 0x800 / f); /* write-low */
S
Sheng Yang 已提交
3087 3088
	} else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) {
		msr &= 0x1fff;
3089 3090
		__clear_bit(msr, msr_bitmap + 0x400 / f); /* read-high */
		__clear_bit(msr, msr_bitmap + 0xc00 / f); /* write-high */
S
Sheng Yang 已提交
3091 3092 3093
	}
}

3094 3095 3096 3097 3098 3099 3100
static void vmx_disable_intercept_for_msr(u32 msr, bool longmode_only)
{
	if (!longmode_only)
		__vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy, msr);
	__vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode, msr);
}

A
Avi Kivity 已提交
3101 3102 3103
/*
 * Sets up the vmcs for emulated real mode.
 */
R
Rusty Russell 已提交
3104
static int vmx_vcpu_setup(struct vcpu_vmx *vmx)
A
Avi Kivity 已提交
3105
{
S
Sheng Yang 已提交
3106
	u32 host_sysenter_cs, msr_low, msr_high;
A
Avi Kivity 已提交
3107
	u32 junk;
3108
	u64 host_pat;
A
Avi Kivity 已提交
3109
	unsigned long a;
3110
	struct desc_ptr dt;
A
Avi Kivity 已提交
3111
	int i;
3112
	unsigned long kvm_vmx_return;
3113
	u32 exec_control;
A
Avi Kivity 已提交
3114 3115

	/* I/O */
3116 3117
	vmcs_write64(IO_BITMAP_A, __pa(vmx_io_bitmap_a));
	vmcs_write64(IO_BITMAP_B, __pa(vmx_io_bitmap_b));
A
Avi Kivity 已提交
3118

S
Sheng Yang 已提交
3119
	if (cpu_has_vmx_msr_bitmap())
3120
		vmcs_write64(MSR_BITMAP, __pa(vmx_msr_bitmap_legacy));
S
Sheng Yang 已提交
3121

A
Avi Kivity 已提交
3122 3123 3124
	vmcs_write64(VMCS_LINK_POINTER, -1ull); /* 22.3.1.5 */

	/* Control */
3125 3126
	vmcs_write32(PIN_BASED_VM_EXEC_CONTROL,
		vmcs_config.pin_based_exec_ctrl);
3127 3128 3129 3130 3131 3132 3133 3134 3135

	exec_control = vmcs_config.cpu_based_exec_ctrl;
	if (!vm_need_tpr_shadow(vmx->vcpu.kvm)) {
		exec_control &= ~CPU_BASED_TPR_SHADOW;
#ifdef CONFIG_X86_64
		exec_control |= CPU_BASED_CR8_STORE_EXITING |
				CPU_BASED_CR8_LOAD_EXITING;
#endif
	}
3136
	if (!enable_ept)
S
Sheng Yang 已提交
3137
		exec_control |= CPU_BASED_CR3_STORE_EXITING |
3138 3139
				CPU_BASED_CR3_LOAD_EXITING  |
				CPU_BASED_INVLPG_EXITING;
3140
	vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, exec_control);
A
Avi Kivity 已提交
3141

3142 3143 3144 3145 3146
	if (cpu_has_secondary_exec_ctrls()) {
		exec_control = vmcs_config.cpu_based_2nd_exec_ctrl;
		if (!vm_need_virtualize_apic_accesses(vmx->vcpu.kvm))
			exec_control &=
				~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES;
3147 3148
		if (vmx->vpid == 0)
			exec_control &= ~SECONDARY_EXEC_ENABLE_VPID;
3149
		if (!enable_ept) {
S
Sheng Yang 已提交
3150
			exec_control &= ~SECONDARY_EXEC_ENABLE_EPT;
3151 3152
			enable_unrestricted_guest = 0;
		}
3153 3154
		if (!enable_unrestricted_guest)
			exec_control &= ~SECONDARY_EXEC_UNRESTRICTED_GUEST;
3155 3156
		if (!ple_gap)
			exec_control &= ~SECONDARY_EXEC_PAUSE_LOOP_EXITING;
3157 3158
		vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control);
	}
3159

3160 3161 3162 3163 3164
	if (ple_gap) {
		vmcs_write32(PLE_GAP, ple_gap);
		vmcs_write32(PLE_WINDOW, ple_window);
	}

3165 3166
	vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, !!bypass_guest_pf);
	vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, !!bypass_guest_pf);
A
Avi Kivity 已提交
3167 3168
	vmcs_write32(CR3_TARGET_COUNT, 0);           /* 22.2.1 */

3169
	vmcs_writel(HOST_CR0, read_cr0() | X86_CR0_TS);  /* 22.2.3 */
A
Avi Kivity 已提交
3170 3171 3172 3173 3174 3175
	vmcs_writel(HOST_CR4, read_cr4());  /* 22.2.3, 22.2.5 */
	vmcs_writel(HOST_CR3, read_cr3());  /* 22.2.3  FIXME: shadow tables */

	vmcs_write16(HOST_CS_SELECTOR, __KERNEL_CS);  /* 22.2.4 */
	vmcs_write16(HOST_DS_SELECTOR, __KERNEL_DS);  /* 22.2.4 */
	vmcs_write16(HOST_ES_SELECTOR, __KERNEL_DS);  /* 22.2.4 */
3176 3177
	vmcs_write16(HOST_FS_SELECTOR, 0);            /* 22.2.4 */
	vmcs_write16(HOST_GS_SELECTOR, 0);            /* 22.2.4 */
A
Avi Kivity 已提交
3178
	vmcs_write16(HOST_SS_SELECTOR, __KERNEL_DS);  /* 22.2.4 */
3179
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190
	rdmsrl(MSR_FS_BASE, a);
	vmcs_writel(HOST_FS_BASE, a); /* 22.2.4 */
	rdmsrl(MSR_GS_BASE, a);
	vmcs_writel(HOST_GS_BASE, a); /* 22.2.4 */
#else
	vmcs_writel(HOST_FS_BASE, 0); /* 22.2.4 */
	vmcs_writel(HOST_GS_BASE, 0); /* 22.2.4 */
#endif

	vmcs_write16(HOST_TR_SELECTOR, GDT_ENTRY_TSS*8);  /* 22.2.4 */

3191
	native_store_idt(&dt);
3192
	vmcs_writel(HOST_IDTR_BASE, dt.address);   /* 22.2.4 */
A
Avi Kivity 已提交
3193

M
Mike Day 已提交
3194
	asm("mov $.Lkvm_vmx_return, %0" : "=r"(kvm_vmx_return));
3195
	vmcs_writel(HOST_RIP, kvm_vmx_return); /* 22.2.5 */
3196 3197
	vmcs_write32(VM_EXIT_MSR_STORE_COUNT, 0);
	vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, 0);
3198
	vmcs_write64(VM_EXIT_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.host));
3199
	vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, 0);
3200
	vmcs_write64(VM_ENTRY_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.guest));
A
Avi Kivity 已提交
3201 3202 3203 3204 3205 3206 3207 3208

	rdmsr(MSR_IA32_SYSENTER_CS, host_sysenter_cs, junk);
	vmcs_write32(HOST_IA32_SYSENTER_CS, host_sysenter_cs);
	rdmsrl(MSR_IA32_SYSENTER_ESP, a);
	vmcs_writel(HOST_IA32_SYSENTER_ESP, a);   /* 22.2.3 */
	rdmsrl(MSR_IA32_SYSENTER_EIP, a);
	vmcs_writel(HOST_IA32_SYSENTER_EIP, a);   /* 22.2.3 */

S
Sheng Yang 已提交
3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222
	if (vmcs_config.vmexit_ctrl & VM_EXIT_LOAD_IA32_PAT) {
		rdmsr(MSR_IA32_CR_PAT, msr_low, msr_high);
		host_pat = msr_low | ((u64) msr_high << 32);
		vmcs_write64(HOST_IA32_PAT, host_pat);
	}
	if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) {
		rdmsr(MSR_IA32_CR_PAT, msr_low, msr_high);
		host_pat = msr_low | ((u64) msr_high << 32);
		/* Write the default value follow host pat */
		vmcs_write64(GUEST_IA32_PAT, host_pat);
		/* Keep arch.pat sync with GUEST_IA32_PAT */
		vmx->vcpu.arch.pat = host_pat;
	}

A
Avi Kivity 已提交
3223 3224 3225
	for (i = 0; i < NR_VMX_MSR; ++i) {
		u32 index = vmx_msr_index[i];
		u32 data_low, data_high;
3226
		int j = vmx->nmsrs;
A
Avi Kivity 已提交
3227 3228 3229

		if (rdmsr_safe(index, &data_low, &data_high) < 0)
			continue;
3230 3231
		if (wrmsr_safe(index, data_low, data_high) < 0)
			continue;
3232 3233
		vmx->guest_msrs[j].index = i;
		vmx->guest_msrs[j].data = 0;
3234
		vmx->guest_msrs[j].mask = -1ull;
3235
		++vmx->nmsrs;
A
Avi Kivity 已提交
3236 3237
	}

3238
	vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl);
A
Avi Kivity 已提交
3239 3240

	/* 22.2.1, 20.8.1 */
3241 3242
	vmcs_write32(VM_ENTRY_CONTROLS, vmcs_config.vmentry_ctrl);

3243
	vmcs_writel(CR0_GUEST_HOST_MASK, ~0UL);
3244
	vmx->vcpu.arch.cr4_guest_owned_bits = KVM_CR4_GUEST_OWNED_BITS;
3245 3246
	if (enable_ept)
		vmx->vcpu.arch.cr4_guest_owned_bits |= X86_CR4_PGE;
3247
	vmcs_writel(CR4_GUEST_HOST_MASK, ~vmx->vcpu.arch.cr4_guest_owned_bits);
3248

3249
	kvm_write_tsc(&vmx->vcpu, 0);
3250

3251 3252 3253 3254 3255 3256 3257
	return 0;
}

static int vmx_vcpu_reset(struct kvm_vcpu *vcpu)
{
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	u64 msr;
3258
	int ret;
3259

3260
	vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) | (1 << VCPU_REGS_RSP));
3261

3262
	vmx->rmode.vm86_active = 0;
3263

3264 3265
	vmx->soft_vnmi_blocked = 0;

3266
	vmx->vcpu.arch.regs[VCPU_REGS_RDX] = get_rdx_init_val();
3267
	kvm_set_cr8(&vmx->vcpu, 0);
3268
	msr = 0xfee00000 | MSR_IA32_APICBASE_ENABLE;
3269
	if (kvm_vcpu_is_bsp(&vmx->vcpu))
3270 3271 3272
		msr |= MSR_IA32_APICBASE_BSP;
	kvm_set_apic_base(&vmx->vcpu, msr);

3273 3274 3275
	ret = fx_init(&vmx->vcpu);
	if (ret != 0)
		goto out;
3276

A
Avi Kivity 已提交
3277 3278
	vmx_segment_cache_clear(vmx);

3279
	seg_setup(VCPU_SREG_CS);
3280 3281 3282 3283
	/*
	 * GUEST_CS_BASE should really be 0xffff0000, but VT vm86 mode
	 * insists on having GUEST_CS_BASE == GUEST_CS_SELECTOR << 4.  Sigh.
	 */
3284
	if (kvm_vcpu_is_bsp(&vmx->vcpu)) {
3285 3286 3287
		vmcs_write16(GUEST_CS_SELECTOR, 0xf000);
		vmcs_writel(GUEST_CS_BASE, 0x000f0000);
	} else {
3288 3289
		vmcs_write16(GUEST_CS_SELECTOR, vmx->vcpu.arch.sipi_vector << 8);
		vmcs_writel(GUEST_CS_BASE, vmx->vcpu.arch.sipi_vector << 12);
3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312
	}

	seg_setup(VCPU_SREG_DS);
	seg_setup(VCPU_SREG_ES);
	seg_setup(VCPU_SREG_FS);
	seg_setup(VCPU_SREG_GS);
	seg_setup(VCPU_SREG_SS);

	vmcs_write16(GUEST_TR_SELECTOR, 0);
	vmcs_writel(GUEST_TR_BASE, 0);
	vmcs_write32(GUEST_TR_LIMIT, 0xffff);
	vmcs_write32(GUEST_TR_AR_BYTES, 0x008b);

	vmcs_write16(GUEST_LDTR_SELECTOR, 0);
	vmcs_writel(GUEST_LDTR_BASE, 0);
	vmcs_write32(GUEST_LDTR_LIMIT, 0xffff);
	vmcs_write32(GUEST_LDTR_AR_BYTES, 0x00082);

	vmcs_write32(GUEST_SYSENTER_CS, 0);
	vmcs_writel(GUEST_SYSENTER_ESP, 0);
	vmcs_writel(GUEST_SYSENTER_EIP, 0);

	vmcs_writel(GUEST_RFLAGS, 0x02);
3313
	if (kvm_vcpu_is_bsp(&vmx->vcpu))
3314
		kvm_rip_write(vcpu, 0xfff0);
3315
	else
3316 3317
		kvm_rip_write(vcpu, 0);
	kvm_register_write(vcpu, VCPU_REGS_RSP, 0);
3318 3319 3320 3321 3322 3323 3324 3325 3326

	vmcs_writel(GUEST_DR7, 0x400);

	vmcs_writel(GUEST_GDTR_BASE, 0);
	vmcs_write32(GUEST_GDTR_LIMIT, 0xffff);

	vmcs_writel(GUEST_IDTR_BASE, 0);
	vmcs_write32(GUEST_IDTR_LIMIT, 0xffff);

3327
	vmcs_write32(GUEST_ACTIVITY_STATE, GUEST_ACTIVITY_ACTIVE);
3328 3329 3330 3331 3332 3333 3334 3335
	vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, 0);
	vmcs_write32(GUEST_PENDING_DBG_EXCEPTIONS, 0);

	/* Special registers */
	vmcs_write64(GUEST_IA32_DEBUGCTL, 0);

	setup_msrs(vmx);

A
Avi Kivity 已提交
3336 3337
	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0);  /* 22.2.1 */

3338 3339 3340 3341
	if (cpu_has_vmx_tpr_shadow()) {
		vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, 0);
		if (vm_need_tpr_shadow(vmx->vcpu.kvm))
			vmcs_write64(VIRTUAL_APIC_PAGE_ADDR,
3342
				     __pa(vmx->vcpu.arch.apic->regs));
3343 3344 3345 3346 3347
		vmcs_write32(TPR_THRESHOLD, 0);
	}

	if (vm_need_virtualize_apic_accesses(vmx->vcpu.kvm))
		vmcs_write64(APIC_ACCESS_ADDR,
3348
			     page_to_phys(vmx->vcpu.kvm->arch.apic_access_page));
A
Avi Kivity 已提交
3349

3350 3351 3352
	if (vmx->vpid != 0)
		vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid);

3353
	vmx->vcpu.arch.cr0 = X86_CR0_NW | X86_CR0_CD | X86_CR0_ET;
3354
	vmx_set_cr0(&vmx->vcpu, kvm_read_cr0(vcpu)); /* enter rmode */
R
Rusty Russell 已提交
3355 3356 3357 3358
	vmx_set_cr4(&vmx->vcpu, 0);
	vmx_set_efer(&vmx->vcpu, 0);
	vmx_fpu_activate(&vmx->vcpu);
	update_exception_bitmap(&vmx->vcpu);
A
Avi Kivity 已提交
3359

3360
	vpid_sync_context(vmx);
3361

3362
	ret = 0;
A
Avi Kivity 已提交
3363

3364 3365 3366
	/* HACK: Don't enable emulation on guest boot/reset */
	vmx->emulation_required = 0;

A
Avi Kivity 已提交
3367 3368 3369 3370
out:
	return ret;
}

3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388
static void enable_irq_window(struct kvm_vcpu *vcpu)
{
	u32 cpu_based_vm_exec_control;

	cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL);
	cpu_based_vm_exec_control |= CPU_BASED_VIRTUAL_INTR_PENDING;
	vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control);
}

static void enable_nmi_window(struct kvm_vcpu *vcpu)
{
	u32 cpu_based_vm_exec_control;

	if (!cpu_has_virtual_nmis()) {
		enable_irq_window(vcpu);
		return;
	}

3389 3390 3391 3392
	if (vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_STI) {
		enable_irq_window(vcpu);
		return;
	}
3393 3394 3395 3396 3397
	cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL);
	cpu_based_vm_exec_control |= CPU_BASED_VIRTUAL_NMI_PENDING;
	vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control);
}

3398
static void vmx_inject_irq(struct kvm_vcpu *vcpu)
3399
{
3400
	struct vcpu_vmx *vmx = to_vmx(vcpu);
3401 3402
	uint32_t intr;
	int irq = vcpu->arch.interrupt.nr;
3403

3404
	trace_kvm_inj_virq(irq);
F
Feng (Eric) Liu 已提交
3405

3406
	++vcpu->stat.irq_injections;
3407
	if (vmx->rmode.vm86_active) {
3408 3409 3410 3411
		int inc_eip = 0;
		if (vcpu->arch.interrupt.soft)
			inc_eip = vcpu->arch.event_exit_inst_len;
		if (kvm_inject_realmode_interrupt(vcpu, irq, inc_eip) != EMULATE_DONE)
3412
			kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu);
3413 3414
		return;
	}
3415 3416 3417 3418 3419 3420 3421 3422
	intr = irq | INTR_INFO_VALID_MASK;
	if (vcpu->arch.interrupt.soft) {
		intr |= INTR_TYPE_SOFT_INTR;
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN,
			     vmx->vcpu.arch.event_exit_inst_len);
	} else
		intr |= INTR_TYPE_EXT_INTR;
	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr);
3423
	vmx_clear_hlt(vcpu);
3424 3425
}

3426 3427
static void vmx_inject_nmi(struct kvm_vcpu *vcpu)
{
J
Jan Kiszka 已提交
3428 3429
	struct vcpu_vmx *vmx = to_vmx(vcpu);

3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442
	if (!cpu_has_virtual_nmis()) {
		/*
		 * Tracking the NMI-blocked state in software is built upon
		 * finding the next open IRQ window. This, in turn, depends on
		 * well-behaving guests: They have to keep IRQs disabled at
		 * least as long as the NMI handler runs. Otherwise we may
		 * cause NMI nesting, maybe breaking the guest. But as this is
		 * highly unlikely, we can live with the residual risk.
		 */
		vmx->soft_vnmi_blocked = 1;
		vmx->vnmi_blocked_time = 0;
	}

3443
	++vcpu->stat.nmi_injections;
3444
	vmx->nmi_known_unmasked = false;
3445
	if (vmx->rmode.vm86_active) {
3446
		if (kvm_inject_realmode_interrupt(vcpu, NMI_VECTOR, 0) != EMULATE_DONE)
3447
			kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu);
J
Jan Kiszka 已提交
3448 3449
		return;
	}
3450 3451
	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
			INTR_TYPE_NMI_INTR | INTR_INFO_VALID_MASK | NMI_VECTOR);
3452
	vmx_clear_hlt(vcpu);
3453 3454
}

3455
static int vmx_nmi_allowed(struct kvm_vcpu *vcpu)
3456
{
3457
	if (!cpu_has_virtual_nmis() && to_vmx(vcpu)->soft_vnmi_blocked)
3458
		return 0;
3459

3460
	return	!(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
3461 3462
		  (GUEST_INTR_STATE_MOV_SS | GUEST_INTR_STATE_STI
		   | GUEST_INTR_STATE_NMI));
3463 3464
}

J
Jan Kiszka 已提交
3465 3466 3467 3468
static bool vmx_get_nmi_mask(struct kvm_vcpu *vcpu)
{
	if (!cpu_has_virtual_nmis())
		return to_vmx(vcpu)->soft_vnmi_blocked;
3469 3470
	if (to_vmx(vcpu)->nmi_known_unmasked)
		return false;
3471
	return vmcs_read32(GUEST_INTERRUPTIBILITY_INFO)	& GUEST_INTR_STATE_NMI;
J
Jan Kiszka 已提交
3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483
}

static void vmx_set_nmi_mask(struct kvm_vcpu *vcpu, bool masked)
{
	struct vcpu_vmx *vmx = to_vmx(vcpu);

	if (!cpu_has_virtual_nmis()) {
		if (vmx->soft_vnmi_blocked != masked) {
			vmx->soft_vnmi_blocked = masked;
			vmx->vnmi_blocked_time = 0;
		}
	} else {
3484
		vmx->nmi_known_unmasked = !masked;
J
Jan Kiszka 已提交
3485 3486 3487 3488 3489 3490 3491 3492 3493
		if (masked)
			vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
				      GUEST_INTR_STATE_NMI);
		else
			vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO,
					GUEST_INTR_STATE_NMI);
	}
}

3494 3495
static int vmx_interrupt_allowed(struct kvm_vcpu *vcpu)
{
3496 3497 3498
	return (vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) &&
		!(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
			(GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS));
3499 3500
}

3501 3502 3503 3504
static int vmx_set_tss_addr(struct kvm *kvm, unsigned int addr)
{
	int ret;
	struct kvm_userspace_memory_region tss_mem = {
3505
		.slot = TSS_PRIVATE_MEMSLOT,
3506 3507 3508 3509 3510 3511 3512 3513
		.guest_phys_addr = addr,
		.memory_size = PAGE_SIZE * 3,
		.flags = 0,
	};

	ret = kvm_set_memory_region(kvm, &tss_mem, 0);
	if (ret)
		return ret;
3514
	kvm->arch.tss_addr = addr;
3515 3516 3517
	if (!init_rmode_tss(kvm))
		return  -ENOMEM;

3518 3519 3520
	return 0;
}

A
Avi Kivity 已提交
3521 3522 3523
static int handle_rmode_exception(struct kvm_vcpu *vcpu,
				  int vec, u32 err_code)
{
3524 3525 3526 3527 3528
	/*
	 * Instruction with address size override prefix opcode 0x67
	 * Cause the #SS fault with 0 error code in VM86 mode.
	 */
	if (((vec == GP_VECTOR) || (vec == SS_VECTOR)) && err_code == 0)
3529
		if (emulate_instruction(vcpu, 0) == EMULATE_DONE)
A
Avi Kivity 已提交
3530
			return 1;
3531 3532 3533 3534 3535 3536 3537
	/*
	 * Forward all other exceptions that are valid in real mode.
	 * FIXME: Breaks guest debugging in real mode, needs to be fixed with
	 *        the required debugging infrastructure rework.
	 */
	switch (vec) {
	case DB_VECTOR:
J
Jan Kiszka 已提交
3538 3539 3540 3541 3542
		if (vcpu->guest_debug &
		    (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP))
			return 0;
		kvm_queue_exception(vcpu, vec);
		return 1;
3543
	case BP_VECTOR:
3544 3545 3546 3547 3548 3549
		/*
		 * Update instruction length as we may reinject the exception
		 * from user space while in guest debugging mode.
		 */
		to_vmx(vcpu)->vcpu.arch.event_exit_inst_len =
			vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
J
Jan Kiszka 已提交
3550 3551 3552 3553
		if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP)
			return 0;
		/* fall through */
	case DE_VECTOR:
3554 3555 3556 3557 3558 3559 3560 3561 3562 3563
	case OF_VECTOR:
	case BR_VECTOR:
	case UD_VECTOR:
	case DF_VECTOR:
	case SS_VECTOR:
	case GP_VECTOR:
	case MF_VECTOR:
		kvm_queue_exception(vcpu, vec);
		return 1;
	}
A
Avi Kivity 已提交
3564 3565 3566
	return 0;
}

A
Andi Kleen 已提交
3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585
/*
 * Trigger machine check on the host. We assume all the MSRs are already set up
 * by the CPU and that we still run on the same CPU as the MCE occurred on.
 * We pass a fake environment to the machine check handler because we want
 * the guest to be always treated like user space, no matter what context
 * it used internally.
 */
static void kvm_machine_check(void)
{
#if defined(CONFIG_X86_MCE) && defined(CONFIG_X86_64)
	struct pt_regs regs = {
		.cs = 3, /* Fake ring 3 no matter what the guest ran on */
		.flags = X86_EFLAGS_IF,
	};

	do_machine_check(&regs, 0);
#endif
}

A
Avi Kivity 已提交
3586
static int handle_machine_check(struct kvm_vcpu *vcpu)
A
Andi Kleen 已提交
3587 3588 3589 3590 3591
{
	/* already handled by vcpu_run */
	return 1;
}

A
Avi Kivity 已提交
3592
static int handle_exception(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3593
{
3594
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Avi Kivity 已提交
3595
	struct kvm_run *kvm_run = vcpu->run;
J
Jan Kiszka 已提交
3596
	u32 intr_info, ex_no, error_code;
3597
	unsigned long cr2, rip, dr6;
A
Avi Kivity 已提交
3598 3599 3600
	u32 vect_info;
	enum emulation_result er;

3601
	vect_info = vmx->idt_vectoring_info;
3602
	intr_info = vmx->exit_intr_info;
A
Avi Kivity 已提交
3603

A
Andi Kleen 已提交
3604
	if (is_machine_check(intr_info))
A
Avi Kivity 已提交
3605
		return handle_machine_check(vcpu);
A
Andi Kleen 已提交
3606

A
Avi Kivity 已提交
3607
	if ((vect_info & VECTORING_INFO_VALID_MASK) &&
3608 3609 3610 3611 3612 3613 3614 3615
	    !is_page_fault(intr_info)) {
		vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
		vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_SIMUL_EX;
		vcpu->run->internal.ndata = 2;
		vcpu->run->internal.data[0] = vect_info;
		vcpu->run->internal.data[1] = intr_info;
		return 0;
	}
A
Avi Kivity 已提交
3616

3617
	if ((intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR)
3618
		return 1;  /* already handled by vmx_vcpu_run() */
3619 3620

	if (is_no_device(intr_info)) {
3621
		vmx_fpu_activate(vcpu);
3622 3623 3624
		return 1;
	}

3625
	if (is_invalid_opcode(intr_info)) {
3626
		er = emulate_instruction(vcpu, EMULTYPE_TRAP_UD);
3627
		if (er != EMULATE_DONE)
3628
			kvm_queue_exception(vcpu, UD_VECTOR);
3629 3630 3631
		return 1;
	}

A
Avi Kivity 已提交
3632
	error_code = 0;
3633
	if (intr_info & INTR_INFO_DELIVER_CODE_MASK)
A
Avi Kivity 已提交
3634 3635
		error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE);
	if (is_page_fault(intr_info)) {
3636
		/* EPT won't cause page fault directly */
3637
		if (enable_ept)
3638
			BUG();
A
Avi Kivity 已提交
3639
		cr2 = vmcs_readl(EXIT_QUALIFICATION);
3640 3641
		trace_kvm_page_fault(cr2, error_code);

3642
		if (kvm_event_needs_reinjection(vcpu))
3643
			kvm_mmu_unprotect_page_virt(vcpu, cr2);
3644
		return kvm_mmu_page_fault(vcpu, cr2, error_code, NULL, 0);
A
Avi Kivity 已提交
3645 3646
	}

3647
	if (vmx->rmode.vm86_active &&
A
Avi Kivity 已提交
3648
	    handle_rmode_exception(vcpu, intr_info & INTR_INFO_VECTOR_MASK,
3649
								error_code)) {
3650 3651
		if (vcpu->arch.halt_request) {
			vcpu->arch.halt_request = 0;
3652 3653
			return kvm_emulate_halt(vcpu);
		}
A
Avi Kivity 已提交
3654
		return 1;
3655
	}
A
Avi Kivity 已提交
3656

J
Jan Kiszka 已提交
3657
	ex_no = intr_info & INTR_INFO_VECTOR_MASK;
3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670
	switch (ex_no) {
	case DB_VECTOR:
		dr6 = vmcs_readl(EXIT_QUALIFICATION);
		if (!(vcpu->guest_debug &
		      (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP))) {
			vcpu->arch.dr6 = dr6 | DR6_FIXED_1;
			kvm_queue_exception(vcpu, DB_VECTOR);
			return 1;
		}
		kvm_run->debug.arch.dr6 = dr6 | DR6_FIXED_1;
		kvm_run->debug.arch.dr7 = vmcs_readl(GUEST_DR7);
		/* fall through */
	case BP_VECTOR:
3671 3672 3673 3674 3675 3676 3677
		/*
		 * Update instruction length as we may reinject #BP from
		 * user space while in guest debugging mode. Reading it for
		 * #DB as well causes no harm, it is not used in that case.
		 */
		vmx->vcpu.arch.event_exit_inst_len =
			vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
A
Avi Kivity 已提交
3678
		kvm_run->exit_reason = KVM_EXIT_DEBUG;
3679
		rip = kvm_rip_read(vcpu);
J
Jan Kiszka 已提交
3680 3681
		kvm_run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + rip;
		kvm_run->debug.arch.exception = ex_no;
3682 3683
		break;
	default:
J
Jan Kiszka 已提交
3684 3685 3686
		kvm_run->exit_reason = KVM_EXIT_EXCEPTION;
		kvm_run->ex.exception = ex_no;
		kvm_run->ex.error_code = error_code;
3687
		break;
A
Avi Kivity 已提交
3688 3689 3690 3691
	}
	return 0;
}

A
Avi Kivity 已提交
3692
static int handle_external_interrupt(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3693
{
A
Avi Kivity 已提交
3694
	++vcpu->stat.irq_exits;
A
Avi Kivity 已提交
3695 3696 3697
	return 1;
}

A
Avi Kivity 已提交
3698
static int handle_triple_fault(struct kvm_vcpu *vcpu)
3699
{
A
Avi Kivity 已提交
3700
	vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
3701 3702
	return 0;
}
A
Avi Kivity 已提交
3703

A
Avi Kivity 已提交
3704
static int handle_io(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3705
{
3706
	unsigned long exit_qualification;
3707
	int size, in, string;
3708
	unsigned port;
A
Avi Kivity 已提交
3709

3710
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
3711
	string = (exit_qualification & 16) != 0;
3712
	in = (exit_qualification & 8) != 0;
3713

3714
	++vcpu->stat.io_exits;
3715

3716
	if (string || in)
3717
		return emulate_instruction(vcpu, 0) == EMULATE_DONE;
3718

3719 3720
	port = exit_qualification >> 16;
	size = (exit_qualification & 7) + 1;
3721
	skip_emulated_instruction(vcpu);
3722 3723

	return kvm_fast_pio_out(vcpu, size, port);
A
Avi Kivity 已提交
3724 3725
}

I
Ingo Molnar 已提交
3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736
static void
vmx_patch_hypercall(struct kvm_vcpu *vcpu, unsigned char *hypercall)
{
	/*
	 * Patch in the VMCALL instruction:
	 */
	hypercall[0] = 0x0f;
	hypercall[1] = 0x01;
	hypercall[2] = 0xc1;
}

A
Avi Kivity 已提交
3737
static int handle_cr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3738
{
3739
	unsigned long exit_qualification, val;
A
Avi Kivity 已提交
3740 3741
	int cr;
	int reg;
3742
	int err;
A
Avi Kivity 已提交
3743

3744
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
A
Avi Kivity 已提交
3745 3746 3747 3748
	cr = exit_qualification & 15;
	reg = (exit_qualification >> 8) & 15;
	switch ((exit_qualification >> 4) & 3) {
	case 0: /* mov to cr */
3749 3750
		val = kvm_register_read(vcpu, reg);
		trace_kvm_cr_write(cr, val);
A
Avi Kivity 已提交
3751 3752
		switch (cr) {
		case 0:
3753
			err = kvm_set_cr0(vcpu, val);
3754
			kvm_complete_insn_gp(vcpu, err);
A
Avi Kivity 已提交
3755 3756
			return 1;
		case 3:
3757
			err = kvm_set_cr3(vcpu, val);
3758
			kvm_complete_insn_gp(vcpu, err);
A
Avi Kivity 已提交
3759 3760
			return 1;
		case 4:
3761
			err = kvm_set_cr4(vcpu, val);
3762
			kvm_complete_insn_gp(vcpu, err);
A
Avi Kivity 已提交
3763
			return 1;
3764 3765 3766
		case 8: {
				u8 cr8_prev = kvm_get_cr8(vcpu);
				u8 cr8 = kvm_register_read(vcpu, reg);
A
Andre Przywara 已提交
3767
				err = kvm_set_cr8(vcpu, cr8);
3768
				kvm_complete_insn_gp(vcpu, err);
3769 3770 3771 3772
				if (irqchip_in_kernel(vcpu->kvm))
					return 1;
				if (cr8_prev <= cr8)
					return 1;
A
Avi Kivity 已提交
3773
				vcpu->run->exit_reason = KVM_EXIT_SET_TPR;
3774 3775
				return 0;
			}
A
Avi Kivity 已提交
3776 3777
		};
		break;
3778
	case 2: /* clts */
3779
		vmx_set_cr0(vcpu, kvm_read_cr0_bits(vcpu, ~X86_CR0_TS));
3780
		trace_kvm_cr_write(0, kvm_read_cr0(vcpu));
3781
		skip_emulated_instruction(vcpu);
A
Avi Kivity 已提交
3782
		vmx_fpu_activate(vcpu);
3783
		return 1;
A
Avi Kivity 已提交
3784 3785 3786
	case 1: /*mov from cr*/
		switch (cr) {
		case 3:
3787 3788 3789
			val = kvm_read_cr3(vcpu);
			kvm_register_write(vcpu, reg, val);
			trace_kvm_cr_read(cr, val);
A
Avi Kivity 已提交
3790 3791 3792
			skip_emulated_instruction(vcpu);
			return 1;
		case 8:
3793 3794 3795
			val = kvm_get_cr8(vcpu);
			kvm_register_write(vcpu, reg, val);
			trace_kvm_cr_read(cr, val);
A
Avi Kivity 已提交
3796 3797 3798 3799 3800
			skip_emulated_instruction(vcpu);
			return 1;
		}
		break;
	case 3: /* lmsw */
3801
		val = (exit_qualification >> LMSW_SOURCE_DATA_SHIFT) & 0x0f;
3802
		trace_kvm_cr_write(0, (kvm_read_cr0(vcpu) & ~0xful) | val);
3803
		kvm_lmsw(vcpu, val);
A
Avi Kivity 已提交
3804 3805 3806 3807 3808 3809

		skip_emulated_instruction(vcpu);
		return 1;
	default:
		break;
	}
A
Avi Kivity 已提交
3810
	vcpu->run->exit_reason = 0;
3811
	pr_unimpl(vcpu, "unhandled control register: op %d cr %d\n",
A
Avi Kivity 已提交
3812 3813 3814 3815
	       (int)(exit_qualification >> 4) & 3, cr);
	return 0;
}

A
Avi Kivity 已提交
3816
static int handle_dr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3817
{
3818
	unsigned long exit_qualification;
A
Avi Kivity 已提交
3819 3820
	int dr, reg;

3821
	/* Do not handle if the CPL > 0, will trigger GP on re-entry */
3822 3823
	if (!kvm_require_cpl(vcpu, 0))
		return 1;
3824 3825 3826 3827 3828 3829 3830 3831
	dr = vmcs_readl(GUEST_DR7);
	if (dr & DR7_GD) {
		/*
		 * As the vm-exit takes precedence over the debug trap, we
		 * need to emulate the latter, either for the host or the
		 * guest debugging itself.
		 */
		if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) {
A
Avi Kivity 已提交
3832 3833 3834
			vcpu->run->debug.arch.dr6 = vcpu->arch.dr6;
			vcpu->run->debug.arch.dr7 = dr;
			vcpu->run->debug.arch.pc =
3835 3836
				vmcs_readl(GUEST_CS_BASE) +
				vmcs_readl(GUEST_RIP);
A
Avi Kivity 已提交
3837 3838
			vcpu->run->debug.arch.exception = DB_VECTOR;
			vcpu->run->exit_reason = KVM_EXIT_DEBUG;
3839 3840 3841 3842 3843 3844 3845 3846 3847 3848
			return 0;
		} else {
			vcpu->arch.dr7 &= ~DR7_GD;
			vcpu->arch.dr6 |= DR6_BD;
			vmcs_writel(GUEST_DR7, vcpu->arch.dr7);
			kvm_queue_exception(vcpu, DB_VECTOR);
			return 1;
		}
	}

3849
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
3850 3851 3852
	dr = exit_qualification & DEBUG_REG_ACCESS_NUM;
	reg = DEBUG_REG_ACCESS_REG(exit_qualification);
	if (exit_qualification & TYPE_MOV_FROM_DR) {
3853 3854 3855 3856 3857
		unsigned long val;
		if (!kvm_get_dr(vcpu, dr, &val))
			kvm_register_write(vcpu, reg, val);
	} else
		kvm_set_dr(vcpu, dr, vcpu->arch.regs[reg]);
A
Avi Kivity 已提交
3858 3859 3860 3861
	skip_emulated_instruction(vcpu);
	return 1;
}

3862 3863 3864 3865 3866
static void vmx_set_dr7(struct kvm_vcpu *vcpu, unsigned long val)
{
	vmcs_writel(GUEST_DR7, val);
}

A
Avi Kivity 已提交
3867
static int handle_cpuid(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3868
{
3869 3870
	kvm_emulate_cpuid(vcpu);
	return 1;
A
Avi Kivity 已提交
3871 3872
}

A
Avi Kivity 已提交
3873
static int handle_rdmsr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3874
{
3875
	u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX];
A
Avi Kivity 已提交
3876 3877 3878
	u64 data;

	if (vmx_get_msr(vcpu, ecx, &data)) {
3879
		trace_kvm_msr_read_ex(ecx);
3880
		kvm_inject_gp(vcpu, 0);
A
Avi Kivity 已提交
3881 3882 3883
		return 1;
	}

3884
	trace_kvm_msr_read(ecx, data);
F
Feng (Eric) Liu 已提交
3885

A
Avi Kivity 已提交
3886
	/* FIXME: handling of bits 32:63 of rax, rdx */
3887 3888
	vcpu->arch.regs[VCPU_REGS_RAX] = data & -1u;
	vcpu->arch.regs[VCPU_REGS_RDX] = (data >> 32) & -1u;
A
Avi Kivity 已提交
3889 3890 3891 3892
	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3893
static int handle_wrmsr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3894
{
3895 3896 3897
	u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX];
	u64 data = (vcpu->arch.regs[VCPU_REGS_RAX] & -1u)
		| ((u64)(vcpu->arch.regs[VCPU_REGS_RDX] & -1u) << 32);
A
Avi Kivity 已提交
3898 3899

	if (vmx_set_msr(vcpu, ecx, data) != 0) {
3900
		trace_kvm_msr_write_ex(ecx, data);
3901
		kvm_inject_gp(vcpu, 0);
A
Avi Kivity 已提交
3902 3903 3904
		return 1;
	}

3905
	trace_kvm_msr_write(ecx, data);
A
Avi Kivity 已提交
3906 3907 3908 3909
	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3910
static int handle_tpr_below_threshold(struct kvm_vcpu *vcpu)
3911
{
3912
	kvm_make_request(KVM_REQ_EVENT, vcpu);
3913 3914 3915
	return 1;
}

A
Avi Kivity 已提交
3916
static int handle_interrupt_window(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3917
{
3918 3919 3920 3921 3922 3923
	u32 cpu_based_vm_exec_control;

	/* clear pending irq */
	cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL);
	cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING;
	vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control);
F
Feng (Eric) Liu 已提交
3924

3925 3926
	kvm_make_request(KVM_REQ_EVENT, vcpu);

3927
	++vcpu->stat.irq_window_exits;
F
Feng (Eric) Liu 已提交
3928

3929 3930 3931 3932
	/*
	 * If the user space waits to inject interrupts, exit as soon as
	 * possible
	 */
3933
	if (!irqchip_in_kernel(vcpu->kvm) &&
A
Avi Kivity 已提交
3934
	    vcpu->run->request_interrupt_window &&
3935
	    !kvm_cpu_has_interrupt(vcpu)) {
A
Avi Kivity 已提交
3936
		vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
3937 3938
		return 0;
	}
A
Avi Kivity 已提交
3939 3940 3941
	return 1;
}

A
Avi Kivity 已提交
3942
static int handle_halt(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3943 3944
{
	skip_emulated_instruction(vcpu);
3945
	return kvm_emulate_halt(vcpu);
A
Avi Kivity 已提交
3946 3947
}

A
Avi Kivity 已提交
3948
static int handle_vmcall(struct kvm_vcpu *vcpu)
3949
{
3950
	skip_emulated_instruction(vcpu);
3951 3952
	kvm_emulate_hypercall(vcpu);
	return 1;
3953 3954
}

A
Avi Kivity 已提交
3955
static int handle_vmx_insn(struct kvm_vcpu *vcpu)
3956 3957 3958 3959 3960
{
	kvm_queue_exception(vcpu, UD_VECTOR);
	return 1;
}

3961 3962
static int handle_invd(struct kvm_vcpu *vcpu)
{
3963
	return emulate_instruction(vcpu, 0) == EMULATE_DONE;
3964 3965
}

A
Avi Kivity 已提交
3966
static int handle_invlpg(struct kvm_vcpu *vcpu)
M
Marcelo Tosatti 已提交
3967
{
3968
	unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
M
Marcelo Tosatti 已提交
3969 3970 3971 3972 3973 3974

	kvm_mmu_invlpg(vcpu, exit_qualification);
	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3975
static int handle_wbinvd(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
3976 3977
{
	skip_emulated_instruction(vcpu);
3978
	kvm_emulate_wbinvd(vcpu);
E
Eddie Dong 已提交
3979 3980 3981
	return 1;
}

3982 3983 3984 3985 3986 3987 3988 3989 3990 3991
static int handle_xsetbv(struct kvm_vcpu *vcpu)
{
	u64 new_bv = kvm_read_edx_eax(vcpu);
	u32 index = kvm_register_read(vcpu, VCPU_REGS_RCX);

	if (kvm_set_xcr(vcpu, index, new_bv) == 0)
		skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3992
static int handle_apic_access(struct kvm_vcpu *vcpu)
3993
{
3994
	return emulate_instruction(vcpu, 0) == EMULATE_DONE;
3995 3996
}

A
Avi Kivity 已提交
3997
static int handle_task_switch(struct kvm_vcpu *vcpu)
3998
{
J
Jan Kiszka 已提交
3999
	struct vcpu_vmx *vmx = to_vmx(vcpu);
4000
	unsigned long exit_qualification;
4001 4002
	bool has_error_code = false;
	u32 error_code = 0;
4003
	u16 tss_selector;
4004 4005 4006 4007
	int reason, type, idt_v;

	idt_v = (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK);
	type = (vmx->idt_vectoring_info & VECTORING_INFO_TYPE_MASK);
4008 4009 4010 4011

	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);

	reason = (u32)exit_qualification >> 30;
4012 4013 4014 4015
	if (reason == TASK_SWITCH_GATE && idt_v) {
		switch (type) {
		case INTR_TYPE_NMI_INTR:
			vcpu->arch.nmi_injected = false;
4016
			vmx_set_nmi_mask(vcpu, true);
4017 4018
			break;
		case INTR_TYPE_EXT_INTR:
4019
		case INTR_TYPE_SOFT_INTR:
4020 4021 4022
			kvm_clear_interrupt_queue(vcpu);
			break;
		case INTR_TYPE_HARD_EXCEPTION:
4023 4024 4025 4026 4027 4028 4029
			if (vmx->idt_vectoring_info &
			    VECTORING_INFO_DELIVER_CODE_MASK) {
				has_error_code = true;
				error_code =
					vmcs_read32(IDT_VECTORING_ERROR_CODE);
			}
			/* fall through */
4030 4031 4032 4033 4034 4035
		case INTR_TYPE_SOFT_EXCEPTION:
			kvm_clear_exception_queue(vcpu);
			break;
		default:
			break;
		}
J
Jan Kiszka 已提交
4036
	}
4037 4038
	tss_selector = exit_qualification;

4039 4040 4041 4042 4043
	if (!idt_v || (type != INTR_TYPE_HARD_EXCEPTION &&
		       type != INTR_TYPE_EXT_INTR &&
		       type != INTR_TYPE_NMI_INTR))
		skip_emulated_instruction(vcpu);

4044 4045 4046 4047 4048
	if (kvm_task_switch(vcpu, tss_selector, reason,
				has_error_code, error_code) == EMULATE_FAIL) {
		vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
		vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION;
		vcpu->run->internal.ndata = 0;
4049
		return 0;
4050
	}
4051 4052 4053 4054 4055 4056 4057 4058 4059 4060

	/* clear all local breakpoint enable flags */
	vmcs_writel(GUEST_DR7, vmcs_readl(GUEST_DR7) & ~55);

	/*
	 * TODO: What about debug traps on tss switch?
	 *       Are we supposed to inject them and update dr6?
	 */

	return 1;
4061 4062
}

A
Avi Kivity 已提交
4063
static int handle_ept_violation(struct kvm_vcpu *vcpu)
4064
{
4065
	unsigned long exit_qualification;
4066 4067 4068
	gpa_t gpa;
	int gla_validity;

4069
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
4070 4071 4072

	if (exit_qualification & (1 << 6)) {
		printk(KERN_ERR "EPT: GPA exceeds GAW!\n");
4073
		return -EINVAL;
4074 4075 4076 4077 4078 4079 4080
	}

	gla_validity = (exit_qualification >> 7) & 0x3;
	if (gla_validity != 0x3 && gla_validity != 0x1 && gla_validity != 0) {
		printk(KERN_ERR "EPT: Handling EPT violation failed!\n");
		printk(KERN_ERR "EPT: GPA: 0x%lx, GVA: 0x%lx\n",
			(long unsigned int)vmcs_read64(GUEST_PHYSICAL_ADDRESS),
4081
			vmcs_readl(GUEST_LINEAR_ADDRESS));
4082 4083
		printk(KERN_ERR "EPT: Exit qualification is 0x%lx\n",
			(long unsigned int)exit_qualification);
A
Avi Kivity 已提交
4084 4085
		vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
		vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_VIOLATION;
4086
		return 0;
4087 4088 4089
	}

	gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS);
4090
	trace_kvm_page_fault(gpa, exit_qualification);
4091
	return kvm_mmu_page_fault(vcpu, gpa, exit_qualification & 0x3, NULL, 0);
4092 4093
}

4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154
static u64 ept_rsvd_mask(u64 spte, int level)
{
	int i;
	u64 mask = 0;

	for (i = 51; i > boot_cpu_data.x86_phys_bits; i--)
		mask |= (1ULL << i);

	if (level > 2)
		/* bits 7:3 reserved */
		mask |= 0xf8;
	else if (level == 2) {
		if (spte & (1ULL << 7))
			/* 2MB ref, bits 20:12 reserved */
			mask |= 0x1ff000;
		else
			/* bits 6:3 reserved */
			mask |= 0x78;
	}

	return mask;
}

static void ept_misconfig_inspect_spte(struct kvm_vcpu *vcpu, u64 spte,
				       int level)
{
	printk(KERN_ERR "%s: spte 0x%llx level %d\n", __func__, spte, level);

	/* 010b (write-only) */
	WARN_ON((spte & 0x7) == 0x2);

	/* 110b (write/execute) */
	WARN_ON((spte & 0x7) == 0x6);

	/* 100b (execute-only) and value not supported by logical processor */
	if (!cpu_has_vmx_ept_execute_only())
		WARN_ON((spte & 0x7) == 0x4);

	/* not 000b */
	if ((spte & 0x7)) {
		u64 rsvd_bits = spte & ept_rsvd_mask(spte, level);

		if (rsvd_bits != 0) {
			printk(KERN_ERR "%s: rsvd_bits = 0x%llx\n",
					 __func__, rsvd_bits);
			WARN_ON(1);
		}

		if (level == 1 || (level == 2 && (spte & (1ULL << 7)))) {
			u64 ept_mem_type = (spte & 0x38) >> 3;

			if (ept_mem_type == 2 || ept_mem_type == 3 ||
			    ept_mem_type == 7) {
				printk(KERN_ERR "%s: ept_mem_type=0x%llx\n",
						__func__, ept_mem_type);
				WARN_ON(1);
			}
		}
	}
}

A
Avi Kivity 已提交
4155
static int handle_ept_misconfig(struct kvm_vcpu *vcpu)
4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170
{
	u64 sptes[4];
	int nr_sptes, i;
	gpa_t gpa;

	gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS);

	printk(KERN_ERR "EPT: Misconfiguration.\n");
	printk(KERN_ERR "EPT: GPA: 0x%llx\n", gpa);

	nr_sptes = kvm_mmu_get_spte_hierarchy(vcpu, gpa, sptes);

	for (i = PT64_ROOT_LEVEL; i > PT64_ROOT_LEVEL - nr_sptes; --i)
		ept_misconfig_inspect_spte(vcpu, sptes[i-1], i);

A
Avi Kivity 已提交
4171 4172
	vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
	vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_MISCONFIG;
4173 4174 4175 4176

	return 0;
}

A
Avi Kivity 已提交
4177
static int handle_nmi_window(struct kvm_vcpu *vcpu)
4178 4179 4180 4181 4182 4183 4184 4185
{
	u32 cpu_based_vm_exec_control;

	/* clear pending NMI */
	cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL);
	cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_NMI_PENDING;
	vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control);
	++vcpu->stat.nmi_window_exits;
4186
	kvm_make_request(KVM_REQ_EVENT, vcpu);
4187 4188 4189 4190

	return 1;
}

4191
static int handle_invalid_guest_state(struct kvm_vcpu *vcpu)
4192
{
4193 4194
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	enum emulation_result err = EMULATE_DONE;
4195
	int ret = 1;
4196 4197 4198 4199 4200
	u32 cpu_exec_ctrl;
	bool intr_window_requested;

	cpu_exec_ctrl = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL);
	intr_window_requested = cpu_exec_ctrl & CPU_BASED_VIRTUAL_INTR_PENDING;
4201 4202

	while (!guest_state_valid(vcpu)) {
4203 4204 4205 4206
		if (intr_window_requested
		    && (kvm_get_rflags(&vmx->vcpu) & X86_EFLAGS_IF))
			return handle_interrupt_window(&vmx->vcpu);

4207
		err = emulate_instruction(vcpu, 0);
4208

4209 4210 4211 4212
		if (err == EMULATE_DO_MMIO) {
			ret = 0;
			goto out;
		}
4213

4214 4215
		if (err != EMULATE_DONE)
			return 0;
4216 4217

		if (signal_pending(current))
4218
			goto out;
4219 4220 4221 4222
		if (need_resched())
			schedule();
	}

4223 4224 4225
	vmx->emulation_required = 0;
out:
	return ret;
4226 4227
}

4228 4229 4230 4231
/*
 * Indicate a busy-waiting vcpu in spinlock. We do not enable the PAUSE
 * exiting, so only get here on cpu with PAUSE-Loop-Exiting.
 */
4232
static int handle_pause(struct kvm_vcpu *vcpu)
4233 4234 4235 4236 4237 4238 4239
{
	skip_emulated_instruction(vcpu);
	kvm_vcpu_on_spin(vcpu);

	return 1;
}

4240 4241 4242 4243 4244 4245
static int handle_invalid_op(struct kvm_vcpu *vcpu)
{
	kvm_queue_exception(vcpu, UD_VECTOR);
	return 1;
}

4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326
/*
 * Emulate the VMXON instruction.
 * Currently, we just remember that VMX is active, and do not save or even
 * inspect the argument to VMXON (the so-called "VMXON pointer") because we
 * do not currently need to store anything in that guest-allocated memory
 * region. Consequently, VMCLEAR and VMPTRLD also do not verify that the their
 * argument is different from the VMXON pointer (which the spec says they do).
 */
static int handle_vmon(struct kvm_vcpu *vcpu)
{
	struct kvm_segment cs;
	struct vcpu_vmx *vmx = to_vmx(vcpu);

	/* The Intel VMX Instruction Reference lists a bunch of bits that
	 * are prerequisite to running VMXON, most notably cr4.VMXE must be
	 * set to 1 (see vmx_set_cr4() for when we allow the guest to set this).
	 * Otherwise, we should fail with #UD. We test these now:
	 */
	if (!kvm_read_cr4_bits(vcpu, X86_CR4_VMXE) ||
	    !kvm_read_cr0_bits(vcpu, X86_CR0_PE) ||
	    (vmx_get_rflags(vcpu) & X86_EFLAGS_VM)) {
		kvm_queue_exception(vcpu, UD_VECTOR);
		return 1;
	}

	vmx_get_segment(vcpu, &cs, VCPU_SREG_CS);
	if (is_long_mode(vcpu) && !cs.l) {
		kvm_queue_exception(vcpu, UD_VECTOR);
		return 1;
	}

	if (vmx_get_cpl(vcpu)) {
		kvm_inject_gp(vcpu, 0);
		return 1;
	}

	vmx->nested.vmxon = true;

	skip_emulated_instruction(vcpu);
	return 1;
}

/*
 * Intel's VMX Instruction Reference specifies a common set of prerequisites
 * for running VMX instructions (except VMXON, whose prerequisites are
 * slightly different). It also specifies what exception to inject otherwise.
 */
static int nested_vmx_check_permission(struct kvm_vcpu *vcpu)
{
	struct kvm_segment cs;
	struct vcpu_vmx *vmx = to_vmx(vcpu);

	if (!vmx->nested.vmxon) {
		kvm_queue_exception(vcpu, UD_VECTOR);
		return 0;
	}

	vmx_get_segment(vcpu, &cs, VCPU_SREG_CS);
	if ((vmx_get_rflags(vcpu) & X86_EFLAGS_VM) ||
	    (is_long_mode(vcpu) && !cs.l)) {
		kvm_queue_exception(vcpu, UD_VECTOR);
		return 0;
	}

	if (vmx_get_cpl(vcpu)) {
		kvm_inject_gp(vcpu, 0);
		return 0;
	}

	return 1;
}

/*
 * Free whatever needs to be freed from vmx->nested when L1 goes down, or
 * just stops using VMX.
 */
static void free_nested(struct vcpu_vmx *vmx)
{
	if (!vmx->nested.vmxon)
		return;
	vmx->nested.vmxon = false;
4327 4328 4329 4330 4331 4332
	if (vmx->nested.current_vmptr != -1ull) {
		kunmap(vmx->nested.current_vmcs12_page);
		nested_release_page(vmx->nested.current_vmcs12_page);
		vmx->nested.current_vmptr = -1ull;
		vmx->nested.current_vmcs12 = NULL;
	}
4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344
}

/* Emulate the VMXOFF instruction */
static int handle_vmoff(struct kvm_vcpu *vcpu)
{
	if (!nested_vmx_check_permission(vcpu))
		return 1;
	free_nested(to_vmx(vcpu));
	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
4345 4346 4347 4348 4349
/*
 * The exit handlers return 1 if the exit was handled fully and guest execution
 * may resume.  Otherwise they set the kvm_run parameter to indicate what needs
 * to be done to userspace and return 0.
 */
A
Avi Kivity 已提交
4350
static int (*kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu) = {
A
Avi Kivity 已提交
4351 4352
	[EXIT_REASON_EXCEPTION_NMI]           = handle_exception,
	[EXIT_REASON_EXTERNAL_INTERRUPT]      = handle_external_interrupt,
4353
	[EXIT_REASON_TRIPLE_FAULT]            = handle_triple_fault,
4354
	[EXIT_REASON_NMI_WINDOW]	      = handle_nmi_window,
A
Avi Kivity 已提交
4355 4356 4357 4358 4359 4360 4361 4362
	[EXIT_REASON_IO_INSTRUCTION]          = handle_io,
	[EXIT_REASON_CR_ACCESS]               = handle_cr,
	[EXIT_REASON_DR_ACCESS]               = handle_dr,
	[EXIT_REASON_CPUID]                   = handle_cpuid,
	[EXIT_REASON_MSR_READ]                = handle_rdmsr,
	[EXIT_REASON_MSR_WRITE]               = handle_wrmsr,
	[EXIT_REASON_PENDING_INTERRUPT]       = handle_interrupt_window,
	[EXIT_REASON_HLT]                     = handle_halt,
4363
	[EXIT_REASON_INVD]		      = handle_invd,
M
Marcelo Tosatti 已提交
4364
	[EXIT_REASON_INVLPG]		      = handle_invlpg,
4365
	[EXIT_REASON_VMCALL]                  = handle_vmcall,
4366 4367 4368 4369 4370 4371 4372
	[EXIT_REASON_VMCLEAR]	              = handle_vmx_insn,
	[EXIT_REASON_VMLAUNCH]                = handle_vmx_insn,
	[EXIT_REASON_VMPTRLD]                 = handle_vmx_insn,
	[EXIT_REASON_VMPTRST]                 = handle_vmx_insn,
	[EXIT_REASON_VMREAD]                  = handle_vmx_insn,
	[EXIT_REASON_VMRESUME]                = handle_vmx_insn,
	[EXIT_REASON_VMWRITE]                 = handle_vmx_insn,
4373 4374
	[EXIT_REASON_VMOFF]                   = handle_vmoff,
	[EXIT_REASON_VMON]                    = handle_vmon,
4375 4376
	[EXIT_REASON_TPR_BELOW_THRESHOLD]     = handle_tpr_below_threshold,
	[EXIT_REASON_APIC_ACCESS]             = handle_apic_access,
E
Eddie Dong 已提交
4377
	[EXIT_REASON_WBINVD]                  = handle_wbinvd,
4378
	[EXIT_REASON_XSETBV]                  = handle_xsetbv,
4379
	[EXIT_REASON_TASK_SWITCH]             = handle_task_switch,
A
Andi Kleen 已提交
4380
	[EXIT_REASON_MCE_DURING_VMENTRY]      = handle_machine_check,
4381 4382
	[EXIT_REASON_EPT_VIOLATION]	      = handle_ept_violation,
	[EXIT_REASON_EPT_MISCONFIG]           = handle_ept_misconfig,
4383
	[EXIT_REASON_PAUSE_INSTRUCTION]       = handle_pause,
4384 4385
	[EXIT_REASON_MWAIT_INSTRUCTION]	      = handle_invalid_op,
	[EXIT_REASON_MONITOR_INSTRUCTION]     = handle_invalid_op,
A
Avi Kivity 已提交
4386 4387 4388
};

static const int kvm_vmx_max_exit_handlers =
4389
	ARRAY_SIZE(kvm_vmx_exit_handlers);
A
Avi Kivity 已提交
4390

4391 4392 4393 4394 4395 4396
static void vmx_get_exit_info(struct kvm_vcpu *vcpu, u64 *info1, u64 *info2)
{
	*info1 = vmcs_readl(EXIT_QUALIFICATION);
	*info2 = vmcs_read32(VM_EXIT_INTR_INFO);
}

A
Avi Kivity 已提交
4397 4398 4399 4400
/*
 * The guest has exited.  See if we can fix it or if we need userspace
 * assistance.
 */
A
Avi Kivity 已提交
4401
static int vmx_handle_exit(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
4402
{
4403
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Andi Kleen 已提交
4404
	u32 exit_reason = vmx->exit_reason;
4405
	u32 vectoring_info = vmx->idt_vectoring_info;
4406

4407
	trace_kvm_exit(exit_reason, vcpu, KVM_ISA_VMX);
F
Feng (Eric) Liu 已提交
4408

4409 4410 4411
	/* If guest state is invalid, start emulating */
	if (vmx->emulation_required && emulate_invalid_guest_state)
		return handle_invalid_guest_state(vcpu);
4412

4413 4414 4415 4416 4417 4418 4419
	if (exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY) {
		vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;
		vcpu->run->fail_entry.hardware_entry_failure_reason
			= exit_reason;
		return 0;
	}

4420
	if (unlikely(vmx->fail)) {
A
Avi Kivity 已提交
4421 4422
		vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;
		vcpu->run->fail_entry.hardware_entry_failure_reason
4423 4424 4425
			= vmcs_read32(VM_INSTRUCTION_ERROR);
		return 0;
	}
A
Avi Kivity 已提交
4426

M
Mike Day 已提交
4427
	if ((vectoring_info & VECTORING_INFO_VALID_MASK) &&
4428
			(exit_reason != EXIT_REASON_EXCEPTION_NMI &&
J
Jan Kiszka 已提交
4429 4430 4431 4432 4433
			exit_reason != EXIT_REASON_EPT_VIOLATION &&
			exit_reason != EXIT_REASON_TASK_SWITCH))
		printk(KERN_WARNING "%s: unexpected, valid vectoring info "
		       "(0x%x) and exit reason is 0x%x\n",
		       __func__, vectoring_info, exit_reason);
4434 4435

	if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked)) {
4436
		if (vmx_interrupt_allowed(vcpu)) {
4437 4438
			vmx->soft_vnmi_blocked = 0;
		} else if (vmx->vnmi_blocked_time > 1000000000LL &&
4439
			   vcpu->arch.nmi_pending) {
4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452
			/*
			 * This CPU don't support us in finding the end of an
			 * NMI-blocked window if the guest runs with IRQs
			 * disabled. So we pull the trigger after 1 s of
			 * futile waiting, but inform the user about this.
			 */
			printk(KERN_WARNING "%s: Breaking out of NMI-blocked "
			       "state on VCPU %d after 1 s timeout\n",
			       __func__, vcpu->vcpu_id);
			vmx->soft_vnmi_blocked = 0;
		}
	}

A
Avi Kivity 已提交
4453 4454
	if (exit_reason < kvm_vmx_max_exit_handlers
	    && kvm_vmx_exit_handlers[exit_reason])
A
Avi Kivity 已提交
4455
		return kvm_vmx_exit_handlers[exit_reason](vcpu);
A
Avi Kivity 已提交
4456
	else {
A
Avi Kivity 已提交
4457 4458
		vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
		vcpu->run->hw.hardware_exit_reason = exit_reason;
A
Avi Kivity 已提交
4459 4460 4461 4462
	}
	return 0;
}

4463
static void update_cr8_intercept(struct kvm_vcpu *vcpu, int tpr, int irr)
4464
{
4465
	if (irr == -1 || tpr < irr) {
4466 4467 4468 4469
		vmcs_write32(TPR_THRESHOLD, 0);
		return;
	}

4470
	vmcs_write32(TPR_THRESHOLD, irr);
4471 4472
}

4473
static void vmx_complete_atomic_exit(struct vcpu_vmx *vmx)
4474
{
4475 4476 4477 4478 4479 4480
	u32 exit_intr_info;

	if (!(vmx->exit_reason == EXIT_REASON_MCE_DURING_VMENTRY
	      || vmx->exit_reason == EXIT_REASON_EXCEPTION_NMI))
		return;

4481
	vmx->exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO);
4482
	exit_intr_info = vmx->exit_intr_info;
A
Andi Kleen 已提交
4483 4484

	/* Handle machine checks before interrupts are enabled */
4485
	if (is_machine_check(exit_intr_info))
A
Andi Kleen 已提交
4486 4487
		kvm_machine_check();

4488
	/* We need to handle NMIs before interrupts are enabled */
4489
	if ((exit_intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR &&
4490 4491
	    (exit_intr_info & INTR_INFO_VALID_MASK)) {
		kvm_before_handle_nmi(&vmx->vcpu);
4492
		asm("int $2");
4493 4494
		kvm_after_handle_nmi(&vmx->vcpu);
	}
4495
}
4496

4497 4498
static void vmx_recover_nmi_blocking(struct vcpu_vmx *vmx)
{
4499
	u32 exit_intr_info;
4500 4501 4502 4503 4504
	bool unblock_nmi;
	u8 vector;
	bool idtv_info_valid;

	idtv_info_valid = vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK;
4505

4506
	if (cpu_has_virtual_nmis()) {
4507 4508
		if (vmx->nmi_known_unmasked)
			return;
4509 4510 4511 4512 4513
		/*
		 * Can't use vmx->exit_intr_info since we're not sure what
		 * the exit reason is.
		 */
		exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO);
4514 4515 4516
		unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0;
		vector = exit_intr_info & INTR_INFO_VECTOR_MASK;
		/*
4517
		 * SDM 3: 27.7.1.2 (September 2008)
4518 4519
		 * Re-set bit "block by NMI" before VM entry if vmexit caused by
		 * a guest IRET fault.
4520 4521 4522 4523 4524
		 * SDM 3: 23.2.2 (September 2008)
		 * Bit 12 is undefined in any of the following cases:
		 *  If the VM exit sets the valid bit in the IDT-vectoring
		 *   information field.
		 *  If the VM exit is due to a double fault.
4525
		 */
4526 4527
		if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi &&
		    vector != DF_VECTOR && !idtv_info_valid)
4528 4529
			vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
				      GUEST_INTR_STATE_NMI);
4530 4531 4532 4533
		else
			vmx->nmi_known_unmasked =
				!(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO)
				  & GUEST_INTR_STATE_NMI);
4534 4535 4536
	} else if (unlikely(vmx->soft_vnmi_blocked))
		vmx->vnmi_blocked_time +=
			ktime_to_ns(ktime_sub(ktime_get(), vmx->entry_time));
4537 4538
}

4539 4540 4541 4542
static void __vmx_complete_interrupts(struct vcpu_vmx *vmx,
				      u32 idt_vectoring_info,
				      int instr_len_field,
				      int error_code_field)
4543 4544 4545 4546 4547 4548
{
	u8 vector;
	int type;
	bool idtv_info_valid;

	idtv_info_valid = idt_vectoring_info & VECTORING_INFO_VALID_MASK;
4549

4550 4551 4552 4553 4554 4555 4556
	vmx->vcpu.arch.nmi_injected = false;
	kvm_clear_exception_queue(&vmx->vcpu);
	kvm_clear_interrupt_queue(&vmx->vcpu);

	if (!idtv_info_valid)
		return;

4557 4558
	kvm_make_request(KVM_REQ_EVENT, &vmx->vcpu);

4559 4560
	vector = idt_vectoring_info & VECTORING_INFO_VECTOR_MASK;
	type = idt_vectoring_info & VECTORING_INFO_TYPE_MASK;
4561

4562
	switch (type) {
4563 4564
	case INTR_TYPE_NMI_INTR:
		vmx->vcpu.arch.nmi_injected = true;
4565
		/*
4566
		 * SDM 3: 27.7.1.2 (September 2008)
4567 4568
		 * Clear bit "block by NMI" before VM entry if a NMI
		 * delivery faulted.
4569
		 */
4570
		vmx_set_nmi_mask(&vmx->vcpu, false);
4571 4572
		break;
	case INTR_TYPE_SOFT_EXCEPTION:
4573
		vmx->vcpu.arch.event_exit_inst_len =
4574
			vmcs_read32(instr_len_field);
4575 4576
		/* fall through */
	case INTR_TYPE_HARD_EXCEPTION:
4577
		if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) {
4578
			u32 err = vmcs_read32(error_code_field);
4579
			kvm_queue_exception_e(&vmx->vcpu, vector, err);
4580 4581
		} else
			kvm_queue_exception(&vmx->vcpu, vector);
4582
		break;
4583 4584
	case INTR_TYPE_SOFT_INTR:
		vmx->vcpu.arch.event_exit_inst_len =
4585
			vmcs_read32(instr_len_field);
4586
		/* fall through */
4587
	case INTR_TYPE_EXT_INTR:
4588 4589
		kvm_queue_interrupt(&vmx->vcpu, vector,
			type == INTR_TYPE_SOFT_INTR);
4590 4591 4592
		break;
	default:
		break;
4593
	}
4594 4595
}

4596 4597 4598 4599 4600 4601 4602
static void vmx_complete_interrupts(struct vcpu_vmx *vmx)
{
	__vmx_complete_interrupts(vmx, vmx->idt_vectoring_info,
				  VM_EXIT_INSTRUCTION_LEN,
				  IDT_VECTORING_ERROR_CODE);
}

A
Avi Kivity 已提交
4603 4604 4605 4606 4607 4608 4609 4610 4611 4612
static void vmx_cancel_injection(struct kvm_vcpu *vcpu)
{
	__vmx_complete_interrupts(to_vmx(vcpu),
				  vmcs_read32(VM_ENTRY_INTR_INFO_FIELD),
				  VM_ENTRY_INSTRUCTION_LEN,
				  VM_ENTRY_EXCEPTION_ERROR_CODE);

	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0);
}

4613 4614 4615 4616 4617 4618 4619 4620
#ifdef CONFIG_X86_64
#define R "r"
#define Q "q"
#else
#define R "e"
#define Q "l"
#endif

4621
static void __noclone vmx_vcpu_run(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
4622
{
4623
	struct vcpu_vmx *vmx = to_vmx(vcpu);
4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646

	/* Record the guest's net vcpu time for enforced NMI injections. */
	if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked))
		vmx->entry_time = ktime_get();

	/* Don't enter VMX if guest state is invalid, let the exit handler
	   start emulation until we arrive back to a valid state */
	if (vmx->emulation_required && emulate_invalid_guest_state)
		return;

	if (test_bit(VCPU_REGS_RSP, (unsigned long *)&vcpu->arch.regs_dirty))
		vmcs_writel(GUEST_RSP, vcpu->arch.regs[VCPU_REGS_RSP]);
	if (test_bit(VCPU_REGS_RIP, (unsigned long *)&vcpu->arch.regs_dirty))
		vmcs_writel(GUEST_RIP, vcpu->arch.regs[VCPU_REGS_RIP]);

	/* When single-stepping over STI and MOV SS, we must clear the
	 * corresponding interruptibility bits in the guest state. Otherwise
	 * vmentry fails as it then expects bit 14 (BS) in pending debug
	 * exceptions being set, but that's not correct for the guest debugging
	 * case. */
	if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)
		vmx_set_interrupt_shadow(vcpu, 0);

4647
	vmx->__launched = vmx->loaded_vmcs->launched;
4648
	asm(
A
Avi Kivity 已提交
4649
		/* Store host registers */
4650
		"push %%"R"dx; push %%"R"bp;"
4651
		"push %%"R"cx \n\t" /* placeholder for guest rcx */
4652
		"push %%"R"cx \n\t"
4653 4654 4655
		"cmp %%"R"sp, %c[host_rsp](%0) \n\t"
		"je 1f \n\t"
		"mov %%"R"sp, %c[host_rsp](%0) \n\t"
4656
		__ex(ASM_VMX_VMWRITE_RSP_RDX) "\n\t"
4657
		"1: \n\t"
4658 4659 4660 4661 4662 4663 4664
		/* Reload cr2 if changed */
		"mov %c[cr2](%0), %%"R"ax \n\t"
		"mov %%cr2, %%"R"dx \n\t"
		"cmp %%"R"ax, %%"R"dx \n\t"
		"je 2f \n\t"
		"mov %%"R"ax, %%cr2 \n\t"
		"2: \n\t"
A
Avi Kivity 已提交
4665
		/* Check if vmlaunch of vmresume is needed */
4666
		"cmpl $0, %c[launched](%0) \n\t"
A
Avi Kivity 已提交
4667
		/* Load guest registers.  Don't clobber flags. */
4668 4669 4670 4671 4672 4673
		"mov %c[rax](%0), %%"R"ax \n\t"
		"mov %c[rbx](%0), %%"R"bx \n\t"
		"mov %c[rdx](%0), %%"R"dx \n\t"
		"mov %c[rsi](%0), %%"R"si \n\t"
		"mov %c[rdi](%0), %%"R"di \n\t"
		"mov %c[rbp](%0), %%"R"bp \n\t"
4674
#ifdef CONFIG_X86_64
4675 4676 4677 4678 4679 4680 4681 4682
		"mov %c[r8](%0),  %%r8  \n\t"
		"mov %c[r9](%0),  %%r9  \n\t"
		"mov %c[r10](%0), %%r10 \n\t"
		"mov %c[r11](%0), %%r11 \n\t"
		"mov %c[r12](%0), %%r12 \n\t"
		"mov %c[r13](%0), %%r13 \n\t"
		"mov %c[r14](%0), %%r14 \n\t"
		"mov %c[r15](%0), %%r15 \n\t"
A
Avi Kivity 已提交
4683
#endif
4684 4685
		"mov %c[rcx](%0), %%"R"cx \n\t" /* kills %0 (ecx) */

A
Avi Kivity 已提交
4686
		/* Enter guest mode */
4687
		"jne .Llaunched \n\t"
4688
		__ex(ASM_VMX_VMLAUNCH) "\n\t"
4689
		"jmp .Lkvm_vmx_return \n\t"
4690
		".Llaunched: " __ex(ASM_VMX_VMRESUME) "\n\t"
4691
		".Lkvm_vmx_return: "
A
Avi Kivity 已提交
4692
		/* Save guest registers, load host registers, keep flags */
4693 4694
		"mov %0, %c[wordsize](%%"R"sp) \n\t"
		"pop %0 \n\t"
4695 4696
		"mov %%"R"ax, %c[rax](%0) \n\t"
		"mov %%"R"bx, %c[rbx](%0) \n\t"
4697
		"pop"Q" %c[rcx](%0) \n\t"
4698 4699 4700 4701
		"mov %%"R"dx, %c[rdx](%0) \n\t"
		"mov %%"R"si, %c[rsi](%0) \n\t"
		"mov %%"R"di, %c[rdi](%0) \n\t"
		"mov %%"R"bp, %c[rbp](%0) \n\t"
4702
#ifdef CONFIG_X86_64
4703 4704 4705 4706 4707 4708 4709 4710
		"mov %%r8,  %c[r8](%0) \n\t"
		"mov %%r9,  %c[r9](%0) \n\t"
		"mov %%r10, %c[r10](%0) \n\t"
		"mov %%r11, %c[r11](%0) \n\t"
		"mov %%r12, %c[r12](%0) \n\t"
		"mov %%r13, %c[r13](%0) \n\t"
		"mov %%r14, %c[r14](%0) \n\t"
		"mov %%r15, %c[r15](%0) \n\t"
A
Avi Kivity 已提交
4711
#endif
4712 4713 4714
		"mov %%cr2, %%"R"ax   \n\t"
		"mov %%"R"ax, %c[cr2](%0) \n\t"

4715
		"pop  %%"R"bp; pop  %%"R"dx \n\t"
4716 4717
		"setbe %c[fail](%0) \n\t"
	      : : "c"(vmx), "d"((unsigned long)HOST_RSP),
4718
		[launched]"i"(offsetof(struct vcpu_vmx, __launched)),
4719
		[fail]"i"(offsetof(struct vcpu_vmx, fail)),
4720
		[host_rsp]"i"(offsetof(struct vcpu_vmx, host_rsp)),
4721 4722 4723 4724 4725 4726 4727
		[rax]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RAX])),
		[rbx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBX])),
		[rcx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RCX])),
		[rdx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDX])),
		[rsi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RSI])),
		[rdi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDI])),
		[rbp]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBP])),
4728
#ifdef CONFIG_X86_64
4729 4730 4731 4732 4733 4734 4735 4736
		[r8]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R8])),
		[r9]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R9])),
		[r10]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R10])),
		[r11]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R11])),
		[r12]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R12])),
		[r13]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R13])),
		[r14]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R14])),
		[r15]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R15])),
A
Avi Kivity 已提交
4737
#endif
4738 4739
		[cr2]"i"(offsetof(struct vcpu_vmx, vcpu.arch.cr2)),
		[wordsize]"i"(sizeof(ulong))
4740
	      : "cc", "memory"
4741
		, R"ax", R"bx", R"di", R"si"
4742 4743 4744 4745
#ifdef CONFIG_X86_64
		, "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
#endif
	      );
A
Avi Kivity 已提交
4746

A
Avi Kivity 已提交
4747
	vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) | (1 << VCPU_REGS_RSP)
A
Avi Kivity 已提交
4748
				  | (1 << VCPU_EXREG_RFLAGS)
A
Avi Kivity 已提交
4749
				  | (1 << VCPU_EXREG_CPL)
4750
				  | (1 << VCPU_EXREG_PDPTR)
A
Avi Kivity 已提交
4751
				  | (1 << VCPU_EXREG_SEGMENTS)
4752
				  | (1 << VCPU_EXREG_CR3));
4753 4754
	vcpu->arch.regs_dirty = 0;

4755 4756
	vmx->idt_vectoring_info = vmcs_read32(IDT_VECTORING_INFO_FIELD);

M
Mike Day 已提交
4757
	asm("mov %0, %%ds; mov %0, %%es" : : "r"(__USER_DS));
4758
	vmx->loaded_vmcs->launched = 1;
4759

4760 4761 4762 4763
	vmx->exit_reason = vmcs_read32(VM_EXIT_REASON);

	vmx_complete_atomic_exit(vmx);
	vmx_recover_nmi_blocking(vmx);
4764
	vmx_complete_interrupts(vmx);
A
Avi Kivity 已提交
4765 4766
}

4767 4768 4769
#undef R
#undef Q

A
Avi Kivity 已提交
4770 4771
static void vmx_free_vcpu(struct kvm_vcpu *vcpu)
{
R
Rusty Russell 已提交
4772 4773
	struct vcpu_vmx *vmx = to_vmx(vcpu);

4774
	free_vpid(vmx);
4775
	free_nested(vmx);
4776
	free_loaded_vmcs(vmx->loaded_vmcs);
R
Rusty Russell 已提交
4777 4778
	kfree(vmx->guest_msrs);
	kvm_vcpu_uninit(vcpu);
4779
	kmem_cache_free(kvm_vcpu_cache, vmx);
A
Avi Kivity 已提交
4780 4781
}

R
Rusty Russell 已提交
4782
static struct kvm_vcpu *vmx_create_vcpu(struct kvm *kvm, unsigned int id)
A
Avi Kivity 已提交
4783
{
R
Rusty Russell 已提交
4784
	int err;
4785
	struct vcpu_vmx *vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
4786
	int cpu;
A
Avi Kivity 已提交
4787

4788
	if (!vmx)
R
Rusty Russell 已提交
4789 4790
		return ERR_PTR(-ENOMEM);

4791 4792
	allocate_vpid(vmx);

R
Rusty Russell 已提交
4793 4794 4795
	err = kvm_vcpu_init(&vmx->vcpu, kvm, id);
	if (err)
		goto free_vcpu;
4796

4797
	vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
4798
	err = -ENOMEM;
R
Rusty Russell 已提交
4799 4800 4801
	if (!vmx->guest_msrs) {
		goto uninit_vcpu;
	}
4802

4803 4804 4805
	vmx->loaded_vmcs = &vmx->vmcs01;
	vmx->loaded_vmcs->vmcs = alloc_vmcs();
	if (!vmx->loaded_vmcs->vmcs)
R
Rusty Russell 已提交
4806
		goto free_msrs;
4807 4808 4809 4810 4811
	if (!vmm_exclusive)
		kvm_cpu_vmxon(__pa(per_cpu(vmxarea, raw_smp_processor_id())));
	loaded_vmcs_init(vmx->loaded_vmcs);
	if (!vmm_exclusive)
		kvm_cpu_vmxoff();
4812

4813 4814
	cpu = get_cpu();
	vmx_vcpu_load(&vmx->vcpu, cpu);
Z
Zachary Amsden 已提交
4815
	vmx->vcpu.cpu = cpu;
R
Rusty Russell 已提交
4816
	err = vmx_vcpu_setup(vmx);
R
Rusty Russell 已提交
4817
	vmx_vcpu_put(&vmx->vcpu);
4818
	put_cpu();
R
Rusty Russell 已提交
4819 4820
	if (err)
		goto free_vmcs;
4821
	if (vm_need_virtualize_apic_accesses(kvm))
4822 4823
		err = alloc_apic_access_page(kvm);
		if (err)
4824
			goto free_vmcs;
R
Rusty Russell 已提交
4825

4826 4827 4828 4829
	if (enable_ept) {
		if (!kvm->arch.ept_identity_map_addr)
			kvm->arch.ept_identity_map_addr =
				VMX_EPT_IDENTITY_PAGETABLE_ADDR;
4830
		err = -ENOMEM;
4831 4832
		if (alloc_identity_pagetable(kvm) != 0)
			goto free_vmcs;
4833 4834
		if (!init_rmode_identity_map(kvm))
			goto free_vmcs;
4835
	}
4836

4837 4838 4839
	vmx->nested.current_vmptr = -1ull;
	vmx->nested.current_vmcs12 = NULL;

R
Rusty Russell 已提交
4840 4841 4842
	return &vmx->vcpu;

free_vmcs:
4843
	free_vmcs(vmx->loaded_vmcs->vmcs);
R
Rusty Russell 已提交
4844 4845 4846 4847 4848
free_msrs:
	kfree(vmx->guest_msrs);
uninit_vcpu:
	kvm_vcpu_uninit(&vmx->vcpu);
free_vcpu:
4849
	free_vpid(vmx);
4850
	kmem_cache_free(kvm_vcpu_cache, vmx);
R
Rusty Russell 已提交
4851
	return ERR_PTR(err);
A
Avi Kivity 已提交
4852 4853
}

Y
Yang, Sheng 已提交
4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867
static void __init vmx_check_processor_compat(void *rtn)
{
	struct vmcs_config vmcs_conf;

	*(int *)rtn = 0;
	if (setup_vmcs_config(&vmcs_conf) < 0)
		*(int *)rtn = -EIO;
	if (memcmp(&vmcs_config, &vmcs_conf, sizeof(struct vmcs_config)) != 0) {
		printk(KERN_ERR "kvm: CPU %d feature inconsistency!\n",
				smp_processor_id());
		*(int *)rtn = -EIO;
	}
}

4868 4869 4870 4871 4872
static int get_ept_level(void)
{
	return VMX_EPT_DEFAULT_GAW + 1;
}

4873
static u64 vmx_get_mt_mask(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio)
S
Sheng Yang 已提交
4874
{
4875 4876
	u64 ret;

4877 4878 4879 4880 4881 4882 4883 4884
	/* For VT-d and EPT combination
	 * 1. MMIO: always map as UC
	 * 2. EPT with VT-d:
	 *   a. VT-d without snooping control feature: can't guarantee the
	 *	result, try to trust guest.
	 *   b. VT-d with snooping control feature: snooping control feature of
	 *	VT-d engine can guarantee the cache correctness. Just set it
	 *	to WB to keep consistent with host. So the same as item 3.
4885
	 * 3. EPT without VT-d: always map as WB and set IPAT=1 to keep
4886 4887
	 *    consistent with host MTRR
	 */
4888 4889
	if (is_mmio)
		ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT;
4890 4891 4892 4893
	else if (vcpu->kvm->arch.iommu_domain &&
		!(vcpu->kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY))
		ret = kvm_get_guest_memory_type(vcpu, gfn) <<
		      VMX_EPT_MT_EPTE_SHIFT;
4894
	else
4895
		ret = (MTRR_TYPE_WRBACK << VMX_EPT_MT_EPTE_SHIFT)
4896
			| VMX_EPT_IPAT_BIT;
4897 4898

	return ret;
S
Sheng Yang 已提交
4899 4900
}

4901 4902
#define _ER(x) { EXIT_REASON_##x, #x }

4903
static const struct trace_print_flags vmx_exit_reasons_str[] = {
4904 4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938
	_ER(EXCEPTION_NMI),
	_ER(EXTERNAL_INTERRUPT),
	_ER(TRIPLE_FAULT),
	_ER(PENDING_INTERRUPT),
	_ER(NMI_WINDOW),
	_ER(TASK_SWITCH),
	_ER(CPUID),
	_ER(HLT),
	_ER(INVLPG),
	_ER(RDPMC),
	_ER(RDTSC),
	_ER(VMCALL),
	_ER(VMCLEAR),
	_ER(VMLAUNCH),
	_ER(VMPTRLD),
	_ER(VMPTRST),
	_ER(VMREAD),
	_ER(VMRESUME),
	_ER(VMWRITE),
	_ER(VMOFF),
	_ER(VMON),
	_ER(CR_ACCESS),
	_ER(DR_ACCESS),
	_ER(IO_INSTRUCTION),
	_ER(MSR_READ),
	_ER(MSR_WRITE),
	_ER(MWAIT_INSTRUCTION),
	_ER(MONITOR_INSTRUCTION),
	_ER(PAUSE_INSTRUCTION),
	_ER(MCE_DURING_VMENTRY),
	_ER(TPR_BELOW_THRESHOLD),
	_ER(APIC_ACCESS),
	_ER(EPT_VIOLATION),
	_ER(EPT_MISCONFIG),
	_ER(WBINVD),
4939 4940 4941
	{ -1, NULL }
};

4942 4943
#undef _ER

4944
static int vmx_get_lpage_level(void)
4945
{
4946 4947 4948 4949 4950
	if (enable_ept && !cpu_has_vmx_ept_1g_page())
		return PT_DIRECTORY_LEVEL;
	else
		/* For shadow and EPT supported 1GB page */
		return PT_PDPE_LEVEL;
4951 4952
}

4953 4954
static void vmx_cpuid_update(struct kvm_vcpu *vcpu)
{
4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972
	struct kvm_cpuid_entry2 *best;
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	u32 exec_control;

	vmx->rdtscp_enabled = false;
	if (vmx_rdtscp_supported()) {
		exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL);
		if (exec_control & SECONDARY_EXEC_RDTSCP) {
			best = kvm_find_cpuid_entry(vcpu, 0x80000001, 0);
			if (best && (best->edx & bit(X86_FEATURE_RDTSCP)))
				vmx->rdtscp_enabled = true;
			else {
				exec_control &= ~SECONDARY_EXEC_RDTSCP;
				vmcs_write32(SECONDARY_VM_EXEC_CONTROL,
						exec_control);
			}
		}
	}
4973 4974
}

4975 4976 4977 4978
static void vmx_set_supported_cpuid(u32 func, struct kvm_cpuid_entry2 *entry)
{
}

4979 4980 4981 4982 4983 4984 4985
static int vmx_check_intercept(struct kvm_vcpu *vcpu,
			       struct x86_instruction_info *info,
			       enum x86_intercept_stage stage)
{
	return X86EMUL_CONTINUE;
}

4986
static struct kvm_x86_ops vmx_x86_ops = {
A
Avi Kivity 已提交
4987 4988 4989 4990
	.cpu_has_kvm_support = cpu_has_kvm_support,
	.disabled_by_bios = vmx_disabled_by_bios,
	.hardware_setup = hardware_setup,
	.hardware_unsetup = hardware_unsetup,
Y
Yang, Sheng 已提交
4991
	.check_processor_compatibility = vmx_check_processor_compat,
A
Avi Kivity 已提交
4992 4993
	.hardware_enable = hardware_enable,
	.hardware_disable = hardware_disable,
4994
	.cpu_has_accelerated_tpr = report_flexpriority,
A
Avi Kivity 已提交
4995 4996 4997

	.vcpu_create = vmx_create_vcpu,
	.vcpu_free = vmx_free_vcpu,
4998
	.vcpu_reset = vmx_vcpu_reset,
A
Avi Kivity 已提交
4999

5000
	.prepare_guest_switch = vmx_save_host_state,
A
Avi Kivity 已提交
5001 5002 5003 5004 5005 5006 5007 5008 5009
	.vcpu_load = vmx_vcpu_load,
	.vcpu_put = vmx_vcpu_put,

	.set_guest_debug = set_guest_debug,
	.get_msr = vmx_get_msr,
	.set_msr = vmx_set_msr,
	.get_segment_base = vmx_get_segment_base,
	.get_segment = vmx_get_segment,
	.set_segment = vmx_set_segment,
5010
	.get_cpl = vmx_get_cpl,
A
Avi Kivity 已提交
5011
	.get_cs_db_l_bits = vmx_get_cs_db_l_bits,
5012
	.decache_cr0_guest_bits = vmx_decache_cr0_guest_bits,
5013
	.decache_cr3 = vmx_decache_cr3,
5014
	.decache_cr4_guest_bits = vmx_decache_cr4_guest_bits,
A
Avi Kivity 已提交
5015 5016 5017 5018 5019 5020 5021 5022
	.set_cr0 = vmx_set_cr0,
	.set_cr3 = vmx_set_cr3,
	.set_cr4 = vmx_set_cr4,
	.set_efer = vmx_set_efer,
	.get_idt = vmx_get_idt,
	.set_idt = vmx_set_idt,
	.get_gdt = vmx_get_gdt,
	.set_gdt = vmx_set_gdt,
5023
	.set_dr7 = vmx_set_dr7,
5024
	.cache_reg = vmx_cache_reg,
A
Avi Kivity 已提交
5025 5026
	.get_rflags = vmx_get_rflags,
	.set_rflags = vmx_set_rflags,
5027
	.fpu_activate = vmx_fpu_activate,
5028
	.fpu_deactivate = vmx_fpu_deactivate,
A
Avi Kivity 已提交
5029 5030 5031 5032

	.tlb_flush = vmx_flush_tlb,

	.run = vmx_vcpu_run,
5033
	.handle_exit = vmx_handle_exit,
A
Avi Kivity 已提交
5034
	.skip_emulated_instruction = skip_emulated_instruction,
5035 5036
	.set_interrupt_shadow = vmx_set_interrupt_shadow,
	.get_interrupt_shadow = vmx_get_interrupt_shadow,
I
Ingo Molnar 已提交
5037
	.patch_hypercall = vmx_patch_hypercall,
E
Eddie Dong 已提交
5038
	.set_irq = vmx_inject_irq,
5039
	.set_nmi = vmx_inject_nmi,
5040
	.queue_exception = vmx_queue_exception,
A
Avi Kivity 已提交
5041
	.cancel_injection = vmx_cancel_injection,
5042
	.interrupt_allowed = vmx_interrupt_allowed,
5043
	.nmi_allowed = vmx_nmi_allowed,
J
Jan Kiszka 已提交
5044 5045
	.get_nmi_mask = vmx_get_nmi_mask,
	.set_nmi_mask = vmx_set_nmi_mask,
5046 5047 5048 5049
	.enable_nmi_window = enable_nmi_window,
	.enable_irq_window = enable_irq_window,
	.update_cr8_intercept = update_cr8_intercept,

5050
	.set_tss_addr = vmx_set_tss_addr,
5051
	.get_tdp_level = get_ept_level,
5052
	.get_mt_mask = vmx_get_mt_mask,
5053

5054
	.get_exit_info = vmx_get_exit_info,
5055
	.exit_reasons_str = vmx_exit_reasons_str,
5056

5057
	.get_lpage_level = vmx_get_lpage_level,
5058 5059

	.cpuid_update = vmx_cpuid_update,
5060 5061

	.rdtscp_supported = vmx_rdtscp_supported,
5062 5063

	.set_supported_cpuid = vmx_set_supported_cpuid,
5064 5065

	.has_wbinvd_exit = cpu_has_vmx_wbinvd_exit,
5066

5067
	.set_tsc_khz = vmx_set_tsc_khz,
5068
	.write_tsc_offset = vmx_write_tsc_offset,
Z
Zachary Amsden 已提交
5069
	.adjust_tsc_offset = vmx_adjust_tsc_offset,
5070
	.compute_tsc_offset = vmx_compute_tsc_offset,
5071 5072

	.set_tdp_cr3 = vmx_set_cr3,
5073 5074

	.check_intercept = vmx_check_intercept,
A
Avi Kivity 已提交
5075 5076 5077 5078
};

static int __init vmx_init(void)
{
5079 5080 5081 5082 5083 5084
	int r, i;

	rdmsrl_safe(MSR_EFER, &host_efer);

	for (i = 0; i < NR_VMX_MSR; ++i)
		kvm_define_shared_msr(i, vmx_msr_index[i]);
5085

5086
	vmx_io_bitmap_a = (unsigned long *)__get_free_page(GFP_KERNEL);
5087 5088 5089
	if (!vmx_io_bitmap_a)
		return -ENOMEM;

5090
	vmx_io_bitmap_b = (unsigned long *)__get_free_page(GFP_KERNEL);
5091 5092 5093 5094 5095
	if (!vmx_io_bitmap_b) {
		r = -ENOMEM;
		goto out;
	}

5096 5097
	vmx_msr_bitmap_legacy = (unsigned long *)__get_free_page(GFP_KERNEL);
	if (!vmx_msr_bitmap_legacy) {
S
Sheng Yang 已提交
5098 5099 5100 5101
		r = -ENOMEM;
		goto out1;
	}

5102 5103 5104 5105 5106 5107
	vmx_msr_bitmap_longmode = (unsigned long *)__get_free_page(GFP_KERNEL);
	if (!vmx_msr_bitmap_longmode) {
		r = -ENOMEM;
		goto out2;
	}

5108 5109 5110 5111
	/*
	 * Allow direct access to the PC debug port (it is often used for I/O
	 * delays, but the vmexits simply slow things down).
	 */
5112 5113
	memset(vmx_io_bitmap_a, 0xff, PAGE_SIZE);
	clear_bit(0x80, vmx_io_bitmap_a);
5114

5115
	memset(vmx_io_bitmap_b, 0xff, PAGE_SIZE);
5116

5117 5118
	memset(vmx_msr_bitmap_legacy, 0xff, PAGE_SIZE);
	memset(vmx_msr_bitmap_longmode, 0xff, PAGE_SIZE);
S
Sheng Yang 已提交
5119

5120 5121
	set_bit(0, vmx_vpid_bitmap); /* 0 is reserved for host */

5122 5123
	r = kvm_init(&vmx_x86_ops, sizeof(struct vcpu_vmx),
		     __alignof__(struct vcpu_vmx), THIS_MODULE);
5124
	if (r)
5125
		goto out3;
S
Sheng Yang 已提交
5126

5127 5128 5129 5130 5131 5132
	vmx_disable_intercept_for_msr(MSR_FS_BASE, false);
	vmx_disable_intercept_for_msr(MSR_GS_BASE, false);
	vmx_disable_intercept_for_msr(MSR_KERNEL_GS_BASE, true);
	vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_CS, false);
	vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_ESP, false);
	vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_EIP, false);
5133

5134
	if (enable_ept) {
5135
		bypass_guest_pf = 0;
5136
		kvm_mmu_set_mask_ptes(0ull, 0ull, 0ull, 0ull,
5137
				VMX_EPT_EXECUTABLE_MASK);
5138 5139 5140
		kvm_enable_tdp();
	} else
		kvm_disable_tdp();
5141

5142 5143 5144
	if (bypass_guest_pf)
		kvm_mmu_set_nonpresent_ptes(~0xffeull, 0ull);

5145 5146
	return 0;

5147 5148
out3:
	free_page((unsigned long)vmx_msr_bitmap_longmode);
S
Sheng Yang 已提交
5149
out2:
5150
	free_page((unsigned long)vmx_msr_bitmap_legacy);
5151
out1:
5152
	free_page((unsigned long)vmx_io_bitmap_b);
5153
out:
5154
	free_page((unsigned long)vmx_io_bitmap_a);
5155
	return r;
A
Avi Kivity 已提交
5156 5157 5158 5159
}

static void __exit vmx_exit(void)
{
5160 5161
	free_page((unsigned long)vmx_msr_bitmap_legacy);
	free_page((unsigned long)vmx_msr_bitmap_longmode);
5162 5163
	free_page((unsigned long)vmx_io_bitmap_b);
	free_page((unsigned long)vmx_io_bitmap_a);
5164

5165
	kvm_exit();
A
Avi Kivity 已提交
5166 5167 5168 5169
}

module_init(vmx_init)
module_exit(vmx_exit)