vmx.c 107.9 KB
Newer Older
A
Avi Kivity 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * 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.
 *
 * 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.
 *
 */

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

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

A
Avi Kivity 已提交
32
#include <asm/io.h>
A
Anthony Liguori 已提交
33
#include <asm/desc.h>
34
#include <asm/vmx.h>
35
#include <asm/virtext.h>
A
Andi Kleen 已提交
36
#include <asm/mce.h>
A
Avi Kivity 已提交
37

38 39
#include "trace.h"

40 41
#define __ex(x) __kvm_handle_fault_on_reboot(x)

A
Avi Kivity 已提交
42 43 44
MODULE_AUTHOR("Qumranet");
MODULE_LICENSE("GPL");

45
static int __read_mostly bypass_guest_pf = 1;
46
module_param(bypass_guest_pf, bool, S_IRUGO);
47

48
static int __read_mostly enable_vpid = 1;
49
module_param_named(vpid, enable_vpid, bool, 0444);
50

51
static int __read_mostly flexpriority_enabled = 1;
52
module_param_named(flexpriority, flexpriority_enabled, bool, S_IRUGO);
53

54
static int __read_mostly enable_ept = 1;
55
module_param_named(ept, enable_ept, bool, S_IRUGO);
S
Sheng Yang 已提交
56

57 58 59 60
static int __read_mostly enable_unrestricted_guest = 1;
module_param_named(unrestricted_guest,
			enable_unrestricted_guest, bool, S_IRUGO);

61
static int __read_mostly emulate_invalid_guest_state = 0;
62
module_param(emulate_invalid_guest_state, bool, S_IRUGO);
63

64 65 66 67 68 69 70 71
#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				\
	(X86_CR0_WP | X86_CR0_NE | X86_CR0_TS | X86_CR0_MP)
#define KVM_VM_CR0_ALWAYS_ON						\
	(KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST | X86_CR0_PG | X86_CR0_PE)
72 73 74 75
#define KVM_CR4_GUEST_OWNED_BITS				      \
	(X86_CR4_PVI | X86_CR4_DE | X86_CR4_PCE | X86_CR4_OSFXSR      \
	 | X86_CR4_OSXMMEXCPT)

76 77 78
#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)

79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
/*
 * 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.
 *             According to test, this time is usually small than 41 cycles.
 * 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.
 */
#define KVM_VMX_DEFAULT_PLE_GAP    41
#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);

98 99 100 101 102 103
struct vmcs {
	u32 revision_id;
	u32 abort;
	char data[0];
};

104 105 106
struct shared_msr_entry {
	unsigned index;
	u64 data;
107
	u64 mask;
108 109
};

110
struct vcpu_vmx {
R
Rusty Russell 已提交
111
	struct kvm_vcpu       vcpu;
112
	struct list_head      local_vcpus_link;
113
	unsigned long         host_rsp;
114
	int                   launched;
115
	u8                    fail;
116
	u32                   idt_vectoring_info;
117
	struct shared_msr_entry *guest_msrs;
118 119 120
	int                   nmsrs;
	int                   save_nmsrs;
#ifdef CONFIG_X86_64
121 122
	u64 		      msr_host_kernel_gs_base;
	u64 		      msr_guest_kernel_gs_base;
123 124 125 126 127
#endif
	struct vmcs          *vmcs;
	struct {
		int           loaded;
		u16           fs_sel, gs_sel, ldt_sel;
128 129
		int           gs_ldt_reload_needed;
		int           fs_reload_needed;
M
Mike Day 已提交
130
	} host_state;
131
	struct {
132 133 134 135 136 137 138 139
		int vm86_active;
		u8 save_iopl;
		struct kvm_save_segment {
			u16 selector;
			unsigned long base;
			u32 limit;
			u32 ar;
		} tr, es, ds, fs, gs;
140 141 142 143 144 145
		struct {
			bool pending;
			u8 vector;
			unsigned rip;
		} irq;
	} rmode;
146
	int vpid;
147
	bool emulation_required;
148 149 150 151 152

	/* Support for vnmi-less CPUs */
	int soft_vnmi_blocked;
	ktime_t entry_time;
	s64 vnmi_blocked_time;
A
Andi Kleen 已提交
153
	u32 exit_reason;
154 155

	bool rdtscp_enabled;
156 157 158 159
};

static inline struct vcpu_vmx *to_vmx(struct kvm_vcpu *vcpu)
{
R
Rusty Russell 已提交
160
	return container_of(vcpu, struct vcpu_vmx, vcpu);
161 162
}

163
static int init_rmode(struct kvm *kvm);
164
static u64 construct_eptp(unsigned long root_hpa);
165

A
Avi Kivity 已提交
166 167
static DEFINE_PER_CPU(struct vmcs *, vmxarea);
static DEFINE_PER_CPU(struct vmcs *, current_vmcs);
168
static DEFINE_PER_CPU(struct list_head, vcpus_on_cpu);
A
Avi Kivity 已提交
169

170 171
static unsigned long *vmx_io_bitmap_a;
static unsigned long *vmx_io_bitmap_b;
172 173
static unsigned long *vmx_msr_bitmap_legacy;
static unsigned long *vmx_msr_bitmap_longmode;
174

175 176 177
static DECLARE_BITMAP(vmx_vpid_bitmap, VMX_NR_VPIDS);
static DEFINE_SPINLOCK(vmx_vpid_lock);

178
static struct vmcs_config {
A
Avi Kivity 已提交
179 180 181
	int size;
	int order;
	u32 revision_id;
182 183
	u32 pin_based_exec_ctrl;
	u32 cpu_based_exec_ctrl;
184
	u32 cpu_based_2nd_exec_ctrl;
185 186 187
	u32 vmexit_ctrl;
	u32 vmentry_ctrl;
} vmcs_config;
A
Avi Kivity 已提交
188

H
Hannes Eder 已提交
189
static struct vmx_capability {
S
Sheng Yang 已提交
190 191 192 193
	u32 ept;
	u32 vpid;
} vmx_capability;

A
Avi Kivity 已提交
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
#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),
};

218 219
static u64 host_efer;

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

222 223 224 225
/*
 * Keep MSR_K6_STAR at the end, as setup_msrs() will try to optimize it
 * away by decrementing the array size.
 */
A
Avi Kivity 已提交
226
static const u32 vmx_msr_index[] = {
227
#ifdef CONFIG_X86_64
228
	MSR_SYSCALL_MASK, MSR_LSTAR, MSR_CSTAR,
A
Avi Kivity 已提交
229
#endif
230
	MSR_EFER, MSR_TSC_AUX, MSR_K6_STAR,
A
Avi Kivity 已提交
231
};
232
#define NR_VMX_MSR ARRAY_SIZE(vmx_msr_index)
A
Avi Kivity 已提交
233 234 235 236 237

static inline int is_page_fault(u32 intr_info)
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
238
		(INTR_TYPE_HARD_EXCEPTION | PF_VECTOR | INTR_INFO_VALID_MASK);
A
Avi Kivity 已提交
239 240
}

241 242 243 244
static inline int is_no_device(u32 intr_info)
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
245
		(INTR_TYPE_HARD_EXCEPTION | NM_VECTOR | INTR_INFO_VALID_MASK);
246 247
}

248 249 250 251
static inline int is_invalid_opcode(u32 intr_info)
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
252
		(INTR_TYPE_HARD_EXCEPTION | UD_VECTOR | INTR_INFO_VALID_MASK);
253 254
}

A
Avi Kivity 已提交
255 256 257 258 259 260
static inline int is_external_interrupt(u32 intr_info)
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VALID_MASK))
		== (INTR_TYPE_EXT_INTR | INTR_INFO_VALID_MASK);
}

A
Andi Kleen 已提交
261 262 263 264 265 266 267
static inline int is_machine_check(u32 intr_info)
{
	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);
}

S
Sheng Yang 已提交
268 269
static inline int cpu_has_vmx_msr_bitmap(void)
{
270
	return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS;
S
Sheng Yang 已提交
271 272
}

273 274
static inline int cpu_has_vmx_tpr_shadow(void)
{
275
	return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW;
276 277 278 279
}

static inline int vm_need_tpr_shadow(struct kvm *kvm)
{
280
	return (cpu_has_vmx_tpr_shadow()) && (irqchip_in_kernel(kvm));
281 282
}

283 284
static inline int cpu_has_secondary_exec_ctrls(void)
{
285 286
	return vmcs_config.cpu_based_exec_ctrl &
		CPU_BASED_ACTIVATE_SECONDARY_CONTROLS;
287 288
}

289
static inline bool cpu_has_vmx_virtualize_apic_accesses(void)
290
{
291 292 293 294 295 296 297 298
	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();
299 300
}

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
static inline bool cpu_has_vmx_ept_execute_only(void)
{
	return !!(vmx_capability.ept & VMX_EPT_EXECUTE_ONLY_BIT);
}

static inline bool cpu_has_vmx_eptp_uncacheable(void)
{
	return !!(vmx_capability.ept & VMX_EPTP_UC_BIT);
}

static inline bool cpu_has_vmx_eptp_writeback(void)
{
	return !!(vmx_capability.ept & VMX_EPTP_WB_BIT);
}

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

S
Sheng Yang 已提交
321 322
static inline int cpu_has_vmx_invept_individual_addr(void)
{
323
	return !!(vmx_capability.ept & VMX_EPT_EXTENT_INDIVIDUAL_BIT);
S
Sheng Yang 已提交
324 325 326 327
}

static inline int cpu_has_vmx_invept_context(void)
{
328
	return !!(vmx_capability.ept & VMX_EPT_EXTENT_CONTEXT_BIT);
S
Sheng Yang 已提交
329 330 331 332
}

static inline int cpu_has_vmx_invept_global(void)
{
333
	return !!(vmx_capability.ept & VMX_EPT_EXTENT_GLOBAL_BIT);
S
Sheng Yang 已提交
334 335 336 337
}

static inline int cpu_has_vmx_ept(void)
{
338 339
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_ENABLE_EPT;
S
Sheng Yang 已提交
340 341
}

342 343 344 345 346 347
static inline int cpu_has_vmx_unrestricted_guest(void)
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_UNRESTRICTED_GUEST;
}

348 349 350 351 352 353
static inline int cpu_has_vmx_ple(void)
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_PAUSE_LOOP_EXITING;
}

354 355
static inline int vm_need_virtualize_apic_accesses(struct kvm *kvm)
{
356 357 358
	return flexpriority_enabled &&
		(cpu_has_vmx_virtualize_apic_accesses()) &&
		(irqchip_in_kernel(kvm));
359 360
}

361 362
static inline int cpu_has_vmx_vpid(void)
{
363 364
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_ENABLE_VPID;
365 366
}

367 368 369 370 371 372
static inline int cpu_has_vmx_rdtscp(void)
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_RDTSCP;
}

373 374 375 376 377
static inline int cpu_has_virtual_nmis(void)
{
	return vmcs_config.pin_based_exec_ctrl & PIN_BASED_VIRTUAL_NMIS;
}

378 379 380 381 382
static inline bool report_flexpriority(void)
{
	return flexpriority_enabled;
}

R
Rusty Russell 已提交
383
static int __find_msr_index(struct vcpu_vmx *vmx, u32 msr)
384 385 386
{
	int i;

387
	for (i = 0; i < vmx->nmsrs; ++i)
388
		if (vmx_msr_index[vmx->guest_msrs[i].index] == msr)
389 390 391 392
			return i;
	return -1;
}

393 394 395 396 397 398 399 400
static inline void __invvpid(int ext, u16 vpid, gva_t gva)
{
    struct {
	u64 vpid : 16;
	u64 rsvd : 48;
	u64 gva;
    } operand = { vpid, 0, gva };

401
    asm volatile (__ex(ASM_VMX_INVVPID)
402 403 404 405 406
		  /* CF==1 or ZF==1 --> rc = -1 */
		  "; ja 1f ; ud2 ; 1:"
		  : : "a"(&operand), "c"(ext) : "cc", "memory");
}

407 408 409 410 411 412
static inline void __invept(int ext, u64 eptp, gpa_t gpa)
{
	struct {
		u64 eptp, gpa;
	} operand = {eptp, gpa};

413
	asm volatile (__ex(ASM_VMX_INVEPT)
414 415 416 417 418
			/* CF==1 or ZF==1 --> rc = -1 */
			"; ja 1f ; ud2 ; 1:\n"
			: : "a" (&operand), "c" (ext) : "cc", "memory");
}

419
static struct shared_msr_entry *find_msr_entry(struct vcpu_vmx *vmx, u32 msr)
420 421 422
{
	int i;

R
Rusty Russell 已提交
423
	i = __find_msr_index(vmx, msr);
424
	if (i >= 0)
425
		return &vmx->guest_msrs[i];
A
Al Viro 已提交
426
	return NULL;
427 428
}

A
Avi Kivity 已提交
429 430 431 432 433
static void vmcs_clear(struct vmcs *vmcs)
{
	u64 phys_addr = __pa(vmcs);
	u8 error;

434
	asm volatile (__ex(ASM_VMX_VMCLEAR_RAX) "; setna %0"
A
Avi Kivity 已提交
435 436 437 438 439 440 441 442 443
		      : "=g"(error) : "a"(&phys_addr), "m"(phys_addr)
		      : "cc", "memory");
	if (error)
		printk(KERN_ERR "kvm: vmclear fail: %p/%llx\n",
		       vmcs, phys_addr);
}

static void __vcpu_clear(void *arg)
{
R
Rusty Russell 已提交
444
	struct vcpu_vmx *vmx = arg;
445
	int cpu = raw_smp_processor_id();
A
Avi Kivity 已提交
446

R
Rusty Russell 已提交
447
	if (vmx->vcpu.cpu == cpu)
448 449
		vmcs_clear(vmx->vmcs);
	if (per_cpu(current_vmcs, cpu) == vmx->vmcs)
A
Avi Kivity 已提交
450
		per_cpu(current_vmcs, cpu) = NULL;
451
	rdtscll(vmx->vcpu.arch.host_tsc);
452 453 454
	list_del(&vmx->local_vcpus_link);
	vmx->vcpu.cpu = -1;
	vmx->launched = 0;
A
Avi Kivity 已提交
455 456
}

R
Rusty Russell 已提交
457
static void vcpu_clear(struct vcpu_vmx *vmx)
A
Avi Kivity 已提交
458
{
459 460
	if (vmx->vcpu.cpu == -1)
		return;
461
	smp_call_function_single(vmx->vcpu.cpu, __vcpu_clear, vmx, 1);
A
Avi Kivity 已提交
462 463
}

464 465 466 467 468 469 470 471
static inline void vpid_sync_vcpu_all(struct vcpu_vmx *vmx)
{
	if (vmx->vpid == 0)
		return;

	__invvpid(VMX_VPID_EXTENT_SINGLE_CONTEXT, vmx->vpid, 0);
}

472 473 474 475 476 477 478 479
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)
{
480
	if (enable_ept) {
481 482 483 484 485 486 487 488 489
		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)
{
490
	if (enable_ept) {
491 492 493 494 495 496 497 498
		if (cpu_has_vmx_invept_individual_addr())
			__invept(VMX_EPT_EXTENT_INDIVIDUAL_ADDR,
					eptp, gpa);
		else
			ept_sync_context(eptp);
	}
}

A
Avi Kivity 已提交
499 500 501 502
static unsigned long vmcs_readl(unsigned long field)
{
	unsigned long value;

503
	asm volatile (__ex(ASM_VMX_VMREAD_RDX_RAX)
A
Avi Kivity 已提交
504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519
		      : "=a"(value) : "d"(field) : "cc");
	return value;
}

static u16 vmcs_read16(unsigned long field)
{
	return vmcs_readl(field);
}

static u32 vmcs_read32(unsigned long field)
{
	return vmcs_readl(field);
}

static u64 vmcs_read64(unsigned long field)
{
520
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
521 522 523 524 525 526
	return vmcs_readl(field);
#else
	return vmcs_readl(field) | ((u64)vmcs_readl(field+1) << 32);
#endif
}

527 528 529 530 531 532 533
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 已提交
534 535 536 537
static void vmcs_writel(unsigned long field, unsigned long value)
{
	u8 error;

538
	asm volatile (__ex(ASM_VMX_VMWRITE_RAX_RDX) "; setna %0"
M
Mike Day 已提交
539
		       : "=q"(error) : "a"(value), "d"(field) : "cc");
540 541
	if (unlikely(error))
		vmwrite_error(field, value);
A
Avi Kivity 已提交
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
}

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);
557
#ifndef CONFIG_X86_64
A
Avi Kivity 已提交
558 559 560 561 562
	asm volatile ("");
	vmcs_writel(field+1, value >> 32);
#endif
}

563 564 565 566 567 568 569 570 571 572
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);
}

573 574 575 576
static void update_exception_bitmap(struct kvm_vcpu *vcpu)
{
	u32 eb;

A
Andi Kleen 已提交
577
	eb = (1u << PF_VECTOR) | (1u << UD_VECTOR) | (1u << MC_VECTOR);
578 579
	if (!vcpu->fpu_active)
		eb |= 1u << NM_VECTOR;
580 581 582 583 584
	/*
	 * Unconditionally intercept #DB so we can maintain dr6 without
	 * reading it every exit.
	 */
	eb |= 1u << DB_VECTOR;
J
Jan Kiszka 已提交
585 586 587 588
	if (vcpu->guest_debug & KVM_GUESTDBG_ENABLE) {
		if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP)
			eb |= 1u << BP_VECTOR;
	}
589
	if (to_vmx(vcpu)->rmode.vm86_active)
590
		eb = ~0;
591
	if (enable_ept)
592
		eb &= ~(1u << PF_VECTOR); /* bypass_guest_pf = 0 */
593 594 595
	vmcs_write32(EXCEPTION_BITMAP, eb);
}

596 597 598 599 600 601
static void reload_tss(void)
{
	/*
	 * VT restores TR but not its size.  Useless.
	 */
	struct descriptor_table gdt;
602
	struct desc_struct *descs;
603

604
	kvm_get_gdt(&gdt);
605 606 607 608 609
	descs = (void *)gdt.base;
	descs[GDT_ENTRY_TSS].type = 9; /* available TSS */
	load_TR_desc();
}

A
Avi Kivity 已提交
610
static bool update_transition_efer(struct vcpu_vmx *vmx, int efer_offset)
611
{
R
Roel Kluin 已提交
612
	u64 guest_efer;
613 614
	u64 ignore_bits;

615
	guest_efer = vmx->vcpu.arch.shadow_efer;
R
Roel Kluin 已提交
616

617 618 619 620 621 622 623 624 625 626 627 628 629
	/*
	 * 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;
630
	vmx->guest_msrs[efer_offset].data = guest_efer;
631
	vmx->guest_msrs[efer_offset].mask = ~ignore_bits;
632
	return true;
633 634
}

635
static void vmx_save_host_state(struct kvm_vcpu *vcpu)
636
{
637
	struct vcpu_vmx *vmx = to_vmx(vcpu);
638
	int i;
639

640
	if (vmx->host_state.loaded)
641 642
		return;

643
	vmx->host_state.loaded = 1;
644 645 646 647
	/*
	 * Set host fs and gs selectors.  Unfortunately, 22.2.3 does not
	 * allow segment selectors with cpl > 0 or ti == 1.
	 */
648
	vmx->host_state.ldt_sel = kvm_read_ldt();
649
	vmx->host_state.gs_ldt_reload_needed = vmx->host_state.ldt_sel;
650
	vmx->host_state.fs_sel = kvm_read_fs();
651
	if (!(vmx->host_state.fs_sel & 7)) {
652
		vmcs_write16(HOST_FS_SELECTOR, vmx->host_state.fs_sel);
653 654
		vmx->host_state.fs_reload_needed = 0;
	} else {
655
		vmcs_write16(HOST_FS_SELECTOR, 0);
656
		vmx->host_state.fs_reload_needed = 1;
657
	}
658
	vmx->host_state.gs_sel = kvm_read_gs();
659 660
	if (!(vmx->host_state.gs_sel & 7))
		vmcs_write16(HOST_GS_SELECTOR, vmx->host_state.gs_sel);
661 662
	else {
		vmcs_write16(HOST_GS_SELECTOR, 0);
663
		vmx->host_state.gs_ldt_reload_needed = 1;
664 665 666 667 668 669
	}

#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
670 671
	vmcs_writel(HOST_FS_BASE, segment_base(vmx->host_state.fs_sel));
	vmcs_writel(HOST_GS_BASE, segment_base(vmx->host_state.gs_sel));
672
#endif
673 674

#ifdef CONFIG_X86_64
675 676 677 678
	if (is_long_mode(&vmx->vcpu)) {
		rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base);
		wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base);
	}
679
#endif
680 681
	for (i = 0; i < vmx->save_nmsrs; ++i)
		kvm_set_shared_msr(vmx->guest_msrs[i].index,
682 683
				   vmx->guest_msrs[i].data,
				   vmx->guest_msrs[i].mask);
684 685
}

686
static void __vmx_load_host_state(struct vcpu_vmx *vmx)
687
{
688
	unsigned long flags;
689

690
	if (!vmx->host_state.loaded)
691 692
		return;

693
	++vmx->vcpu.stat.host_state_reload;
694
	vmx->host_state.loaded = 0;
695
	if (vmx->host_state.fs_reload_needed)
696
		kvm_load_fs(vmx->host_state.fs_sel);
697
	if (vmx->host_state.gs_ldt_reload_needed) {
698
		kvm_load_ldt(vmx->host_state.ldt_sel);
699 700 701 702
		/*
		 * If we have to reload gs, we must take care to
		 * preserve our gs base.
		 */
703
		local_irq_save(flags);
704
		kvm_load_gs(vmx->host_state.gs_sel);
705 706 707
#ifdef CONFIG_X86_64
		wrmsrl(MSR_GS_BASE, vmcs_readl(HOST_GS_BASE));
#endif
708
		local_irq_restore(flags);
709
	}
710
	reload_tss();
711 712 713 714 715 716
#ifdef CONFIG_X86_64
	if (is_long_mode(&vmx->vcpu)) {
		rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base);
		wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base);
	}
#endif
717 718
}

719 720 721 722 723 724 725
static void vmx_load_host_state(struct vcpu_vmx *vmx)
{
	preempt_disable();
	__vmx_load_host_state(vmx);
	preempt_enable();
}

A
Avi Kivity 已提交
726 727 728 729
/*
 * Switches to specified vcpu, until a matching vcpu_put(), but assumes
 * vcpu mutex is already taken.
 */
730
static void vmx_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
A
Avi Kivity 已提交
731
{
732 733
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	u64 phys_addr = __pa(vmx->vmcs);
734
	u64 tsc_this, delta, new_offset;
A
Avi Kivity 已提交
735

736
	if (vcpu->cpu != cpu) {
R
Rusty Russell 已提交
737
		vcpu_clear(vmx);
M
Marcelo Tosatti 已提交
738
		kvm_migrate_timers(vcpu);
739
		set_bit(KVM_REQ_TLB_FLUSH, &vcpu->requests);
740 741 742 743
		local_irq_disable();
		list_add(&vmx->local_vcpus_link,
			 &per_cpu(vcpus_on_cpu, cpu));
		local_irq_enable();
744
	}
A
Avi Kivity 已提交
745

746
	if (per_cpu(current_vmcs, cpu) != vmx->vmcs) {
A
Avi Kivity 已提交
747 748
		u8 error;

749
		per_cpu(current_vmcs, cpu) = vmx->vmcs;
750
		asm volatile (__ex(ASM_VMX_VMPTRLD_RAX) "; setna %0"
A
Avi Kivity 已提交
751 752 753 754
			      : "=g"(error) : "a"(&phys_addr), "m"(phys_addr)
			      : "cc");
		if (error)
			printk(KERN_ERR "kvm: vmptrld %p/%llx fail\n",
755
			       vmx->vmcs, phys_addr);
A
Avi Kivity 已提交
756 757 758 759 760 761 762 763 764 765 766
	}

	if (vcpu->cpu != cpu) {
		struct descriptor_table dt;
		unsigned long sysenter_esp;

		vcpu->cpu = cpu;
		/*
		 * Linux uses per-cpu TSS and GDT, so set these when switching
		 * processors.
		 */
767 768
		vmcs_writel(HOST_TR_BASE, kvm_read_tr_base()); /* 22.2.4 */
		kvm_get_gdt(&dt);
A
Avi Kivity 已提交
769 770 771 772
		vmcs_writel(HOST_GDTR_BASE, dt.base);   /* 22.2.4 */

		rdmsrl(MSR_IA32_SYSENTER_ESP, sysenter_esp);
		vmcs_writel(HOST_IA32_SYSENTER_ESP, sysenter_esp); /* 22.2.3 */
773 774 775 776 777

		/*
		 * Make sure the time stamp counter is monotonous.
		 */
		rdtscll(tsc_this);
778 779 780 781 782
		if (tsc_this < vcpu->arch.host_tsc) {
			delta = vcpu->arch.host_tsc - tsc_this;
			new_offset = vmcs_read64(TSC_OFFSET) + delta;
			vmcs_write64(TSC_OFFSET, new_offset);
		}
A
Avi Kivity 已提交
783 784 785 786 787
	}
}

static void vmx_vcpu_put(struct kvm_vcpu *vcpu)
{
788
	__vmx_load_host_state(to_vmx(vcpu));
A
Avi Kivity 已提交
789 790
}

791 792 793 794 795
static void vmx_fpu_activate(struct kvm_vcpu *vcpu)
{
	if (vcpu->fpu_active)
		return;
	vcpu->fpu_active = 1;
796
	vmcs_clear_bits(GUEST_CR0, X86_CR0_TS);
797
	if (vcpu->arch.cr0 & X86_CR0_TS)
798
		vmcs_set_bits(GUEST_CR0, X86_CR0_TS);
799 800 801 802 803 804 805 806
	update_exception_bitmap(vcpu);
}

static void vmx_fpu_deactivate(struct kvm_vcpu *vcpu)
{
	if (!vcpu->fpu_active)
		return;
	vcpu->fpu_active = 0;
807
	vmcs_set_bits(GUEST_CR0, X86_CR0_TS);
808 809 810
	update_exception_bitmap(vcpu);
}

A
Avi Kivity 已提交
811 812
static unsigned long vmx_get_rflags(struct kvm_vcpu *vcpu)
{
813 814 815 816 817 818
	unsigned long rflags;

	rflags = vmcs_readl(GUEST_RFLAGS);
	if (to_vmx(vcpu)->rmode.vm86_active)
		rflags &= ~(unsigned long)(X86_EFLAGS_IOPL | X86_EFLAGS_VM);
	return rflags;
A
Avi Kivity 已提交
819 820 821 822
}

static void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags)
{
823
	if (to_vmx(vcpu)->rmode.vm86_active)
824
		rflags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM;
A
Avi Kivity 已提交
825 826 827
	vmcs_writel(GUEST_RFLAGS, rflags);
}

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
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)
		ret |= X86_SHADOW_INT_STI;
	if (interruptibility & GUEST_INTR_STATE_MOV_SS)
		ret |= X86_SHADOW_INT_MOV_SS;

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

	if (mask & X86_SHADOW_INT_MOV_SS)
		interruptibility |= GUEST_INTR_STATE_MOV_SS;
	if (mask & X86_SHADOW_INT_STI)
		interruptibility |= GUEST_INTR_STATE_STI;

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

A
Avi Kivity 已提交
857 858 859 860
static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
{
	unsigned long rip;

861
	rip = kvm_rip_read(vcpu);
A
Avi Kivity 已提交
862
	rip += vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
863
	kvm_rip_write(vcpu, rip);
A
Avi Kivity 已提交
864

865 866
	/* skipping an emulated instruction also counts */
	vmx_set_interrupt_shadow(vcpu, 0);
A
Avi Kivity 已提交
867 868
}

869 870 871
static void vmx_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
				bool has_error_code, u32 error_code)
{
872
	struct vcpu_vmx *vmx = to_vmx(vcpu);
873
	u32 intr_info = nr | INTR_INFO_VALID_MASK;
874

875
	if (has_error_code) {
876
		vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, error_code);
877 878
		intr_info |= INTR_INFO_DELIVER_CODE_MASK;
	}
879

880
	if (vmx->rmode.vm86_active) {
881 882 883
		vmx->rmode.irq.pending = true;
		vmx->rmode.irq.vector = nr;
		vmx->rmode.irq.rip = kvm_rip_read(vcpu);
884 885 886
		if (kvm_exception_is_soft(nr))
			vmx->rmode.irq.rip +=
				vmx->vcpu.arch.event_exit_inst_len;
887 888
		intr_info |= INTR_TYPE_SOFT_INTR;
		vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info);
889 890 891 892 893
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, 1);
		kvm_rip_write(vcpu, vmx->rmode.irq.rip - 1);
		return;
	}

894 895 896
	if (kvm_exception_is_soft(nr)) {
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN,
			     vmx->vcpu.arch.event_exit_inst_len);
897 898 899 900 901
		intr_info |= INTR_TYPE_SOFT_EXCEPTION;
	} else
		intr_info |= INTR_TYPE_HARD_EXCEPTION;

	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info);
902 903
}

904 905 906 907 908
static bool vmx_rdtscp_supported(void)
{
	return cpu_has_vmx_rdtscp();
}

909 910 911
/*
 * Swap MSR entry in host/guest MSR entry array.
 */
R
Rusty Russell 已提交
912
static void move_msr_up(struct vcpu_vmx *vmx, int from, int to)
913
{
914
	struct shared_msr_entry tmp;
915 916 917 918

	tmp = vmx->guest_msrs[to];
	vmx->guest_msrs[to] = vmx->guest_msrs[from];
	vmx->guest_msrs[from] = tmp;
919 920
}

921 922 923 924 925
/*
 * 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 已提交
926
static void setup_msrs(struct vcpu_vmx *vmx)
927
{
928
	int save_nmsrs, index;
929
	unsigned long *msr_bitmap;
930

931
	vmx_load_host_state(vmx);
932 933
	save_nmsrs = 0;
#ifdef CONFIG_X86_64
R
Rusty Russell 已提交
934 935
	if (is_long_mode(&vmx->vcpu)) {
		index = __find_msr_index(vmx, MSR_SYSCALL_MASK);
936
		if (index >= 0)
R
Rusty Russell 已提交
937 938
			move_msr_up(vmx, index, save_nmsrs++);
		index = __find_msr_index(vmx, MSR_LSTAR);
939
		if (index >= 0)
R
Rusty Russell 已提交
940 941
			move_msr_up(vmx, index, save_nmsrs++);
		index = __find_msr_index(vmx, MSR_CSTAR);
942
		if (index >= 0)
R
Rusty Russell 已提交
943
			move_msr_up(vmx, index, save_nmsrs++);
944 945 946
		index = __find_msr_index(vmx, MSR_TSC_AUX);
		if (index >= 0 && vmx->rdtscp_enabled)
			move_msr_up(vmx, index, save_nmsrs++);
947 948 949 950
		/*
		 * MSR_K6_STAR is only needed on long mode guests, and only
		 * if efer.sce is enabled.
		 */
R
Rusty Russell 已提交
951
		index = __find_msr_index(vmx, MSR_K6_STAR);
952
		if ((index >= 0) && (vmx->vcpu.arch.shadow_efer & EFER_SCE))
R
Rusty Russell 已提交
953
			move_msr_up(vmx, index, save_nmsrs++);
954 955
	}
#endif
A
Avi Kivity 已提交
956 957
	index = __find_msr_index(vmx, MSR_EFER);
	if (index >= 0 && update_transition_efer(vmx, index))
958
		move_msr_up(vmx, index, save_nmsrs++);
959

960
	vmx->save_nmsrs = save_nmsrs;
961 962 963 964 965 966 967 968 969

	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));
	}
970 971
}

A
Avi Kivity 已提交
972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
/*
 * 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;
}

/*
 * writes 'guest_tsc' into guest's timestamp counter "register"
 * guest_tsc = host_tsc + tsc_offset ==> tsc_offset = guest_tsc - host_tsc
 */
989
static void guest_write_tsc(u64 guest_tsc, u64 host_tsc)
A
Avi Kivity 已提交
990 991 992 993 994 995 996 997 998 999 1000 1001
{
	vmcs_write64(TSC_OFFSET, guest_tsc - host_tsc);
}

/*
 * 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;
1002
	struct shared_msr_entry *msr;
A
Avi Kivity 已提交
1003 1004 1005 1006 1007 1008 1009

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

	switch (msr_index) {
1010
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
1011 1012 1013 1014 1015 1016
	case MSR_FS_BASE:
		data = vmcs_readl(GUEST_FS_BASE);
		break;
	case MSR_GS_BASE:
		data = vmcs_readl(GUEST_GS_BASE);
		break;
1017 1018 1019 1020
	case MSR_KERNEL_GS_BASE:
		vmx_load_host_state(to_vmx(vcpu));
		data = to_vmx(vcpu)->msr_guest_kernel_gs_base;
		break;
1021
#endif
A
Avi Kivity 已提交
1022
	case MSR_EFER:
1023
		return kvm_get_msr_common(vcpu, msr_index, pdata);
1024
	case MSR_IA32_TSC:
A
Avi Kivity 已提交
1025 1026 1027 1028 1029 1030
		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 已提交
1031
		data = vmcs_readl(GUEST_SYSENTER_EIP);
A
Avi Kivity 已提交
1032 1033
		break;
	case MSR_IA32_SYSENTER_ESP:
A
Avi Kivity 已提交
1034
		data = vmcs_readl(GUEST_SYSENTER_ESP);
A
Avi Kivity 已提交
1035
		break;
1036 1037 1038 1039
	case MSR_TSC_AUX:
		if (!to_vmx(vcpu)->rdtscp_enabled)
			return 1;
		/* Otherwise falls through */
A
Avi Kivity 已提交
1040
	default:
1041
		vmx_load_host_state(to_vmx(vcpu));
R
Rusty Russell 已提交
1042
		msr = find_msr_entry(to_vmx(vcpu), msr_index);
1043
		if (msr) {
1044
			vmx_load_host_state(to_vmx(vcpu));
1045 1046
			data = msr->data;
			break;
A
Avi Kivity 已提交
1047
		}
1048
		return kvm_get_msr_common(vcpu, msr_index, pdata);
A
Avi Kivity 已提交
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
	}

	*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)
{
1062
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1063
	struct shared_msr_entry *msr;
1064
	u64 host_tsc;
1065 1066
	int ret = 0;

A
Avi Kivity 已提交
1067
	switch (msr_index) {
1068
	case MSR_EFER:
1069
		vmx_load_host_state(vmx);
1070 1071
		ret = kvm_set_msr_common(vcpu, msr_index, data);
		break;
1072
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
1073 1074 1075 1076 1077 1078
	case MSR_FS_BASE:
		vmcs_writel(GUEST_FS_BASE, data);
		break;
	case MSR_GS_BASE:
		vmcs_writel(GUEST_GS_BASE, data);
		break;
1079 1080 1081 1082
	case MSR_KERNEL_GS_BASE:
		vmx_load_host_state(vmx);
		vmx->msr_guest_kernel_gs_base = data;
		break;
A
Avi Kivity 已提交
1083 1084 1085 1086 1087
#endif
	case MSR_IA32_SYSENTER_CS:
		vmcs_write32(GUEST_SYSENTER_CS, data);
		break;
	case MSR_IA32_SYSENTER_EIP:
A
Avi Kivity 已提交
1088
		vmcs_writel(GUEST_SYSENTER_EIP, data);
A
Avi Kivity 已提交
1089 1090
		break;
	case MSR_IA32_SYSENTER_ESP:
A
Avi Kivity 已提交
1091
		vmcs_writel(GUEST_SYSENTER_ESP, data);
A
Avi Kivity 已提交
1092
		break;
1093
	case MSR_IA32_TSC:
1094 1095
		rdtscll(host_tsc);
		guest_write_tsc(data, host_tsc);
A
Avi Kivity 已提交
1096
		break;
S
Sheng Yang 已提交
1097 1098 1099 1100 1101 1102
	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;
		}
1103 1104 1105 1106 1107 1108 1109 1110 1111
		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 已提交
1112
	default:
R
Rusty Russell 已提交
1113
		msr = find_msr_entry(vmx, msr_index);
1114
		if (msr) {
1115
			vmx_load_host_state(vmx);
1116 1117
			msr->data = data;
			break;
A
Avi Kivity 已提交
1118
		}
1119
		ret = kvm_set_msr_common(vcpu, msr_index, data);
A
Avi Kivity 已提交
1120 1121
	}

1122
	return ret;
A
Avi Kivity 已提交
1123 1124
}

1125
static void vmx_cache_reg(struct kvm_vcpu *vcpu, enum kvm_reg reg)
A
Avi Kivity 已提交
1126
{
1127 1128 1129 1130 1131 1132 1133 1134
	__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 已提交
1135 1136 1137 1138
	case VCPU_EXREG_PDPTR:
		if (enable_ept)
			ept_save_pdptrs(vcpu);
		break;
1139 1140 1141
	default:
		break;
	}
A
Avi Kivity 已提交
1142 1143
}

1144
static void set_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg)
A
Avi Kivity 已提交
1145
{
1146 1147 1148 1149 1150
	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);

1151
	update_exception_bitmap(vcpu);
A
Avi Kivity 已提交
1152 1153 1154 1155
}

static __init int cpu_has_kvm_support(void)
{
1156
	return cpu_has_vmx();
A
Avi Kivity 已提交
1157 1158 1159 1160 1161 1162 1163
}

static __init int vmx_disabled_by_bios(void)
{
	u64 msr;

	rdmsrl(MSR_IA32_FEATURE_CONTROL, msr);
1164 1165 1166
	return (msr & (FEATURE_CONTROL_LOCKED |
		       FEATURE_CONTROL_VMXON_ENABLED))
	    == FEATURE_CONTROL_LOCKED;
1167
	/* locked but not enabled */
A
Avi Kivity 已提交
1168 1169
}

1170
static int hardware_enable(void *garbage)
A
Avi Kivity 已提交
1171 1172 1173 1174 1175
{
	int cpu = raw_smp_processor_id();
	u64 phys_addr = __pa(per_cpu(vmxarea, cpu));
	u64 old;

1176 1177 1178
	if (read_cr4() & X86_CR4_VMXE)
		return -EBUSY;

1179
	INIT_LIST_HEAD(&per_cpu(vcpus_on_cpu, cpu));
A
Avi Kivity 已提交
1180
	rdmsrl(MSR_IA32_FEATURE_CONTROL, old);
1181 1182 1183 1184
	if ((old & (FEATURE_CONTROL_LOCKED |
		    FEATURE_CONTROL_VMXON_ENABLED))
	    != (FEATURE_CONTROL_LOCKED |
		FEATURE_CONTROL_VMXON_ENABLED))
A
Avi Kivity 已提交
1185
		/* enable and lock */
1186
		wrmsrl(MSR_IA32_FEATURE_CONTROL, old |
1187 1188
		       FEATURE_CONTROL_LOCKED |
		       FEATURE_CONTROL_VMXON_ENABLED);
1189
	write_cr4(read_cr4() | X86_CR4_VMXE); /* FIXME: not cpu hotplug safe */
1190 1191
	asm volatile (ASM_VMX_VMXON_RAX
		      : : "a"(&phys_addr), "m"(phys_addr)
A
Avi Kivity 已提交
1192
		      : "memory", "cc");
1193 1194 1195 1196

	ept_sync_global();

	return 0;
A
Avi Kivity 已提交
1197 1198
}

1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
static void vmclear_local_vcpus(void)
{
	int cpu = raw_smp_processor_id();
	struct vcpu_vmx *vmx, *n;

	list_for_each_entry_safe(vmx, n, &per_cpu(vcpus_on_cpu, cpu),
				 local_vcpus_link)
		__vcpu_clear(vmx);
}

1209 1210 1211 1212 1213

/* Just like cpu_vmxoff(), but with the __kvm_handle_fault_on_reboot()
 * tricks.
 */
static void kvm_cpu_vmxoff(void)
A
Avi Kivity 已提交
1214
{
1215
	asm volatile (__ex(ASM_VMX_VMXOFF) : : : "cc");
1216
	write_cr4(read_cr4() & ~X86_CR4_VMXE);
A
Avi Kivity 已提交
1217 1218
}

1219 1220 1221 1222 1223 1224
static void hardware_disable(void *garbage)
{
	vmclear_local_vcpus();
	kvm_cpu_vmxoff();
}

1225
static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt,
M
Mike Day 已提交
1226
				      u32 msr, u32 *result)
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
{
	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 已提交
1238
		return -EIO;
1239 1240 1241 1242 1243

	*result = ctl;
	return 0;
}

Y
Yang, Sheng 已提交
1244
static __init int setup_vmcs_config(struct vmcs_config *vmcs_conf)
A
Avi Kivity 已提交
1245 1246
{
	u32 vmx_msr_low, vmx_msr_high;
S
Sheng Yang 已提交
1247
	u32 min, opt, min2, opt2;
1248 1249
	u32 _pin_based_exec_control = 0;
	u32 _cpu_based_exec_control = 0;
1250
	u32 _cpu_based_2nd_exec_control = 0;
1251 1252 1253 1254
	u32 _vmexit_control = 0;
	u32 _vmentry_control = 0;

	min = PIN_BASED_EXT_INTR_MASK | PIN_BASED_NMI_EXITING;
1255
	opt = PIN_BASED_VIRTUAL_NMIS;
1256 1257
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PINBASED_CTLS,
				&_pin_based_exec_control) < 0)
Y
Yang, Sheng 已提交
1258
		return -EIO;
1259 1260 1261 1262 1263 1264

	min = CPU_BASED_HLT_EXITING |
#ifdef CONFIG_X86_64
	      CPU_BASED_CR8_LOAD_EXITING |
	      CPU_BASED_CR8_STORE_EXITING |
#endif
S
Sheng Yang 已提交
1265 1266
	      CPU_BASED_CR3_LOAD_EXITING |
	      CPU_BASED_CR3_STORE_EXITING |
1267 1268
	      CPU_BASED_USE_IO_BITMAPS |
	      CPU_BASED_MOV_DR_EXITING |
M
Marcelo Tosatti 已提交
1269
	      CPU_BASED_USE_TSC_OFFSETING |
1270 1271
	      CPU_BASED_MWAIT_EXITING |
	      CPU_BASED_MONITOR_EXITING |
M
Marcelo Tosatti 已提交
1272
	      CPU_BASED_INVLPG_EXITING;
1273
	opt = CPU_BASED_TPR_SHADOW |
S
Sheng Yang 已提交
1274
	      CPU_BASED_USE_MSR_BITMAPS |
1275
	      CPU_BASED_ACTIVATE_SECONDARY_CONTROLS;
1276 1277
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PROCBASED_CTLS,
				&_cpu_based_exec_control) < 0)
Y
Yang, Sheng 已提交
1278
		return -EIO;
1279 1280 1281 1282 1283
#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
1284
	if (_cpu_based_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) {
S
Sheng Yang 已提交
1285 1286
		min2 = 0;
		opt2 = SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES |
1287
			SECONDARY_EXEC_WBINVD_EXITING |
S
Sheng Yang 已提交
1288
			SECONDARY_EXEC_ENABLE_VPID |
1289
			SECONDARY_EXEC_ENABLE_EPT |
1290
			SECONDARY_EXEC_UNRESTRICTED_GUEST |
1291 1292
			SECONDARY_EXEC_PAUSE_LOOP_EXITING |
			SECONDARY_EXEC_RDTSCP;
S
Sheng Yang 已提交
1293 1294
		if (adjust_vmx_controls(min2, opt2,
					MSR_IA32_VMX_PROCBASED_CTLS2,
1295 1296 1297 1298 1299 1300 1301 1302
					&_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 已提交
1303
	if (_cpu_based_2nd_exec_control & SECONDARY_EXEC_ENABLE_EPT) {
M
Marcelo Tosatti 已提交
1304 1305
		/* CR3 accesses and invlpg don't need to cause VM Exits when EPT
		   enabled */
1306 1307 1308
		_cpu_based_exec_control &= ~(CPU_BASED_CR3_LOAD_EXITING |
					     CPU_BASED_CR3_STORE_EXITING |
					     CPU_BASED_INVLPG_EXITING);
S
Sheng Yang 已提交
1309 1310 1311
		rdmsr(MSR_IA32_VMX_EPT_VPID_CAP,
		      vmx_capability.ept, vmx_capability.vpid);
	}
1312 1313 1314 1315 1316

	min = 0;
#ifdef CONFIG_X86_64
	min |= VM_EXIT_HOST_ADDR_SPACE_SIZE;
#endif
S
Sheng Yang 已提交
1317
	opt = VM_EXIT_SAVE_IA32_PAT | VM_EXIT_LOAD_IA32_PAT;
1318 1319
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_EXIT_CTLS,
				&_vmexit_control) < 0)
Y
Yang, Sheng 已提交
1320
		return -EIO;
1321

S
Sheng Yang 已提交
1322 1323
	min = 0;
	opt = VM_ENTRY_LOAD_IA32_PAT;
1324 1325
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_ENTRY_CTLS,
				&_vmentry_control) < 0)
Y
Yang, Sheng 已提交
1326
		return -EIO;
A
Avi Kivity 已提交
1327

N
Nguyen Anh Quynh 已提交
1328
	rdmsr(MSR_IA32_VMX_BASIC, vmx_msr_low, vmx_msr_high);
1329 1330 1331

	/* IA-32 SDM Vol 3B: VMCS size is never greater than 4kB. */
	if ((vmx_msr_high & 0x1fff) > PAGE_SIZE)
Y
Yang, Sheng 已提交
1332
		return -EIO;
1333 1334 1335 1336

#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 已提交
1337
		return -EIO;
1338 1339 1340 1341
#endif

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

Y
Yang, Sheng 已提交
1344 1345 1346
	vmcs_conf->size = vmx_msr_high & 0x1fff;
	vmcs_conf->order = get_order(vmcs_config.size);
	vmcs_conf->revision_id = vmx_msr_low;
1347

Y
Yang, Sheng 已提交
1348 1349
	vmcs_conf->pin_based_exec_ctrl = _pin_based_exec_control;
	vmcs_conf->cpu_based_exec_ctrl = _cpu_based_exec_control;
1350
	vmcs_conf->cpu_based_2nd_exec_ctrl = _cpu_based_2nd_exec_control;
Y
Yang, Sheng 已提交
1351 1352
	vmcs_conf->vmexit_ctrl         = _vmexit_control;
	vmcs_conf->vmentry_ctrl        = _vmentry_control;
1353 1354

	return 0;
N
Nguyen Anh Quynh 已提交
1355
}
A
Avi Kivity 已提交
1356 1357 1358 1359 1360 1361 1362

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

1363
	pages = alloc_pages_exact_node(node, GFP_KERNEL, vmcs_config.order);
A
Avi Kivity 已提交
1364 1365 1366
	if (!pages)
		return NULL;
	vmcs = page_address(pages);
1367 1368
	memset(vmcs, 0, vmcs_config.size);
	vmcs->revision_id = vmcs_config.revision_id; /* vmcs revision id */
A
Avi Kivity 已提交
1369 1370 1371 1372 1373
	return vmcs;
}

static struct vmcs *alloc_vmcs(void)
{
1374
	return alloc_vmcs_cpu(raw_smp_processor_id());
A
Avi Kivity 已提交
1375 1376 1377 1378
}

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

1382
static void free_kvm_area(void)
A
Avi Kivity 已提交
1383 1384 1385
{
	int cpu;

Z
Zachary Amsden 已提交
1386
	for_each_possible_cpu(cpu) {
A
Avi Kivity 已提交
1387
		free_vmcs(per_cpu(vmxarea, cpu));
Z
Zachary Amsden 已提交
1388 1389
		per_cpu(vmxarea, cpu) = NULL;
	}
A
Avi Kivity 已提交
1390 1391 1392 1393 1394 1395
}

static __init int alloc_kvm_area(void)
{
	int cpu;

Z
Zachary Amsden 已提交
1396
	for_each_possible_cpu(cpu) {
A
Avi Kivity 已提交
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411
		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 已提交
1412 1413
	if (setup_vmcs_config(&vmcs_config) < 0)
		return -EIO;
1414 1415 1416 1417

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

S
Sheng Yang 已提交
1418 1419 1420
	if (!cpu_has_vmx_vpid())
		enable_vpid = 0;

1421
	if (!cpu_has_vmx_ept()) {
S
Sheng Yang 已提交
1422
		enable_ept = 0;
1423 1424 1425 1426 1427
		enable_unrestricted_guest = 0;
	}

	if (!cpu_has_vmx_unrestricted_guest())
		enable_unrestricted_guest = 0;
S
Sheng Yang 已提交
1428 1429 1430 1431

	if (!cpu_has_vmx_flexpriority())
		flexpriority_enabled = 0;

1432 1433 1434
	if (!cpu_has_vmx_tpr_shadow())
		kvm_x86_ops->update_cr8_intercept = NULL;

1435 1436 1437
	if (enable_ept && !cpu_has_vmx_ept_2m_page())
		kvm_disable_largepages();

1438 1439 1440
	if (!cpu_has_vmx_ple())
		ple_gap = 0;

A
Avi Kivity 已提交
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
	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];

1453
	if (vmcs_readl(sf->base) == save->base && (save->base & AR_S_MASK)) {
A
Avi Kivity 已提交
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
		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;
1468
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Avi Kivity 已提交
1469

1470
	vmx->emulation_required = 1;
1471
	vmx->rmode.vm86_active = 0;
A
Avi Kivity 已提交
1472

1473 1474 1475
	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 已提交
1476 1477

	flags = vmcs_readl(GUEST_RFLAGS);
1478
	flags &= ~(X86_EFLAGS_IOPL | X86_EFLAGS_VM);
1479
	flags |= (vmx->rmode.save_iopl << IOPL_SHIFT);
A
Avi Kivity 已提交
1480 1481
	vmcs_writel(GUEST_RFLAGS, flags);

1482 1483
	vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~X86_CR4_VME) |
			(vmcs_readl(CR4_READ_SHADOW) & X86_CR4_VME));
A
Avi Kivity 已提交
1484 1485 1486

	update_exception_bitmap(vcpu);

1487 1488 1489
	if (emulate_invalid_guest_state)
		return;

1490 1491 1492 1493
	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 已提交
1494 1495 1496 1497 1498 1499 1500 1501 1502

	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 已提交
1503
static gva_t rmode_tss_base(struct kvm *kvm)
A
Avi Kivity 已提交
1504
{
1505
	if (!kvm->arch.tss_addr) {
1506 1507
		gfn_t base_gfn = kvm->memslots->memslots[0].base_gfn +
				 kvm->memslots->memslots[0].npages - 3;
1508 1509
		return base_gfn << PAGE_SHIFT;
	}
1510
	return kvm->arch.tss_addr;
A
Avi Kivity 已提交
1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
}

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);
1521 1522
	vmcs_write16(sf->selector, save->base >> 4);
	vmcs_write32(sf->base, save->base & 0xfffff);
A
Avi Kivity 已提交
1523 1524 1525 1526 1527 1528 1529
	vmcs_write32(sf->limit, 0xffff);
	vmcs_write32(sf->ar_bytes, 0xf3);
}

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

1532 1533 1534
	if (enable_unrestricted_guest)
		return;

1535
	vmx->emulation_required = 1;
1536
	vmx->rmode.vm86_active = 1;
A
Avi Kivity 已提交
1537

1538
	vmx->rmode.tr.base = vmcs_readl(GUEST_TR_BASE);
A
Avi Kivity 已提交
1539 1540
	vmcs_writel(GUEST_TR_BASE, rmode_tss_base(vcpu->kvm));

1541
	vmx->rmode.tr.limit = vmcs_read32(GUEST_TR_LIMIT);
A
Avi Kivity 已提交
1542 1543
	vmcs_write32(GUEST_TR_LIMIT, RMODE_TSS_SIZE - 1);

1544
	vmx->rmode.tr.ar = vmcs_read32(GUEST_TR_AR_BYTES);
A
Avi Kivity 已提交
1545 1546 1547
	vmcs_write32(GUEST_TR_AR_BYTES, 0x008b);

	flags = vmcs_readl(GUEST_RFLAGS);
1548
	vmx->rmode.save_iopl
1549
		= (flags & X86_EFLAGS_IOPL) >> IOPL_SHIFT;
A
Avi Kivity 已提交
1550

1551
	flags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM;
A
Avi Kivity 已提交
1552 1553

	vmcs_writel(GUEST_RFLAGS, flags);
1554
	vmcs_writel(GUEST_CR4, vmcs_readl(GUEST_CR4) | X86_CR4_VME);
A
Avi Kivity 已提交
1555 1556
	update_exception_bitmap(vcpu);

1557 1558 1559
	if (emulate_invalid_guest_state)
		goto continue_rmode;

A
Avi Kivity 已提交
1560 1561 1562 1563 1564
	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);
1565
	vmcs_write32(GUEST_CS_LIMIT, 0xffff);
1566 1567
	if (vmcs_readl(GUEST_CS_BASE) == 0xffff0000)
		vmcs_writel(GUEST_CS_BASE, 0xf0000);
A
Avi Kivity 已提交
1568 1569
	vmcs_write16(GUEST_CS_SELECTOR, vmcs_readl(GUEST_CS_BASE) >> 4);

1570 1571 1572 1573
	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);
1574

1575
continue_rmode:
1576
	kvm_mmu_reset_context(vcpu);
1577
	init_rmode(vcpu->kvm);
A
Avi Kivity 已提交
1578 1579
}

1580 1581 1582
static void vmx_set_efer(struct kvm_vcpu *vcpu, u64 efer)
{
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1583 1584 1585 1586
	struct shared_msr_entry *msr = find_msr_entry(vmx, MSR_EFER);

	if (!msr)
		return;
1587

1588 1589 1590 1591 1592
	/*
	 * 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));
1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610
	vcpu->arch.shadow_efer = efer;
	if (!msr)
		return;
	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);
}

1611
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
1612 1613 1614 1615 1616 1617 1618 1619

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

	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",
1620
		       __func__);
A
Avi Kivity 已提交
1621 1622 1623 1624
		vmcs_write32(GUEST_TR_AR_BYTES,
			     (guest_tr_ar & ~AR_TYPE_MASK)
			     | AR_TYPE_BUSY_64_TSS);
	}
1625
	vcpu->arch.shadow_efer |= EFER_LMA;
1626
	vmx_set_efer(vcpu, vcpu->arch.shadow_efer);
A
Avi Kivity 已提交
1627 1628 1629 1630
}

static void exit_lmode(struct kvm_vcpu *vcpu)
{
1631
	vcpu->arch.shadow_efer &= ~EFER_LMA;
A
Avi Kivity 已提交
1632 1633 1634

	vmcs_write32(VM_ENTRY_CONTROLS,
		     vmcs_read32(VM_ENTRY_CONTROLS)
1635
		     & ~VM_ENTRY_IA32E_MODE);
A
Avi Kivity 已提交
1636 1637 1638 1639
}

#endif

1640 1641 1642
static void vmx_flush_tlb(struct kvm_vcpu *vcpu)
{
	vpid_sync_vcpu_all(to_vmx(vcpu));
1643
	if (enable_ept)
1644
		ept_sync_context(construct_eptp(vcpu->arch.mmu.root_hpa));
1645 1646
}

1647
static void vmx_decache_cr4_guest_bits(struct kvm_vcpu *vcpu)
1648
{
1649 1650 1651 1652
	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;
1653 1654
}

1655 1656
static void ept_load_pdptrs(struct kvm_vcpu *vcpu)
{
A
Avi Kivity 已提交
1657 1658 1659 1660
	if (!test_bit(VCPU_EXREG_PDPTR,
		      (unsigned long *)&vcpu->arch.regs_dirty))
		return;

1661 1662 1663 1664 1665 1666 1667 1668
	if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) {
		vmcs_write64(GUEST_PDPTR0, vcpu->arch.pdptrs[0]);
		vmcs_write64(GUEST_PDPTR1, vcpu->arch.pdptrs[1]);
		vmcs_write64(GUEST_PDPTR2, vcpu->arch.pdptrs[2]);
		vmcs_write64(GUEST_PDPTR3, vcpu->arch.pdptrs[3]);
	}
}

1669 1670 1671 1672 1673 1674 1675 1676
static void ept_save_pdptrs(struct kvm_vcpu *vcpu)
{
	if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) {
		vcpu->arch.pdptrs[0] = vmcs_read64(GUEST_PDPTR0);
		vcpu->arch.pdptrs[1] = vmcs_read64(GUEST_PDPTR1);
		vcpu->arch.pdptrs[2] = vmcs_read64(GUEST_PDPTR2);
		vcpu->arch.pdptrs[3] = vmcs_read64(GUEST_PDPTR3);
	}
A
Avi Kivity 已提交
1677 1678 1679 1680 1681

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

1684 1685 1686 1687 1688 1689 1690 1691 1692
static void vmx_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4);

static void ept_update_paging_mode_cr0(unsigned long *hw_cr0,
					unsigned long cr0,
					struct kvm_vcpu *vcpu)
{
	if (!(cr0 & X86_CR0_PG)) {
		/* From paging/starting to nonpaging */
		vmcs_write32(CPU_BASED_VM_EXEC_CONTROL,
1693
			     vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) |
1694 1695 1696
			     (CPU_BASED_CR3_LOAD_EXITING |
			      CPU_BASED_CR3_STORE_EXITING));
		vcpu->arch.cr0 = cr0;
1697
		vmx_set_cr4(vcpu, kvm_read_cr4(vcpu));
1698 1699 1700
	} else if (!is_paging(vcpu)) {
		/* From nonpaging to paging */
		vmcs_write32(CPU_BASED_VM_EXEC_CONTROL,
1701
			     vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) &
1702 1703 1704
			     ~(CPU_BASED_CR3_LOAD_EXITING |
			       CPU_BASED_CR3_STORE_EXITING));
		vcpu->arch.cr0 = cr0;
1705
		vmx_set_cr4(vcpu, kvm_read_cr4(vcpu));
1706
	}
1707 1708 1709

	if (!(cr0 & X86_CR0_WP))
		*hw_cr0 &= ~X86_CR0_WP;
1710 1711
}

A
Avi Kivity 已提交
1712 1713
static void vmx_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
{
1714
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1715 1716 1717 1718 1719 1720 1721
	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;
1722

1723 1724
	vmx_fpu_deactivate(vcpu);

1725
	if (vmx->rmode.vm86_active && (cr0 & X86_CR0_PE))
A
Avi Kivity 已提交
1726 1727
		enter_pmode(vcpu);

1728
	if (!vmx->rmode.vm86_active && !(cr0 & X86_CR0_PE))
A
Avi Kivity 已提交
1729 1730
		enter_rmode(vcpu);

1731
#ifdef CONFIG_X86_64
1732
	if (vcpu->arch.shadow_efer & EFER_LME) {
1733
		if (!is_paging(vcpu) && (cr0 & X86_CR0_PG))
A
Avi Kivity 已提交
1734
			enter_lmode(vcpu);
1735
		if (is_paging(vcpu) && !(cr0 & X86_CR0_PG))
A
Avi Kivity 已提交
1736 1737 1738 1739
			exit_lmode(vcpu);
	}
#endif

1740
	if (enable_ept)
1741 1742
		ept_update_paging_mode_cr0(&hw_cr0, cr0, vcpu);

A
Avi Kivity 已提交
1743
	vmcs_writel(CR0_READ_SHADOW, cr0);
1744
	vmcs_writel(GUEST_CR0, hw_cr0);
1745
	vcpu->arch.cr0 = cr0;
1746

1747
	if (!(cr0 & X86_CR0_TS) || !(cr0 & X86_CR0_PE))
1748
		vmx_fpu_activate(vcpu);
A
Avi Kivity 已提交
1749 1750
}

1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
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 已提交
1763 1764
static void vmx_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
{
1765 1766 1767 1768
	unsigned long guest_cr3;
	u64 eptp;

	guest_cr3 = cr3;
1769
	if (enable_ept) {
1770 1771 1772
		eptp = construct_eptp(cr3);
		vmcs_write64(EPT_POINTER, eptp);
		guest_cr3 = is_paging(vcpu) ? vcpu->arch.cr3 :
1773
			vcpu->kvm->arch.ept_identity_map_addr;
1774
		ept_load_pdptrs(vcpu);
1775 1776
	}

1777
	vmx_flush_tlb(vcpu);
1778
	vmcs_writel(GUEST_CR3, guest_cr3);
1779
	if (vcpu->arch.cr0 & X86_CR0_PE)
1780
		vmx_fpu_deactivate(vcpu);
A
Avi Kivity 已提交
1781 1782 1783 1784
}

static void vmx_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
{
1785
	unsigned long hw_cr4 = cr4 | (to_vmx(vcpu)->rmode.vm86_active ?
1786 1787
		    KVM_RMODE_VM_CR4_ALWAYS_ON : KVM_PMODE_VM_CR4_ALWAYS_ON);

1788
	vcpu->arch.cr4 = cr4;
1789 1790 1791 1792 1793 1794 1795 1796
	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;
		}
	}
1797 1798 1799

	vmcs_writel(CR4_READ_SHADOW, cr4);
	vmcs_writel(GUEST_CR4, hw_cr4);
A
Avi Kivity 已提交
1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818
}

static u64 vmx_get_segment_base(struct kvm_vcpu *vcpu, int seg)
{
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];

	return vmcs_readl(sf->base);
}

static void vmx_get_segment(struct kvm_vcpu *vcpu,
			    struct kvm_segment *var, int seg)
{
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
	u32 ar;

	var->base = vmcs_readl(sf->base);
	var->limit = vmcs_read32(sf->limit);
	var->selector = vmcs_read16(sf->selector);
	ar = vmcs_read32(sf->ar_bytes);
1819
	if ((ar & AR_UNUSABLE_MASK) && !emulate_invalid_guest_state)
A
Avi Kivity 已提交
1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831
		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;
}

1832 1833 1834 1835 1836 1837 1838 1839
static int vmx_get_cpl(struct kvm_vcpu *vcpu)
{
	if (!(vcpu->arch.cr0 & X86_CR0_PE)) /* if real mode */
		return 0;

	if (vmx_get_rflags(vcpu) & X86_EFLAGS_VM) /* if virtual 8086 */
		return 3;

A
Avi Kivity 已提交
1840
	return vmcs_read16(GUEST_CS_SELECTOR) & 3;
1841 1842
}

1843
static u32 vmx_segment_access_rights(struct kvm_segment *var)
A
Avi Kivity 已提交
1844 1845 1846
{
	u32 ar;

1847
	if (var->unusable)
A
Avi Kivity 已提交
1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858
		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;
	}
1859 1860
	if (ar == 0) /* a 0 value means unusable */
		ar = AR_UNUSABLE_MASK;
1861 1862 1863 1864 1865 1866 1867

	return ar;
}

static void vmx_set_segment(struct kvm_vcpu *vcpu,
			    struct kvm_segment *var, int seg)
{
1868
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1869 1870 1871
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
	u32 ar;

1872 1873 1874 1875 1876
	if (vmx->rmode.vm86_active && seg == VCPU_SREG_TR) {
		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);
1877 1878 1879 1880 1881
		return;
	}
	vmcs_writel(sf->base, var->base);
	vmcs_write32(sf->limit, var->limit);
	vmcs_write16(sf->selector, var->selector);
1882
	if (vmx->rmode.vm86_active && var->s) {
1883 1884 1885 1886 1887 1888 1889 1890
		/*
		 * 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);
1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905

	/*
	 *   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 已提交
1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
	vmcs_write32(sf->ar_bytes, ar);
}

static void vmx_get_cs_db_l_bits(struct kvm_vcpu *vcpu, int *db, int *l)
{
	u32 ar = vmcs_read32(GUEST_CS_AR_BYTES);

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

static void vmx_get_idt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
{
	dt->limit = vmcs_read32(GUEST_IDTR_LIMIT);
	dt->base = vmcs_readl(GUEST_IDTR_BASE);
}

static void vmx_set_idt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
{
	vmcs_write32(GUEST_IDTR_LIMIT, dt->limit);
	vmcs_writel(GUEST_IDTR_BASE, dt->base);
}

static void vmx_get_gdt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
{
	dt->limit = vmcs_read32(GUEST_GDTR_LIMIT);
	dt->base = vmcs_readl(GUEST_GDTR_BASE);
}

static void vmx_set_gdt(struct kvm_vcpu *vcpu, struct descriptor_table *dt)
{
	vmcs_write32(GUEST_GDTR_LIMIT, dt->limit);
	vmcs_writel(GUEST_GDTR_BASE, dt->base);
}

1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966
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;

1967 1968
	if (cs.unusable)
		return false;
1969 1970 1971 1972
	if (~cs.type & (AR_TYPE_CODE_MASK|AR_TYPE_ACCESSES_MASK))
		return false;
	if (!cs.s)
		return false;
1973
	if (cs.type & AR_TYPE_WRITEABLE_MASK) {
1974 1975
		if (cs.dpl > cs_rpl)
			return false;
1976
	} else {
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994
		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;

1995 1996 1997
	if (ss.unusable)
		return true;
	if (ss.type != 3 && ss.type != 7)
1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
		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;

2017 2018
	if (var.unusable)
		return true;
2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
	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);

2040 2041
	if (tr.unusable)
		return false;
2042 2043
	if (tr.selector & SELECTOR_TI_MASK)	/* TI = 1 */
		return false;
2044
	if (tr.type != 3 && tr.type != 11) /* TODO: Check if guest is in IA32e mode */
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057
		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);

2058 2059
	if (ldtr.unusable)
		return true;
2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130
	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 */
	if (!(vcpu->arch.cr0 & X86_CR0_PE)) {
		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 已提交
2131
static int init_rmode_tss(struct kvm *kvm)
A
Avi Kivity 已提交
2132 2133
{
	gfn_t fn = rmode_tss_base(kvm) >> PAGE_SHIFT;
2134
	u16 data = 0;
2135
	int ret = 0;
2136
	int r;
A
Avi Kivity 已提交
2137

2138 2139
	r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
	if (r < 0)
2140
		goto out;
2141
	data = TSS_BASE_SIZE + TSS_REDIRECTION_SIZE;
2142 2143
	r = kvm_write_guest_page(kvm, fn++, &data,
			TSS_IOPB_BASE_OFFSET, sizeof(u16));
2144
	if (r < 0)
2145
		goto out;
2146 2147
	r = kvm_clear_guest_page(kvm, fn++, 0, PAGE_SIZE);
	if (r < 0)
2148
		goto out;
2149 2150
	r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
	if (r < 0)
2151
		goto out;
2152
	data = ~0;
2153 2154 2155
	r = kvm_write_guest_page(kvm, fn, &data,
				 RMODE_TSS_SIZE - 2 * PAGE_SIZE - 1,
				 sizeof(u8));
2156
	if (r < 0)
2157 2158 2159 2160 2161
		goto out;

	ret = 1;
out:
	return ret;
A
Avi Kivity 已提交
2162 2163
}

2164 2165 2166 2167 2168 2169
static int init_rmode_identity_map(struct kvm *kvm)
{
	int i, r, ret;
	pfn_t identity_map_pfn;
	u32 tmp;

2170
	if (!enable_ept)
2171 2172 2173 2174 2175 2176 2177 2178 2179
		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;
2180
	identity_map_pfn = kvm->arch.ept_identity_map_addr >> PAGE_SHIFT;
2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
	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:
	return ret;
}

A
Avi Kivity 已提交
2199 2200 2201
static void seg_setup(int seg)
{
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
2202
	unsigned int ar;
A
Avi Kivity 已提交
2203 2204 2205 2206

	vmcs_write16(sf->selector, 0);
	vmcs_writel(sf->base, 0);
	vmcs_write32(sf->limit, 0xffff);
2207 2208 2209 2210 2211 2212 2213 2214
	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 已提交
2215 2216
}

2217 2218 2219 2220 2221
static int alloc_apic_access_page(struct kvm *kvm)
{
	struct kvm_userspace_memory_region kvm_userspace_mem;
	int r = 0;

2222
	down_write(&kvm->slots_lock);
2223
	if (kvm->arch.apic_access_page)
2224 2225 2226 2227 2228 2229 2230 2231
		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;
2232

2233
	kvm->arch.apic_access_page = gfn_to_page(kvm, 0xfee00);
2234
out:
2235
	up_write(&kvm->slots_lock);
2236 2237 2238
	return r;
}

2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
static int alloc_identity_pagetable(struct kvm *kvm)
{
	struct kvm_userspace_memory_region kvm_userspace_mem;
	int r = 0;

	down_write(&kvm->slots_lock);
	if (kvm->arch.ept_identity_pagetable)
		goto out;
	kvm_userspace_mem.slot = IDENTITY_PAGETABLE_PRIVATE_MEMSLOT;
	kvm_userspace_mem.flags = 0;
2249 2250
	kvm_userspace_mem.guest_phys_addr =
		kvm->arch.ept_identity_map_addr;
2251 2252 2253 2254 2255 2256
	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,
2257
			kvm->arch.ept_identity_map_addr >> PAGE_SHIFT);
2258 2259 2260 2261 2262
out:
	up_write(&kvm->slots_lock);
	return r;
}

2263 2264 2265 2266 2267
static void allocate_vpid(struct vcpu_vmx *vmx)
{
	int vpid;

	vmx->vpid = 0;
2268
	if (!enable_vpid)
2269 2270 2271 2272 2273 2274 2275 2276 2277 2278
		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);
}

2279
static void __vmx_disable_intercept_for_msr(unsigned long *msr_bitmap, u32 msr)
S
Sheng Yang 已提交
2280
{
2281
	int f = sizeof(unsigned long);
S
Sheng Yang 已提交
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291

	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) {
2292 2293
		__clear_bit(msr, msr_bitmap + 0x000 / f); /* read-low */
		__clear_bit(msr, msr_bitmap + 0x800 / f); /* write-low */
S
Sheng Yang 已提交
2294 2295
	} else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) {
		msr &= 0x1fff;
2296 2297
		__clear_bit(msr, msr_bitmap + 0x400 / f); /* read-high */
		__clear_bit(msr, msr_bitmap + 0xc00 / f); /* write-high */
S
Sheng Yang 已提交
2298 2299 2300
	}
}

2301 2302 2303 2304 2305 2306 2307
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 已提交
2308 2309 2310
/*
 * Sets up the vmcs for emulated real mode.
 */
R
Rusty Russell 已提交
2311
static int vmx_vcpu_setup(struct vcpu_vmx *vmx)
A
Avi Kivity 已提交
2312
{
S
Sheng Yang 已提交
2313
	u32 host_sysenter_cs, msr_low, msr_high;
A
Avi Kivity 已提交
2314
	u32 junk;
2315
	u64 host_pat, tsc_this, tsc_base;
A
Avi Kivity 已提交
2316 2317 2318
	unsigned long a;
	struct descriptor_table dt;
	int i;
2319
	unsigned long kvm_vmx_return;
2320
	u32 exec_control;
A
Avi Kivity 已提交
2321 2322

	/* I/O */
2323 2324
	vmcs_write64(IO_BITMAP_A, __pa(vmx_io_bitmap_a));
	vmcs_write64(IO_BITMAP_B, __pa(vmx_io_bitmap_b));
A
Avi Kivity 已提交
2325

S
Sheng Yang 已提交
2326
	if (cpu_has_vmx_msr_bitmap())
2327
		vmcs_write64(MSR_BITMAP, __pa(vmx_msr_bitmap_legacy));
S
Sheng Yang 已提交
2328

A
Avi Kivity 已提交
2329 2330 2331
	vmcs_write64(VMCS_LINK_POINTER, -1ull); /* 22.3.1.5 */

	/* Control */
2332 2333
	vmcs_write32(PIN_BASED_VM_EXEC_CONTROL,
		vmcs_config.pin_based_exec_ctrl);
2334 2335 2336 2337 2338 2339 2340 2341 2342

	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
	}
2343
	if (!enable_ept)
S
Sheng Yang 已提交
2344
		exec_control |= CPU_BASED_CR3_STORE_EXITING |
2345 2346
				CPU_BASED_CR3_LOAD_EXITING  |
				CPU_BASED_INVLPG_EXITING;
2347
	vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, exec_control);
A
Avi Kivity 已提交
2348

2349 2350 2351 2352 2353
	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;
2354 2355
		if (vmx->vpid == 0)
			exec_control &= ~SECONDARY_EXEC_ENABLE_VPID;
2356
		if (!enable_ept) {
S
Sheng Yang 已提交
2357
			exec_control &= ~SECONDARY_EXEC_ENABLE_EPT;
2358 2359
			enable_unrestricted_guest = 0;
		}
2360 2361
		if (!enable_unrestricted_guest)
			exec_control &= ~SECONDARY_EXEC_UNRESTRICTED_GUEST;
2362 2363
		if (!ple_gap)
			exec_control &= ~SECONDARY_EXEC_PAUSE_LOOP_EXITING;
2364 2365
		vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control);
	}
2366

2367 2368 2369 2370 2371
	if (ple_gap) {
		vmcs_write32(PLE_GAP, ple_gap);
		vmcs_write32(PLE_WINDOW, ple_window);
	}

2372 2373
	vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, !!bypass_guest_pf);
	vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, !!bypass_guest_pf);
A
Avi Kivity 已提交
2374 2375 2376 2377 2378 2379 2380 2381 2382
	vmcs_write32(CR3_TARGET_COUNT, 0);           /* 22.2.1 */

	vmcs_writel(HOST_CR0, read_cr0());  /* 22.2.3 */
	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 */
2383 2384
	vmcs_write16(HOST_FS_SELECTOR, kvm_read_fs());    /* 22.2.4 */
	vmcs_write16(HOST_GS_SELECTOR, kvm_read_gs());    /* 22.2.4 */
A
Avi Kivity 已提交
2385
	vmcs_write16(HOST_SS_SELECTOR, __KERNEL_DS);  /* 22.2.4 */
2386
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397
	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 */

2398
	kvm_get_idt(&dt);
A
Avi Kivity 已提交
2399 2400
	vmcs_writel(HOST_IDTR_BASE, dt.base);   /* 22.2.4 */

M
Mike Day 已提交
2401
	asm("mov $.Lkvm_vmx_return, %0" : "=r"(kvm_vmx_return));
2402
	vmcs_writel(HOST_RIP, kvm_vmx_return); /* 22.2.5 */
2403 2404 2405
	vmcs_write32(VM_EXIT_MSR_STORE_COUNT, 0);
	vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, 0);
	vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, 0);
A
Avi Kivity 已提交
2406 2407 2408 2409 2410 2411 2412 2413

	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 已提交
2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427
	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 已提交
2428 2429 2430
	for (i = 0; i < NR_VMX_MSR; ++i) {
		u32 index = vmx_msr_index[i];
		u32 data_low, data_high;
2431
		int j = vmx->nmsrs;
A
Avi Kivity 已提交
2432 2433 2434

		if (rdmsr_safe(index, &data_low, &data_high) < 0)
			continue;
2435 2436
		if (wrmsr_safe(index, data_low, data_high) < 0)
			continue;
2437 2438
		vmx->guest_msrs[j].index = i;
		vmx->guest_msrs[j].data = 0;
2439
		vmx->guest_msrs[j].mask = -1ull;
2440
		++vmx->nmsrs;
A
Avi Kivity 已提交
2441 2442
	}

2443
	vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl);
A
Avi Kivity 已提交
2444 2445

	/* 22.2.1, 20.8.1 */
2446 2447
	vmcs_write32(VM_ENTRY_CONTROLS, vmcs_config.vmentry_ctrl);

2448
	vmcs_writel(CR0_GUEST_HOST_MASK, ~0UL);
2449
	vmx->vcpu.arch.cr4_guest_owned_bits = KVM_CR4_GUEST_OWNED_BITS;
2450 2451
	if (enable_ept)
		vmx->vcpu.arch.cr4_guest_owned_bits |= X86_CR4_PGE;
2452
	vmcs_writel(CR4_GUEST_HOST_MASK, ~vmx->vcpu.arch.cr4_guest_owned_bits);
2453

2454 2455 2456 2457 2458 2459
	tsc_base = vmx->vcpu.kvm->arch.vm_init_tsc;
	rdtscll(tsc_this);
	if (tsc_this < vmx->vcpu.kvm->arch.vm_init_tsc)
		tsc_base = tsc_this;

	guest_write_tsc(0, tsc_base);
2460

2461 2462 2463
	return 0;
}

2464 2465 2466 2467 2468 2469 2470 2471 2472
static int init_rmode(struct kvm *kvm)
{
	if (!init_rmode_tss(kvm))
		return 0;
	if (!init_rmode_identity_map(kvm))
		return 0;
	return 1;
}

2473 2474 2475 2476 2477 2478
static int vmx_vcpu_reset(struct kvm_vcpu *vcpu)
{
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	u64 msr;
	int ret;

2479
	vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) | (1 << VCPU_REGS_RSP));
2480
	down_read(&vcpu->kvm->slots_lock);
2481
	if (!init_rmode(vmx->vcpu.kvm)) {
2482 2483 2484 2485
		ret = -ENOMEM;
		goto out;
	}

2486
	vmx->rmode.vm86_active = 0;
2487

2488 2489
	vmx->soft_vnmi_blocked = 0;

2490
	vmx->vcpu.arch.regs[VCPU_REGS_RDX] = get_rdx_init_val();
2491
	kvm_set_cr8(&vmx->vcpu, 0);
2492
	msr = 0xfee00000 | MSR_IA32_APICBASE_ENABLE;
2493
	if (kvm_vcpu_is_bsp(&vmx->vcpu))
2494 2495 2496 2497 2498
		msr |= MSR_IA32_APICBASE_BSP;
	kvm_set_apic_base(&vmx->vcpu, msr);

	fx_init(&vmx->vcpu);

2499
	seg_setup(VCPU_SREG_CS);
2500 2501 2502 2503
	/*
	 * GUEST_CS_BASE should really be 0xffff0000, but VT vm86 mode
	 * insists on having GUEST_CS_BASE == GUEST_CS_SELECTOR << 4.  Sigh.
	 */
2504
	if (kvm_vcpu_is_bsp(&vmx->vcpu)) {
2505 2506 2507
		vmcs_write16(GUEST_CS_SELECTOR, 0xf000);
		vmcs_writel(GUEST_CS_BASE, 0x000f0000);
	} else {
2508 2509
		vmcs_write16(GUEST_CS_SELECTOR, vmx->vcpu.arch.sipi_vector << 8);
		vmcs_writel(GUEST_CS_BASE, vmx->vcpu.arch.sipi_vector << 12);
2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532
	}

	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);
2533
	if (kvm_vcpu_is_bsp(&vmx->vcpu))
2534
		kvm_rip_write(vcpu, 0xfff0);
2535
	else
2536 2537
		kvm_rip_write(vcpu, 0);
	kvm_register_write(vcpu, VCPU_REGS_RSP, 0);
2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555

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

	vmcs_write32(GUEST_ACTIVITY_STATE, 0);
	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 已提交
2556 2557
	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0);  /* 22.2.1 */

2558 2559 2560 2561
	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,
2562
				page_to_phys(vmx->vcpu.arch.apic->regs_page));
2563 2564 2565 2566 2567
		vmcs_write32(TPR_THRESHOLD, 0);
	}

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

2570 2571 2572
	if (vmx->vpid != 0)
		vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid);

2573
	vmx->vcpu.arch.cr0 = X86_CR0_NW | X86_CR0_CD | X86_CR0_ET;
2574
	vmx_set_cr0(&vmx->vcpu, vmx->vcpu.arch.cr0); /* enter rmode */
R
Rusty Russell 已提交
2575 2576 2577 2578
	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 已提交
2579

2580 2581
	vpid_sync_vcpu_all(vmx);

2582
	ret = 0;
A
Avi Kivity 已提交
2583

2584 2585 2586
	/* HACK: Don't enable emulation on guest boot/reset */
	vmx->emulation_required = 0;

A
Avi Kivity 已提交
2587
out:
2588
	up_read(&vcpu->kvm->slots_lock);
A
Avi Kivity 已提交
2589 2590 2591
	return ret;
}

2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614
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;
	}

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

2615
static void vmx_inject_irq(struct kvm_vcpu *vcpu)
2616
{
2617
	struct vcpu_vmx *vmx = to_vmx(vcpu);
2618 2619
	uint32_t intr;
	int irq = vcpu->arch.interrupt.nr;
2620

2621
	trace_kvm_inj_virq(irq);
F
Feng (Eric) Liu 已提交
2622

2623
	++vcpu->stat.irq_injections;
2624
	if (vmx->rmode.vm86_active) {
2625 2626
		vmx->rmode.irq.pending = true;
		vmx->rmode.irq.vector = irq;
2627
		vmx->rmode.irq.rip = kvm_rip_read(vcpu);
2628 2629 2630
		if (vcpu->arch.interrupt.soft)
			vmx->rmode.irq.rip +=
				vmx->vcpu.arch.event_exit_inst_len;
2631 2632 2633
		vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
			     irq | INTR_TYPE_SOFT_INTR | INTR_INFO_VALID_MASK);
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, 1);
2634
		kvm_rip_write(vcpu, vmx->rmode.irq.rip - 1);
2635 2636
		return;
	}
2637 2638 2639 2640 2641 2642 2643 2644
	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);
2645 2646
}

2647 2648
static void vmx_inject_nmi(struct kvm_vcpu *vcpu)
{
J
Jan Kiszka 已提交
2649 2650
	struct vcpu_vmx *vmx = to_vmx(vcpu);

2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663
	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;
	}

2664
	++vcpu->stat.nmi_injections;
2665
	if (vmx->rmode.vm86_active) {
J
Jan Kiszka 已提交
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675
		vmx->rmode.irq.pending = true;
		vmx->rmode.irq.vector = NMI_VECTOR;
		vmx->rmode.irq.rip = kvm_rip_read(vcpu);
		vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
			     NMI_VECTOR | INTR_TYPE_SOFT_INTR |
			     INTR_INFO_VALID_MASK);
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, 1);
		kvm_rip_write(vcpu, vmx->rmode.irq.rip - 1);
		return;
	}
2676 2677 2678 2679
	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
			INTR_TYPE_NMI_INTR | INTR_INFO_VALID_MASK | NMI_VECTOR);
}

2680
static int vmx_nmi_allowed(struct kvm_vcpu *vcpu)
2681
{
2682
	if (!cpu_has_virtual_nmis() && to_vmx(vcpu)->soft_vnmi_blocked)
2683
		return 0;
2684

2685 2686 2687
	return	!(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
			(GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS |
				GUEST_INTR_STATE_NMI));
2688 2689
}

J
Jan Kiszka 已提交
2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717
static bool vmx_get_nmi_mask(struct kvm_vcpu *vcpu)
{
	if (!cpu_has_virtual_nmis())
		return to_vmx(vcpu)->soft_vnmi_blocked;
	else
		return !!(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
			  GUEST_INTR_STATE_NMI);
}

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 {
		if (masked)
			vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
				      GUEST_INTR_STATE_NMI);
		else
			vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO,
					GUEST_INTR_STATE_NMI);
	}
}

2718 2719
static int vmx_interrupt_allowed(struct kvm_vcpu *vcpu)
{
2720 2721 2722
	return (vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) &&
		!(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
			(GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS));
2723 2724
}

2725 2726 2727 2728
static int vmx_set_tss_addr(struct kvm *kvm, unsigned int addr)
{
	int ret;
	struct kvm_userspace_memory_region tss_mem = {
2729
		.slot = TSS_PRIVATE_MEMSLOT,
2730 2731 2732 2733 2734 2735 2736 2737
		.guest_phys_addr = addr,
		.memory_size = PAGE_SIZE * 3,
		.flags = 0,
	};

	ret = kvm_set_memory_region(kvm, &tss_mem, 0);
	if (ret)
		return ret;
2738
	kvm->arch.tss_addr = addr;
2739 2740 2741
	return 0;
}

A
Avi Kivity 已提交
2742 2743 2744
static int handle_rmode_exception(struct kvm_vcpu *vcpu,
				  int vec, u32 err_code)
{
2745 2746 2747 2748 2749
	/*
	 * 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)
A
Avi Kivity 已提交
2750
		if (emulate_instruction(vcpu, 0, 0, 0) == EMULATE_DONE)
A
Avi Kivity 已提交
2751
			return 1;
2752 2753 2754 2755 2756 2757 2758
	/*
	 * 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 已提交
2759 2760 2761 2762 2763
		if (vcpu->guest_debug &
		    (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP))
			return 0;
		kvm_queue_exception(vcpu, vec);
		return 1;
2764
	case BP_VECTOR:
J
Jan Kiszka 已提交
2765 2766 2767 2768
		if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP)
			return 0;
		/* fall through */
	case DE_VECTOR:
2769 2770 2771 2772 2773 2774 2775 2776 2777 2778
	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 已提交
2779 2780 2781
	return 0;
}

A
Andi Kleen 已提交
2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
/*
 * 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 已提交
2801
static int handle_machine_check(struct kvm_vcpu *vcpu)
A
Andi Kleen 已提交
2802 2803 2804 2805 2806
{
	/* already handled by vcpu_run */
	return 1;
}

A
Avi Kivity 已提交
2807
static int handle_exception(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
2808
{
2809
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Avi Kivity 已提交
2810
	struct kvm_run *kvm_run = vcpu->run;
J
Jan Kiszka 已提交
2811
	u32 intr_info, ex_no, error_code;
2812
	unsigned long cr2, rip, dr6;
A
Avi Kivity 已提交
2813 2814 2815
	u32 vect_info;
	enum emulation_result er;

2816
	vect_info = vmx->idt_vectoring_info;
A
Avi Kivity 已提交
2817 2818
	intr_info = vmcs_read32(VM_EXIT_INTR_INFO);

A
Andi Kleen 已提交
2819
	if (is_machine_check(intr_info))
A
Avi Kivity 已提交
2820
		return handle_machine_check(vcpu);
A
Andi Kleen 已提交
2821

A
Avi Kivity 已提交
2822
	if ((vect_info & VECTORING_INFO_VALID_MASK) &&
2823 2824 2825 2826 2827 2828 2829 2830
	    !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 已提交
2831

2832
	if ((intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR)
2833
		return 1;  /* already handled by vmx_vcpu_run() */
2834 2835

	if (is_no_device(intr_info)) {
2836
		vmx_fpu_activate(vcpu);
2837 2838 2839
		return 1;
	}

2840
	if (is_invalid_opcode(intr_info)) {
A
Avi Kivity 已提交
2841
		er = emulate_instruction(vcpu, 0, 0, EMULTYPE_TRAP_UD);
2842
		if (er != EMULATE_DONE)
2843
			kvm_queue_exception(vcpu, UD_VECTOR);
2844 2845 2846
		return 1;
	}

A
Avi Kivity 已提交
2847
	error_code = 0;
2848
	rip = kvm_rip_read(vcpu);
2849
	if (intr_info & INTR_INFO_DELIVER_CODE_MASK)
A
Avi Kivity 已提交
2850 2851
		error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE);
	if (is_page_fault(intr_info)) {
2852
		/* EPT won't cause page fault directly */
2853
		if (enable_ept)
2854
			BUG();
A
Avi Kivity 已提交
2855
		cr2 = vmcs_readl(EXIT_QUALIFICATION);
2856 2857
		trace_kvm_page_fault(cr2, error_code);

2858
		if (kvm_event_needs_reinjection(vcpu))
2859
			kvm_mmu_unprotect_page_virt(vcpu, cr2);
2860
		return kvm_mmu_page_fault(vcpu, cr2, error_code);
A
Avi Kivity 已提交
2861 2862
	}

2863
	if (vmx->rmode.vm86_active &&
A
Avi Kivity 已提交
2864
	    handle_rmode_exception(vcpu, intr_info & INTR_INFO_VECTOR_MASK,
2865
								error_code)) {
2866 2867
		if (vcpu->arch.halt_request) {
			vcpu->arch.halt_request = 0;
2868 2869
			return kvm_emulate_halt(vcpu);
		}
A
Avi Kivity 已提交
2870
		return 1;
2871
	}
A
Avi Kivity 已提交
2872

J
Jan Kiszka 已提交
2873
	ex_no = intr_info & INTR_INFO_VECTOR_MASK;
2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886
	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:
A
Avi Kivity 已提交
2887
		kvm_run->exit_reason = KVM_EXIT_DEBUG;
J
Jan Kiszka 已提交
2888 2889
		kvm_run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + rip;
		kvm_run->debug.arch.exception = ex_no;
2890 2891
		break;
	default:
J
Jan Kiszka 已提交
2892 2893 2894
		kvm_run->exit_reason = KVM_EXIT_EXCEPTION;
		kvm_run->ex.exception = ex_no;
		kvm_run->ex.error_code = error_code;
2895
		break;
A
Avi Kivity 已提交
2896 2897 2898 2899
	}
	return 0;
}

A
Avi Kivity 已提交
2900
static int handle_external_interrupt(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
2901
{
A
Avi Kivity 已提交
2902
	++vcpu->stat.irq_exits;
A
Avi Kivity 已提交
2903 2904 2905
	return 1;
}

A
Avi Kivity 已提交
2906
static int handle_triple_fault(struct kvm_vcpu *vcpu)
2907
{
A
Avi Kivity 已提交
2908
	vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
2909 2910
	return 0;
}
A
Avi Kivity 已提交
2911

A
Avi Kivity 已提交
2912
static int handle_io(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
2913
{
2914
	unsigned long exit_qualification;
2915
	int size, in, string;
2916
	unsigned port;
A
Avi Kivity 已提交
2917

A
Avi Kivity 已提交
2918
	++vcpu->stat.io_exits;
2919
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
2920
	string = (exit_qualification & 16) != 0;
2921 2922

	if (string) {
A
Avi Kivity 已提交
2923
		if (emulate_instruction(vcpu, 0, 0, 0) == EMULATE_DO_MMIO)
2924 2925 2926 2927 2928 2929
			return 0;
		return 1;
	}

	size = (exit_qualification & 7) + 1;
	in = (exit_qualification & 8) != 0;
2930
	port = exit_qualification >> 16;
2931

2932
	skip_emulated_instruction(vcpu);
A
Avi Kivity 已提交
2933
	return kvm_emulate_pio(vcpu, in, size, port);
A
Avi Kivity 已提交
2934 2935
}

I
Ingo Molnar 已提交
2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
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 已提交
2947
static int handle_cr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
2948
{
2949
	unsigned long exit_qualification, val;
A
Avi Kivity 已提交
2950 2951 2952
	int cr;
	int reg;

2953
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
A
Avi Kivity 已提交
2954 2955 2956 2957
	cr = exit_qualification & 15;
	reg = (exit_qualification >> 8) & 15;
	switch ((exit_qualification >> 4) & 3) {
	case 0: /* mov to cr */
2958 2959
		val = kvm_register_read(vcpu, reg);
		trace_kvm_cr_write(cr, val);
A
Avi Kivity 已提交
2960 2961
		switch (cr) {
		case 0:
2962
			kvm_set_cr0(vcpu, val);
A
Avi Kivity 已提交
2963 2964 2965
			skip_emulated_instruction(vcpu);
			return 1;
		case 3:
2966
			kvm_set_cr3(vcpu, val);
A
Avi Kivity 已提交
2967 2968 2969
			skip_emulated_instruction(vcpu);
			return 1;
		case 4:
2970
			kvm_set_cr4(vcpu, val);
A
Avi Kivity 已提交
2971 2972
			skip_emulated_instruction(vcpu);
			return 1;
2973 2974 2975 2976 2977 2978 2979 2980 2981
		case 8: {
				u8 cr8_prev = kvm_get_cr8(vcpu);
				u8 cr8 = kvm_register_read(vcpu, reg);
				kvm_set_cr8(vcpu, cr8);
				skip_emulated_instruction(vcpu);
				if (irqchip_in_kernel(vcpu->kvm))
					return 1;
				if (cr8_prev <= cr8)
					return 1;
A
Avi Kivity 已提交
2982
				vcpu->run->exit_reason = KVM_EXIT_SET_TPR;
2983 2984
				return 0;
			}
A
Avi Kivity 已提交
2985 2986
		};
		break;
2987
	case 2: /* clts */
2988
		vmx_fpu_deactivate(vcpu);
2989 2990
		vcpu->arch.cr0 &= ~X86_CR0_TS;
		vmcs_writel(CR0_READ_SHADOW, vcpu->arch.cr0);
2991
		vmx_fpu_activate(vcpu);
2992 2993
		skip_emulated_instruction(vcpu);
		return 1;
A
Avi Kivity 已提交
2994 2995 2996
	case 1: /*mov from cr*/
		switch (cr) {
		case 3:
2997
			kvm_register_write(vcpu, reg, vcpu->arch.cr3);
2998
			trace_kvm_cr_read(cr, vcpu->arch.cr3);
A
Avi Kivity 已提交
2999 3000 3001
			skip_emulated_instruction(vcpu);
			return 1;
		case 8:
3002 3003 3004
			val = kvm_get_cr8(vcpu);
			kvm_register_write(vcpu, reg, val);
			trace_kvm_cr_read(cr, val);
A
Avi Kivity 已提交
3005 3006 3007 3008 3009
			skip_emulated_instruction(vcpu);
			return 1;
		}
		break;
	case 3: /* lmsw */
3010
		kvm_lmsw(vcpu, (exit_qualification >> LMSW_SOURCE_DATA_SHIFT) & 0x0f);
A
Avi Kivity 已提交
3011 3012 3013 3014 3015 3016

		skip_emulated_instruction(vcpu);
		return 1;
	default:
		break;
	}
A
Avi Kivity 已提交
3017
	vcpu->run->exit_reason = 0;
3018
	pr_unimpl(vcpu, "unhandled control register: op %d cr %d\n",
A
Avi Kivity 已提交
3019 3020 3021 3022
	       (int)(exit_qualification >> 4) & 3, cr);
	return 0;
}

A
Avi Kivity 已提交
3023
static int handle_dr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3024
{
3025
	unsigned long exit_qualification;
A
Avi Kivity 已提交
3026 3027 3028
	unsigned long val;
	int dr, reg;

3029 3030
	if (!kvm_require_cpl(vcpu, 0))
		return 1;
3031 3032 3033 3034 3035 3036 3037 3038
	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 已提交
3039 3040 3041
			vcpu->run->debug.arch.dr6 = vcpu->arch.dr6;
			vcpu->run->debug.arch.dr7 = dr;
			vcpu->run->debug.arch.pc =
3042 3043
				vmcs_readl(GUEST_CS_BASE) +
				vmcs_readl(GUEST_RIP);
A
Avi Kivity 已提交
3044 3045
			vcpu->run->debug.arch.exception = DB_VECTOR;
			vcpu->run->exit_reason = KVM_EXIT_DEBUG;
3046 3047 3048 3049 3050 3051 3052 3053 3054 3055
			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;
		}
	}

3056
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
3057 3058 3059
	dr = exit_qualification & DEBUG_REG_ACCESS_NUM;
	reg = DEBUG_REG_ACCESS_REG(exit_qualification);
	if (exit_qualification & TYPE_MOV_FROM_DR) {
A
Avi Kivity 已提交
3060
		switch (dr) {
3061 3062 3063
		case 0 ... 3:
			val = vcpu->arch.db[dr];
			break;
A
Avi Kivity 已提交
3064
		case 6:
3065
			val = vcpu->arch.dr6;
A
Avi Kivity 已提交
3066 3067
			break;
		case 7:
3068
			val = vcpu->arch.dr7;
A
Avi Kivity 已提交
3069 3070 3071 3072
			break;
		default:
			val = 0;
		}
3073
		kvm_register_write(vcpu, reg, val);
A
Avi Kivity 已提交
3074
	} else {
3075 3076 3077 3078 3079 3080 3081 3082
		val = vcpu->arch.regs[reg];
		switch (dr) {
		case 0 ... 3:
			vcpu->arch.db[dr] = val;
			if (!(vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP))
				vcpu->arch.eff_db[dr] = val;
			break;
		case 4 ... 5:
3083
			if (kvm_read_cr4_bits(vcpu, X86_CR4_DE))
3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
				kvm_queue_exception(vcpu, UD_VECTOR);
			break;
		case 6:
			if (val & 0xffffffff00000000ULL) {
				kvm_queue_exception(vcpu, GP_VECTOR);
				break;
			}
			vcpu->arch.dr6 = (val & DR6_VOLATILE) | DR6_FIXED_1;
			break;
		case 7:
			if (val & 0xffffffff00000000ULL) {
				kvm_queue_exception(vcpu, GP_VECTOR);
				break;
			}
			vcpu->arch.dr7 = (val & DR7_VOLATILE) | DR7_FIXED_1;
			if (!(vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP)) {
				vmcs_writel(GUEST_DR7, vcpu->arch.dr7);
				vcpu->arch.switch_db_regs =
					(val & DR7_BP_EN_MASK);
			}
			break;
		}
A
Avi Kivity 已提交
3106 3107 3108 3109 3110
	}
	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3111
static int handle_cpuid(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3112
{
3113 3114
	kvm_emulate_cpuid(vcpu);
	return 1;
A
Avi Kivity 已提交
3115 3116
}

A
Avi Kivity 已提交
3117
static int handle_rdmsr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3118
{
3119
	u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX];
A
Avi Kivity 已提交
3120 3121 3122
	u64 data;

	if (vmx_get_msr(vcpu, ecx, &data)) {
3123
		kvm_inject_gp(vcpu, 0);
A
Avi Kivity 已提交
3124 3125 3126
		return 1;
	}

3127
	trace_kvm_msr_read(ecx, data);
F
Feng (Eric) Liu 已提交
3128

A
Avi Kivity 已提交
3129
	/* FIXME: handling of bits 32:63 of rax, rdx */
3130 3131
	vcpu->arch.regs[VCPU_REGS_RAX] = data & -1u;
	vcpu->arch.regs[VCPU_REGS_RDX] = (data >> 32) & -1u;
A
Avi Kivity 已提交
3132 3133 3134 3135
	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3136
static int handle_wrmsr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3137
{
3138 3139 3140
	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 已提交
3141

3142
	trace_kvm_msr_write(ecx, data);
F
Feng (Eric) Liu 已提交
3143

A
Avi Kivity 已提交
3144
	if (vmx_set_msr(vcpu, ecx, data) != 0) {
3145
		kvm_inject_gp(vcpu, 0);
A
Avi Kivity 已提交
3146 3147 3148 3149 3150 3151 3152
		return 1;
	}

	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3153
static int handle_tpr_below_threshold(struct kvm_vcpu *vcpu)
3154 3155 3156 3157
{
	return 1;
}

A
Avi Kivity 已提交
3158
static int handle_interrupt_window(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3159
{
3160 3161 3162 3163 3164 3165
	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 已提交
3166

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

3169 3170 3171 3172
	/*
	 * If the user space waits to inject interrupts, exit as soon as
	 * possible
	 */
3173
	if (!irqchip_in_kernel(vcpu->kvm) &&
A
Avi Kivity 已提交
3174
	    vcpu->run->request_interrupt_window &&
3175
	    !kvm_cpu_has_interrupt(vcpu)) {
A
Avi Kivity 已提交
3176
		vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
3177 3178
		return 0;
	}
A
Avi Kivity 已提交
3179 3180 3181
	return 1;
}

A
Avi Kivity 已提交
3182
static int handle_halt(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3183 3184
{
	skip_emulated_instruction(vcpu);
3185
	return kvm_emulate_halt(vcpu);
A
Avi Kivity 已提交
3186 3187
}

A
Avi Kivity 已提交
3188
static int handle_vmcall(struct kvm_vcpu *vcpu)
3189
{
3190
	skip_emulated_instruction(vcpu);
3191 3192
	kvm_emulate_hypercall(vcpu);
	return 1;
3193 3194
}

A
Avi Kivity 已提交
3195
static int handle_vmx_insn(struct kvm_vcpu *vcpu)
3196 3197 3198 3199 3200
{
	kvm_queue_exception(vcpu, UD_VECTOR);
	return 1;
}

A
Avi Kivity 已提交
3201
static int handle_invlpg(struct kvm_vcpu *vcpu)
M
Marcelo Tosatti 已提交
3202
{
3203
	unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
M
Marcelo Tosatti 已提交
3204 3205 3206 3207 3208 3209

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

A
Avi Kivity 已提交
3210
static int handle_wbinvd(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
3211 3212 3213 3214 3215 3216
{
	skip_emulated_instruction(vcpu);
	/* TODO: Add support for VT-d/pass-through device */
	return 1;
}

A
Avi Kivity 已提交
3217
static int handle_apic_access(struct kvm_vcpu *vcpu)
3218
{
3219
	unsigned long exit_qualification;
3220 3221 3222
	enum emulation_result er;
	unsigned long offset;

3223
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
3224 3225
	offset = exit_qualification & 0xffful;

A
Avi Kivity 已提交
3226
	er = emulate_instruction(vcpu, 0, 0, 0);
3227 3228 3229 3230 3231

	if (er !=  EMULATE_DONE) {
		printk(KERN_ERR
		       "Fail to handle apic access vmexit! Offset is 0x%lx\n",
		       offset);
3232
		return -ENOEXEC;
3233 3234 3235 3236
	}
	return 1;
}

A
Avi Kivity 已提交
3237
static int handle_task_switch(struct kvm_vcpu *vcpu)
3238
{
J
Jan Kiszka 已提交
3239
	struct vcpu_vmx *vmx = to_vmx(vcpu);
3240 3241
	unsigned long exit_qualification;
	u16 tss_selector;
3242 3243 3244 3245
	int reason, type, idt_v;

	idt_v = (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK);
	type = (vmx->idt_vectoring_info & VECTORING_INFO_TYPE_MASK);
3246 3247 3248 3249

	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);

	reason = (u32)exit_qualification >> 30;
3250 3251 3252 3253 3254 3255 3256 3257 3258
	if (reason == TASK_SWITCH_GATE && idt_v) {
		switch (type) {
		case INTR_TYPE_NMI_INTR:
			vcpu->arch.nmi_injected = false;
			if (cpu_has_virtual_nmis())
				vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
					      GUEST_INTR_STATE_NMI);
			break;
		case INTR_TYPE_EXT_INTR:
3259
		case INTR_TYPE_SOFT_INTR:
3260 3261 3262 3263 3264 3265 3266 3267 3268
			kvm_clear_interrupt_queue(vcpu);
			break;
		case INTR_TYPE_HARD_EXCEPTION:
		case INTR_TYPE_SOFT_EXCEPTION:
			kvm_clear_exception_queue(vcpu);
			break;
		default:
			break;
		}
J
Jan Kiszka 已提交
3269
	}
3270 3271
	tss_selector = exit_qualification;

3272 3273 3274 3275 3276
	if (!idt_v || (type != INTR_TYPE_HARD_EXCEPTION &&
		       type != INTR_TYPE_EXT_INTR &&
		       type != INTR_TYPE_NMI_INTR))
		skip_emulated_instruction(vcpu);

3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288
	if (!kvm_task_switch(vcpu, tss_selector, reason))
		return 0;

	/* 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;
3289 3290
}

A
Avi Kivity 已提交
3291
static int handle_ept_violation(struct kvm_vcpu *vcpu)
3292
{
3293
	unsigned long exit_qualification;
3294 3295 3296
	gpa_t gpa;
	int gla_validity;

3297
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
3298 3299 3300

	if (exit_qualification & (1 << 6)) {
		printk(KERN_ERR "EPT: GPA exceeds GAW!\n");
3301
		return -EINVAL;
3302 3303 3304 3305 3306 3307 3308
	}

	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),
3309
			vmcs_readl(GUEST_LINEAR_ADDRESS));
3310 3311
		printk(KERN_ERR "EPT: Exit qualification is 0x%lx\n",
			(long unsigned int)exit_qualification);
A
Avi Kivity 已提交
3312 3313
		vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
		vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_VIOLATION;
3314
		return 0;
3315 3316 3317
	}

	gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS);
3318
	trace_kvm_page_fault(gpa, exit_qualification);
3319
	return kvm_mmu_page_fault(vcpu, gpa & PAGE_MASK, 0);
3320 3321
}

3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382
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 已提交
3383
static int handle_ept_misconfig(struct kvm_vcpu *vcpu)
3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398
{
	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 已提交
3399 3400
	vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
	vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_MISCONFIG;
3401 3402 3403 3404

	return 0;
}

A
Avi Kivity 已提交
3405
static int handle_nmi_window(struct kvm_vcpu *vcpu)
3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417
{
	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;

	return 1;
}

3418
static int handle_invalid_guest_state(struct kvm_vcpu *vcpu)
3419
{
3420 3421
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	enum emulation_result err = EMULATE_DONE;
3422
	int ret = 1;
3423 3424

	while (!guest_state_valid(vcpu)) {
A
Avi Kivity 已提交
3425
		err = emulate_instruction(vcpu, 0, 0, 0);
3426

3427 3428 3429 3430
		if (err == EMULATE_DO_MMIO) {
			ret = 0;
			goto out;
		}
3431 3432 3433

		if (err != EMULATE_DONE) {
			kvm_report_emulation_failure(vcpu, "emulation failure");
3434 3435
			vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
			vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION;
3436
			vcpu->run->internal.ndata = 0;
3437 3438
			ret = 0;
			goto out;
3439 3440 3441
		}

		if (signal_pending(current))
3442
			goto out;
3443 3444 3445 3446
		if (need_resched())
			schedule();
	}

3447 3448 3449
	vmx->emulation_required = 0;
out:
	return ret;
3450 3451
}

3452 3453 3454 3455
/*
 * Indicate a busy-waiting vcpu in spinlock. We do not enable the PAUSE
 * exiting, so only get here on cpu with PAUSE-Loop-Exiting.
 */
3456
static int handle_pause(struct kvm_vcpu *vcpu)
3457 3458 3459 3460 3461 3462 3463
{
	skip_emulated_instruction(vcpu);
	kvm_vcpu_on_spin(vcpu);

	return 1;
}

3464 3465 3466 3467 3468 3469
static int handle_invalid_op(struct kvm_vcpu *vcpu)
{
	kvm_queue_exception(vcpu, UD_VECTOR);
	return 1;
}

A
Avi Kivity 已提交
3470 3471 3472 3473 3474
/*
 * 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 已提交
3475
static int (*kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu) = {
A
Avi Kivity 已提交
3476 3477
	[EXIT_REASON_EXCEPTION_NMI]           = handle_exception,
	[EXIT_REASON_EXTERNAL_INTERRUPT]      = handle_external_interrupt,
3478
	[EXIT_REASON_TRIPLE_FAULT]            = handle_triple_fault,
3479
	[EXIT_REASON_NMI_WINDOW]	      = handle_nmi_window,
A
Avi Kivity 已提交
3480 3481 3482 3483 3484 3485 3486 3487
	[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,
M
Marcelo Tosatti 已提交
3488
	[EXIT_REASON_INVLPG]		      = handle_invlpg,
3489
	[EXIT_REASON_VMCALL]                  = handle_vmcall,
3490 3491 3492 3493 3494 3495 3496 3497 3498
	[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,
	[EXIT_REASON_VMOFF]                   = handle_vmx_insn,
	[EXIT_REASON_VMON]                    = handle_vmx_insn,
3499 3500
	[EXIT_REASON_TPR_BELOW_THRESHOLD]     = handle_tpr_below_threshold,
	[EXIT_REASON_APIC_ACCESS]             = handle_apic_access,
E
Eddie Dong 已提交
3501
	[EXIT_REASON_WBINVD]                  = handle_wbinvd,
3502
	[EXIT_REASON_TASK_SWITCH]             = handle_task_switch,
A
Andi Kleen 已提交
3503
	[EXIT_REASON_MCE_DURING_VMENTRY]      = handle_machine_check,
3504 3505
	[EXIT_REASON_EPT_VIOLATION]	      = handle_ept_violation,
	[EXIT_REASON_EPT_MISCONFIG]           = handle_ept_misconfig,
3506
	[EXIT_REASON_PAUSE_INSTRUCTION]       = handle_pause,
3507 3508
	[EXIT_REASON_MWAIT_INSTRUCTION]	      = handle_invalid_op,
	[EXIT_REASON_MONITOR_INSTRUCTION]     = handle_invalid_op,
A
Avi Kivity 已提交
3509 3510 3511
};

static const int kvm_vmx_max_exit_handlers =
3512
	ARRAY_SIZE(kvm_vmx_exit_handlers);
A
Avi Kivity 已提交
3513 3514 3515 3516 3517

/*
 * The guest has exited.  See if we can fix it or if we need userspace
 * assistance.
 */
A
Avi Kivity 已提交
3518
static int vmx_handle_exit(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3519
{
3520
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Andi Kleen 已提交
3521
	u32 exit_reason = vmx->exit_reason;
3522
	u32 vectoring_info = vmx->idt_vectoring_info;
3523

3524
	trace_kvm_exit(exit_reason, kvm_rip_read(vcpu));
F
Feng (Eric) Liu 已提交
3525

3526 3527 3528
	/* If guest state is invalid, start emulating */
	if (vmx->emulation_required && emulate_invalid_guest_state)
		return handle_invalid_guest_state(vcpu);
3529

3530 3531
	/* Access CR3 don't cause VMExit in paging mode, so we need
	 * to sync with guest real CR3. */
A
Avi Kivity 已提交
3532
	if (enable_ept && is_paging(vcpu))
3533 3534
		vcpu->arch.cr3 = vmcs_readl(GUEST_CR3);

3535
	if (unlikely(vmx->fail)) {
A
Avi Kivity 已提交
3536 3537
		vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;
		vcpu->run->fail_entry.hardware_entry_failure_reason
3538 3539 3540
			= vmcs_read32(VM_INSTRUCTION_ERROR);
		return 0;
	}
A
Avi Kivity 已提交
3541

M
Mike Day 已提交
3542
	if ((vectoring_info & VECTORING_INFO_VALID_MASK) &&
3543
			(exit_reason != EXIT_REASON_EXCEPTION_NMI &&
J
Jan Kiszka 已提交
3544 3545 3546 3547 3548
			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);
3549 3550

	if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked)) {
3551
		if (vmx_interrupt_allowed(vcpu)) {
3552 3553
			vmx->soft_vnmi_blocked = 0;
		} else if (vmx->vnmi_blocked_time > 1000000000LL &&
3554
			   vcpu->arch.nmi_pending) {
3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567
			/*
			 * 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 已提交
3568 3569
	if (exit_reason < kvm_vmx_max_exit_handlers
	    && kvm_vmx_exit_handlers[exit_reason])
A
Avi Kivity 已提交
3570
		return kvm_vmx_exit_handlers[exit_reason](vcpu);
A
Avi Kivity 已提交
3571
	else {
A
Avi Kivity 已提交
3572 3573
		vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
		vcpu->run->hw.hardware_exit_reason = exit_reason;
A
Avi Kivity 已提交
3574 3575 3576 3577
	}
	return 0;
}

3578
static void update_cr8_intercept(struct kvm_vcpu *vcpu, int tpr, int irr)
3579
{
3580
	if (irr == -1 || tpr < irr) {
3581 3582 3583 3584
		vmcs_write32(TPR_THRESHOLD, 0);
		return;
	}

3585
	vmcs_write32(TPR_THRESHOLD, irr);
3586 3587
}

3588 3589 3590
static void vmx_complete_interrupts(struct vcpu_vmx *vmx)
{
	u32 exit_intr_info;
3591
	u32 idt_vectoring_info = vmx->idt_vectoring_info;
3592 3593
	bool unblock_nmi;
	u8 vector;
3594 3595
	int type;
	bool idtv_info_valid;
3596 3597

	exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO);
3598

A
Andi Kleen 已提交
3599 3600 3601 3602 3603 3604 3605 3606
	vmx->exit_reason = vmcs_read32(VM_EXIT_REASON);

	/* Handle machine checks before interrupts are enabled */
	if ((vmx->exit_reason == EXIT_REASON_MCE_DURING_VMENTRY)
	    || (vmx->exit_reason == EXIT_REASON_EXCEPTION_NMI
		&& is_machine_check(exit_intr_info)))
		kvm_machine_check();

3607 3608
	/* We need to handle NMIs before interrupts are enabled */
	if ((exit_intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR &&
3609
	    (exit_intr_info & INTR_INFO_VALID_MASK))
3610 3611 3612 3613
		asm("int $2");

	idtv_info_valid = idt_vectoring_info & VECTORING_INFO_VALID_MASK;

3614 3615 3616 3617
	if (cpu_has_virtual_nmis()) {
		unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0;
		vector = exit_intr_info & INTR_INFO_VECTOR_MASK;
		/*
3618
		 * SDM 3: 27.7.1.2 (September 2008)
3619 3620
		 * Re-set bit "block by NMI" before VM entry if vmexit caused by
		 * a guest IRET fault.
3621 3622 3623 3624 3625
		 * 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.
3626
		 */
3627 3628
		if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi &&
		    vector != DF_VECTOR && !idtv_info_valid)
3629 3630
			vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
				      GUEST_INTR_STATE_NMI);
3631 3632 3633
	} else if (unlikely(vmx->soft_vnmi_blocked))
		vmx->vnmi_blocked_time +=
			ktime_to_ns(ktime_sub(ktime_get(), vmx->entry_time));
3634

3635 3636 3637 3638 3639 3640 3641
	vmx->vcpu.arch.nmi_injected = false;
	kvm_clear_exception_queue(&vmx->vcpu);
	kvm_clear_interrupt_queue(&vmx->vcpu);

	if (!idtv_info_valid)
		return;

3642 3643
	vector = idt_vectoring_info & VECTORING_INFO_VECTOR_MASK;
	type = idt_vectoring_info & VECTORING_INFO_TYPE_MASK;
3644

3645
	switch (type) {
3646 3647
	case INTR_TYPE_NMI_INTR:
		vmx->vcpu.arch.nmi_injected = true;
3648
		/*
3649
		 * SDM 3: 27.7.1.2 (September 2008)
3650 3651
		 * Clear bit "block by NMI" before VM entry if a NMI
		 * delivery faulted.
3652
		 */
3653 3654 3655 3656
		vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO,
				GUEST_INTR_STATE_NMI);
		break;
	case INTR_TYPE_SOFT_EXCEPTION:
3657 3658 3659 3660
		vmx->vcpu.arch.event_exit_inst_len =
			vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
		/* fall through */
	case INTR_TYPE_HARD_EXCEPTION:
3661
		if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) {
3662 3663
			u32 err = vmcs_read32(IDT_VECTORING_ERROR_CODE);
			kvm_queue_exception_e(&vmx->vcpu, vector, err);
3664 3665
		} else
			kvm_queue_exception(&vmx->vcpu, vector);
3666
		break;
3667 3668 3669 3670
	case INTR_TYPE_SOFT_INTR:
		vmx->vcpu.arch.event_exit_inst_len =
			vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
		/* fall through */
3671
	case INTR_TYPE_EXT_INTR:
3672 3673
		kvm_queue_interrupt(&vmx->vcpu, vector,
			type == INTR_TYPE_SOFT_INTR);
3674 3675 3676
		break;
	default:
		break;
3677
	}
3678 3679
}

3680 3681 3682 3683 3684 3685 3686 3687 3688
/*
 * Failure to inject an interrupt should give us the information
 * in IDT_VECTORING_INFO_FIELD.  However, if the failure occurs
 * when fetching the interrupt redirection bitmap in the real-mode
 * tss, this doesn't happen.  So we do it ourselves.
 */
static void fixup_rmode_irq(struct vcpu_vmx *vmx)
{
	vmx->rmode.irq.pending = 0;
3689
	if (kvm_rip_read(&vmx->vcpu) + 1 != vmx->rmode.irq.rip)
3690
		return;
3691
	kvm_rip_write(&vmx->vcpu, vmx->rmode.irq.rip);
3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702
	if (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK) {
		vmx->idt_vectoring_info &= ~VECTORING_INFO_TYPE_MASK;
		vmx->idt_vectoring_info |= INTR_TYPE_EXT_INTR;
		return;
	}
	vmx->idt_vectoring_info =
		VECTORING_INFO_VALID_MASK
		| INTR_TYPE_EXT_INTR
		| vmx->rmode.irq.vector;
}

3703 3704 3705 3706 3707 3708 3709 3710
#ifdef CONFIG_X86_64
#define R "r"
#define Q "q"
#else
#define R "e"
#define Q "l"
#endif

A
Avi Kivity 已提交
3711
static void vmx_vcpu_run(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3712
{
3713
	struct vcpu_vmx *vmx = to_vmx(vcpu);
3714

3715 3716 3717 3718
	/* 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();

3719 3720 3721
	/* 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)
3722 3723
		return;

3724 3725 3726 3727 3728
	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]);

3729 3730 3731 3732 3733 3734 3735 3736
	/* 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);

3737 3738 3739 3740 3741
	/*
	 * Loading guest fpu may have cleared host cr0.ts
	 */
	vmcs_writel(HOST_CR0, read_cr0());

3742 3743
	if (vcpu->arch.switch_db_regs)
		set_debugreg(vcpu->arch.dr6, 6);
3744

M
Mike Day 已提交
3745
	asm(
A
Avi Kivity 已提交
3746
		/* Store host registers */
3747 3748
		"push %%"R"dx; push %%"R"bp;"
		"push %%"R"cx \n\t"
3749 3750 3751
		"cmp %%"R"sp, %c[host_rsp](%0) \n\t"
		"je 1f \n\t"
		"mov %%"R"sp, %c[host_rsp](%0) \n\t"
3752
		__ex(ASM_VMX_VMWRITE_RSP_RDX) "\n\t"
3753
		"1: \n\t"
3754 3755 3756 3757 3758 3759 3760
		/* 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 已提交
3761
		/* Check if vmlaunch of vmresume is needed */
3762
		"cmpl $0, %c[launched](%0) \n\t"
A
Avi Kivity 已提交
3763
		/* Load guest registers.  Don't clobber flags. */
3764 3765 3766 3767 3768 3769
		"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"
3770
#ifdef CONFIG_X86_64
3771 3772 3773 3774 3775 3776 3777 3778
		"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 已提交
3779
#endif
3780 3781
		"mov %c[rcx](%0), %%"R"cx \n\t" /* kills %0 (ecx) */

A
Avi Kivity 已提交
3782
		/* Enter guest mode */
3783
		"jne .Llaunched \n\t"
3784
		__ex(ASM_VMX_VMLAUNCH) "\n\t"
3785
		"jmp .Lkvm_vmx_return \n\t"
3786
		".Llaunched: " __ex(ASM_VMX_VMRESUME) "\n\t"
3787
		".Lkvm_vmx_return: "
A
Avi Kivity 已提交
3788
		/* Save guest registers, load host registers, keep flags */
3789 3790 3791 3792 3793 3794 3795 3796
		"xchg %0,     (%%"R"sp) \n\t"
		"mov %%"R"ax, %c[rax](%0) \n\t"
		"mov %%"R"bx, %c[rbx](%0) \n\t"
		"push"Q" (%%"R"sp); pop"Q" %c[rcx](%0) \n\t"
		"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"
3797
#ifdef CONFIG_X86_64
3798 3799 3800 3801 3802 3803 3804 3805
		"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 已提交
3806
#endif
3807 3808 3809 3810
		"mov %%cr2, %%"R"ax   \n\t"
		"mov %%"R"ax, %c[cr2](%0) \n\t"

		"pop  %%"R"bp; pop  %%"R"bp; pop  %%"R"dx \n\t"
3811 3812 3813 3814
		"setbe %c[fail](%0) \n\t"
	      : : "c"(vmx), "d"((unsigned long)HOST_RSP),
		[launched]"i"(offsetof(struct vcpu_vmx, launched)),
		[fail]"i"(offsetof(struct vcpu_vmx, fail)),
3815
		[host_rsp]"i"(offsetof(struct vcpu_vmx, host_rsp)),
3816 3817 3818 3819 3820 3821 3822
		[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])),
3823
#ifdef CONFIG_X86_64
3824 3825 3826 3827 3828 3829 3830 3831
		[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 已提交
3832
#endif
3833
		[cr2]"i"(offsetof(struct vcpu_vmx, vcpu.arch.cr2))
3834
	      : "cc", "memory"
3835
		, R"bx", R"di", R"si"
3836 3837 3838 3839
#ifdef CONFIG_X86_64
		, "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
#endif
	      );
A
Avi Kivity 已提交
3840

A
Avi Kivity 已提交
3841 3842
	vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) | (1 << VCPU_REGS_RSP)
				  | (1 << VCPU_EXREG_PDPTR));
3843 3844
	vcpu->arch.regs_dirty = 0;

3845 3846
	if (vcpu->arch.switch_db_regs)
		get_debugreg(vcpu->arch.dr6, 6);
3847

3848
	vmx->idt_vectoring_info = vmcs_read32(IDT_VECTORING_INFO_FIELD);
3849 3850
	if (vmx->rmode.irq.pending)
		fixup_rmode_irq(vmx);
3851

M
Mike Day 已提交
3852
	asm("mov %0, %%ds; mov %0, %%es" : : "r"(__USER_DS));
3853
	vmx->launched = 1;
3854

3855
	vmx_complete_interrupts(vmx);
A
Avi Kivity 已提交
3856 3857
}

3858 3859 3860
#undef R
#undef Q

A
Avi Kivity 已提交
3861 3862
static void vmx_free_vmcs(struct kvm_vcpu *vcpu)
{
3863 3864 3865
	struct vcpu_vmx *vmx = to_vmx(vcpu);

	if (vmx->vmcs) {
3866
		vcpu_clear(vmx);
3867 3868
		free_vmcs(vmx->vmcs);
		vmx->vmcs = NULL;
A
Avi Kivity 已提交
3869 3870 3871 3872 3873
	}
}

static void vmx_free_vcpu(struct kvm_vcpu *vcpu)
{
R
Rusty Russell 已提交
3874 3875
	struct vcpu_vmx *vmx = to_vmx(vcpu);

3876 3877 3878 3879
	spin_lock(&vmx_vpid_lock);
	if (vmx->vpid != 0)
		__clear_bit(vmx->vpid, vmx_vpid_bitmap);
	spin_unlock(&vmx_vpid_lock);
A
Avi Kivity 已提交
3880
	vmx_free_vmcs(vcpu);
R
Rusty Russell 已提交
3881 3882
	kfree(vmx->guest_msrs);
	kvm_vcpu_uninit(vcpu);
3883
	kmem_cache_free(kvm_vcpu_cache, vmx);
A
Avi Kivity 已提交
3884 3885
}

R
Rusty Russell 已提交
3886
static struct kvm_vcpu *vmx_create_vcpu(struct kvm *kvm, unsigned int id)
A
Avi Kivity 已提交
3887
{
R
Rusty Russell 已提交
3888
	int err;
3889
	struct vcpu_vmx *vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
3890
	int cpu;
A
Avi Kivity 已提交
3891

3892
	if (!vmx)
R
Rusty Russell 已提交
3893 3894
		return ERR_PTR(-ENOMEM);

3895 3896
	allocate_vpid(vmx);

R
Rusty Russell 已提交
3897 3898 3899
	err = kvm_vcpu_init(&vmx->vcpu, kvm, id);
	if (err)
		goto free_vcpu;
3900

3901
	vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
R
Rusty Russell 已提交
3902 3903 3904 3905
	if (!vmx->guest_msrs) {
		err = -ENOMEM;
		goto uninit_vcpu;
	}
3906

3907 3908
	vmx->vmcs = alloc_vmcs();
	if (!vmx->vmcs)
R
Rusty Russell 已提交
3909
		goto free_msrs;
3910 3911 3912

	vmcs_clear(vmx->vmcs);

3913 3914
	cpu = get_cpu();
	vmx_vcpu_load(&vmx->vcpu, cpu);
R
Rusty Russell 已提交
3915
	err = vmx_vcpu_setup(vmx);
R
Rusty Russell 已提交
3916
	vmx_vcpu_put(&vmx->vcpu);
3917
	put_cpu();
R
Rusty Russell 已提交
3918 3919
	if (err)
		goto free_vmcs;
3920 3921 3922
	if (vm_need_virtualize_apic_accesses(kvm))
		if (alloc_apic_access_page(kvm) != 0)
			goto free_vmcs;
R
Rusty Russell 已提交
3923

3924 3925 3926 3927
	if (enable_ept) {
		if (!kvm->arch.ept_identity_map_addr)
			kvm->arch.ept_identity_map_addr =
				VMX_EPT_IDENTITY_PAGETABLE_ADDR;
3928 3929
		if (alloc_identity_pagetable(kvm) != 0)
			goto free_vmcs;
3930
	}
3931

R
Rusty Russell 已提交
3932 3933 3934 3935 3936 3937 3938 3939 3940
	return &vmx->vcpu;

free_vmcs:
	free_vmcs(vmx->vmcs);
free_msrs:
	kfree(vmx->guest_msrs);
uninit_vcpu:
	kvm_vcpu_uninit(&vmx->vcpu);
free_vcpu:
3941
	kmem_cache_free(kvm_vcpu_cache, vmx);
R
Rusty Russell 已提交
3942
	return ERR_PTR(err);
A
Avi Kivity 已提交
3943 3944
}

Y
Yang, Sheng 已提交
3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958
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;
	}
}

3959 3960 3961 3962 3963
static int get_ept_level(void)
{
	return VMX_EPT_DEFAULT_GAW + 1;
}

3964
static u64 vmx_get_mt_mask(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio)
S
Sheng Yang 已提交
3965
{
3966 3967
	u64 ret;

3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978
	/* 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.
	 * 3. EPT without VT-d: always map as WB and set IGMT=1 to keep
	 *    consistent with host MTRR
	 */
3979 3980
	if (is_mmio)
		ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT;
3981 3982 3983 3984
	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;
3985
	else
3986 3987
		ret = (MTRR_TYPE_WRBACK << VMX_EPT_MT_EPTE_SHIFT)
			| VMX_EPT_IGMT_BIT;
3988 3989

	return ret;
S
Sheng Yang 已提交
3990 3991
}

3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014
static const struct trace_print_flags vmx_exit_reasons_str[] = {
	{ EXIT_REASON_EXCEPTION_NMI,           "exception" },
	{ EXIT_REASON_EXTERNAL_INTERRUPT,      "ext_irq" },
	{ EXIT_REASON_TRIPLE_FAULT,            "triple_fault" },
	{ EXIT_REASON_NMI_WINDOW,              "nmi_window" },
	{ EXIT_REASON_IO_INSTRUCTION,          "io_instruction" },
	{ EXIT_REASON_CR_ACCESS,               "cr_access" },
	{ EXIT_REASON_DR_ACCESS,               "dr_access" },
	{ EXIT_REASON_CPUID,                   "cpuid" },
	{ EXIT_REASON_MSR_READ,                "rdmsr" },
	{ EXIT_REASON_MSR_WRITE,               "wrmsr" },
	{ EXIT_REASON_PENDING_INTERRUPT,       "interrupt_window" },
	{ EXIT_REASON_HLT,                     "halt" },
	{ EXIT_REASON_INVLPG,                  "invlpg" },
	{ EXIT_REASON_VMCALL,                  "hypercall" },
	{ EXIT_REASON_TPR_BELOW_THRESHOLD,     "tpr_below_thres" },
	{ EXIT_REASON_APIC_ACCESS,             "apic_access" },
	{ EXIT_REASON_WBINVD,                  "wbinvd" },
	{ EXIT_REASON_TASK_SWITCH,             "task_switch" },
	{ EXIT_REASON_EPT_VIOLATION,           "ept_violation" },
	{ -1, NULL }
};

4015 4016 4017 4018 4019
static bool vmx_gb_page_enable(void)
{
	return false;
}

4020 4021 4022 4023 4024
static inline u32 bit(int bitno)
{
	return 1 << (bitno & 31);
}

4025 4026
static void vmx_cpuid_update(struct kvm_vcpu *vcpu)
{
4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044
	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);
			}
		}
	}
4045 4046
}

4047
static struct kvm_x86_ops vmx_x86_ops = {
A
Avi Kivity 已提交
4048 4049 4050 4051
	.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 已提交
4052
	.check_processor_compatibility = vmx_check_processor_compat,
A
Avi Kivity 已提交
4053 4054
	.hardware_enable = hardware_enable,
	.hardware_disable = hardware_disable,
4055
	.cpu_has_accelerated_tpr = report_flexpriority,
A
Avi Kivity 已提交
4056 4057 4058

	.vcpu_create = vmx_create_vcpu,
	.vcpu_free = vmx_free_vcpu,
4059
	.vcpu_reset = vmx_vcpu_reset,
A
Avi Kivity 已提交
4060

4061
	.prepare_guest_switch = vmx_save_host_state,
A
Avi Kivity 已提交
4062 4063 4064 4065 4066 4067 4068 4069 4070
	.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,
4071
	.get_cpl = vmx_get_cpl,
A
Avi Kivity 已提交
4072
	.get_cs_db_l_bits = vmx_get_cs_db_l_bits,
4073
	.decache_cr4_guest_bits = vmx_decache_cr4_guest_bits,
A
Avi Kivity 已提交
4074 4075 4076 4077 4078 4079 4080 4081
	.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,
4082
	.cache_reg = vmx_cache_reg,
A
Avi Kivity 已提交
4083 4084 4085 4086 4087 4088
	.get_rflags = vmx_get_rflags,
	.set_rflags = vmx_set_rflags,

	.tlb_flush = vmx_flush_tlb,

	.run = vmx_vcpu_run,
4089
	.handle_exit = vmx_handle_exit,
A
Avi Kivity 已提交
4090
	.skip_emulated_instruction = skip_emulated_instruction,
4091 4092
	.set_interrupt_shadow = vmx_set_interrupt_shadow,
	.get_interrupt_shadow = vmx_get_interrupt_shadow,
I
Ingo Molnar 已提交
4093
	.patch_hypercall = vmx_patch_hypercall,
E
Eddie Dong 已提交
4094
	.set_irq = vmx_inject_irq,
4095
	.set_nmi = vmx_inject_nmi,
4096
	.queue_exception = vmx_queue_exception,
4097
	.interrupt_allowed = vmx_interrupt_allowed,
4098
	.nmi_allowed = vmx_nmi_allowed,
J
Jan Kiszka 已提交
4099 4100
	.get_nmi_mask = vmx_get_nmi_mask,
	.set_nmi_mask = vmx_set_nmi_mask,
4101 4102 4103 4104
	.enable_nmi_window = enable_nmi_window,
	.enable_irq_window = enable_irq_window,
	.update_cr8_intercept = update_cr8_intercept,

4105
	.set_tss_addr = vmx_set_tss_addr,
4106
	.get_tdp_level = get_ept_level,
4107
	.get_mt_mask = vmx_get_mt_mask,
4108 4109

	.exit_reasons_str = vmx_exit_reasons_str,
4110
	.gb_page_enable = vmx_gb_page_enable,
4111 4112

	.cpuid_update = vmx_cpuid_update,
4113 4114

	.rdtscp_supported = vmx_rdtscp_supported,
A
Avi Kivity 已提交
4115 4116 4117 4118
};

static int __init vmx_init(void)
{
4119 4120 4121 4122 4123 4124
	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]);
4125

4126
	vmx_io_bitmap_a = (unsigned long *)__get_free_page(GFP_KERNEL);
4127 4128 4129
	if (!vmx_io_bitmap_a)
		return -ENOMEM;

4130
	vmx_io_bitmap_b = (unsigned long *)__get_free_page(GFP_KERNEL);
4131 4132 4133 4134 4135
	if (!vmx_io_bitmap_b) {
		r = -ENOMEM;
		goto out;
	}

4136 4137
	vmx_msr_bitmap_legacy = (unsigned long *)__get_free_page(GFP_KERNEL);
	if (!vmx_msr_bitmap_legacy) {
S
Sheng Yang 已提交
4138 4139 4140 4141
		r = -ENOMEM;
		goto out1;
	}

4142 4143 4144 4145 4146 4147
	vmx_msr_bitmap_longmode = (unsigned long *)__get_free_page(GFP_KERNEL);
	if (!vmx_msr_bitmap_longmode) {
		r = -ENOMEM;
		goto out2;
	}

4148 4149 4150 4151
	/*
	 * Allow direct access to the PC debug port (it is often used for I/O
	 * delays, but the vmexits simply slow things down).
	 */
4152 4153
	memset(vmx_io_bitmap_a, 0xff, PAGE_SIZE);
	clear_bit(0x80, vmx_io_bitmap_a);
4154

4155
	memset(vmx_io_bitmap_b, 0xff, PAGE_SIZE);
4156

4157 4158
	memset(vmx_msr_bitmap_legacy, 0xff, PAGE_SIZE);
	memset(vmx_msr_bitmap_longmode, 0xff, PAGE_SIZE);
S
Sheng Yang 已提交
4159

4160 4161
	set_bit(0, vmx_vpid_bitmap); /* 0 is reserved for host */

4162
	r = kvm_init(&vmx_x86_ops, sizeof(struct vcpu_vmx), THIS_MODULE);
4163
	if (r)
4164
		goto out3;
S
Sheng Yang 已提交
4165

4166 4167 4168 4169 4170 4171
	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);
4172

4173
	if (enable_ept) {
4174
		bypass_guest_pf = 0;
4175
		kvm_mmu_set_base_ptes(VMX_EPT_READABLE_MASK |
4176
			VMX_EPT_WRITABLE_MASK);
4177
		kvm_mmu_set_mask_ptes(0ull, 0ull, 0ull, 0ull,
4178
				VMX_EPT_EXECUTABLE_MASK);
4179 4180 4181
		kvm_enable_tdp();
	} else
		kvm_disable_tdp();
4182

4183 4184 4185
	if (bypass_guest_pf)
		kvm_mmu_set_nonpresent_ptes(~0xffeull, 0ull);

4186 4187
	return 0;

4188 4189
out3:
	free_page((unsigned long)vmx_msr_bitmap_longmode);
S
Sheng Yang 已提交
4190
out2:
4191
	free_page((unsigned long)vmx_msr_bitmap_legacy);
4192
out1:
4193
	free_page((unsigned long)vmx_io_bitmap_b);
4194
out:
4195
	free_page((unsigned long)vmx_io_bitmap_a);
4196
	return r;
A
Avi Kivity 已提交
4197 4198 4199 4200
}

static void __exit vmx_exit(void)
{
4201 4202
	free_page((unsigned long)vmx_msr_bitmap_legacy);
	free_page((unsigned long)vmx_msr_bitmap_longmode);
4203 4204
	free_page((unsigned long)vmx_io_bitmap_b);
	free_page((unsigned long)vmx_io_bitmap_a);
4205

4206
	kvm_exit();
A
Avi Kivity 已提交
4207 4208 4209 4210
}

module_init(vmx_init)
module_exit(vmx_exit)