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

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

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

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

43 44
#include "trace.h"

45 46
#define __ex(x) __kvm_handle_fault_on_reboot(x)

A
Avi Kivity 已提交
47 48 49
MODULE_AUTHOR("Qumranet");
MODULE_LICENSE("GPL");

50
static int __read_mostly bypass_guest_pf = 1;
51
module_param(bypass_guest_pf, bool, S_IRUGO);
52

53
static int __read_mostly enable_vpid = 1;
54
module_param_named(vpid, enable_vpid, bool, 0444);
55

56
static int __read_mostly flexpriority_enabled = 1;
57
module_param_named(flexpriority, flexpriority_enabled, bool, S_IRUGO);
58

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

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

66
static int __read_mostly emulate_invalid_guest_state = 0;
67
module_param(emulate_invalid_guest_state, bool, S_IRUGO);
68

69 70 71
static int __read_mostly vmm_exclusive = 1;
module_param(vmm_exclusive, bool, S_IRUGO);

72 73 74 75 76
#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				\
77
	(X86_CR0_WP | X86_CR0_NE)
78 79
#define KVM_VM_CR0_ALWAYS_ON						\
	(KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST | X86_CR0_PG | X86_CR0_PE)
80 81 82 83
#define KVM_CR4_GUEST_OWNED_BITS				      \
	(X86_CR4_PVI | X86_CR4_DE | X86_CR4_PCE | X86_CR4_OSFXSR      \
	 | X86_CR4_OSXMMEXCPT)

84 85 86
#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)

87 88
#define RMODE_GUEST_OWNED_EFLAGS_BITS (~(X86_EFLAGS_IOPL | X86_EFLAGS_VM))

89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
/*
 * 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);

108 109
#define NR_AUTOLOAD_MSRS 1

110 111 112 113 114 115
struct vmcs {
	u32 revision_id;
	u32 abort;
	char data[0];
};

116 117 118
struct shared_msr_entry {
	unsigned index;
	u64 data;
119
	u64 mask;
120 121
};

122
struct vcpu_vmx {
R
Rusty Russell 已提交
123
	struct kvm_vcpu       vcpu;
124
	struct list_head      local_vcpus_link;
125
	unsigned long         host_rsp;
126
	int                   launched;
127
	u8                    fail;
128
	u32                   idt_vectoring_info;
129
	struct shared_msr_entry *guest_msrs;
130 131 132
	int                   nmsrs;
	int                   save_nmsrs;
#ifdef CONFIG_X86_64
133 134
	u64 		      msr_host_kernel_gs_base;
	u64 		      msr_guest_kernel_gs_base;
135 136
#endif
	struct vmcs          *vmcs;
137 138 139 140 141
	struct msr_autoload {
		unsigned nr;
		struct vmx_msr_entry guest[NR_AUTOLOAD_MSRS];
		struct vmx_msr_entry host[NR_AUTOLOAD_MSRS];
	} msr_autoload;
142 143 144
	struct {
		int           loaded;
		u16           fs_sel, gs_sel, ldt_sel;
145 146
		int           gs_ldt_reload_needed;
		int           fs_reload_needed;
M
Mike Day 已提交
147
	} host_state;
148
	struct {
149
		int vm86_active;
150
		ulong save_rflags;
151 152 153 154 155 156
		struct kvm_save_segment {
			u16 selector;
			unsigned long base;
			u32 limit;
			u32 ar;
		} tr, es, ds, fs, gs;
157 158 159 160 161 162
		struct {
			bool pending;
			u8 vector;
			unsigned rip;
		} irq;
	} rmode;
163
	int vpid;
164
	bool emulation_required;
165 166 167 168 169

	/* Support for vnmi-less CPUs */
	int soft_vnmi_blocked;
	ktime_t entry_time;
	s64 vnmi_blocked_time;
A
Andi Kleen 已提交
170
	u32 exit_reason;
171 172

	bool rdtscp_enabled;
173 174 175 176
};

static inline struct vcpu_vmx *to_vmx(struct kvm_vcpu *vcpu)
{
R
Rusty Russell 已提交
177
	return container_of(vcpu, struct vcpu_vmx, vcpu);
178 179
}

180
static int init_rmode(struct kvm *kvm);
181
static u64 construct_eptp(unsigned long root_hpa);
182 183
static void kvm_cpu_vmxon(u64 addr);
static void kvm_cpu_vmxoff(void);
184

A
Avi Kivity 已提交
185 186
static DEFINE_PER_CPU(struct vmcs *, vmxarea);
static DEFINE_PER_CPU(struct vmcs *, current_vmcs);
187
static DEFINE_PER_CPU(struct list_head, vcpus_on_cpu);
A
Avi Kivity 已提交
188

189 190
static unsigned long *vmx_io_bitmap_a;
static unsigned long *vmx_io_bitmap_b;
191 192
static unsigned long *vmx_msr_bitmap_legacy;
static unsigned long *vmx_msr_bitmap_longmode;
193

194 195 196
static DECLARE_BITMAP(vmx_vpid_bitmap, VMX_NR_VPIDS);
static DEFINE_SPINLOCK(vmx_vpid_lock);

197
static struct vmcs_config {
A
Avi Kivity 已提交
198 199 200
	int size;
	int order;
	u32 revision_id;
201 202
	u32 pin_based_exec_ctrl;
	u32 cpu_based_exec_ctrl;
203
	u32 cpu_based_2nd_exec_ctrl;
204 205 206
	u32 vmexit_ctrl;
	u32 vmentry_ctrl;
} vmcs_config;
A
Avi Kivity 已提交
207

H
Hannes Eder 已提交
208
static struct vmx_capability {
S
Sheng Yang 已提交
209 210 211 212
	u32 ept;
	u32 vpid;
} vmx_capability;

A
Avi Kivity 已提交
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
#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),
};

237 238
static u64 host_efer;

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

241 242 243 244
/*
 * Keep MSR_K6_STAR at the end, as setup_msrs() will try to optimize it
 * away by decrementing the array size.
 */
A
Avi Kivity 已提交
245
static const u32 vmx_msr_index[] = {
246
#ifdef CONFIG_X86_64
247
	MSR_SYSCALL_MASK, MSR_LSTAR, MSR_CSTAR,
A
Avi Kivity 已提交
248
#endif
249
	MSR_EFER, MSR_TSC_AUX, MSR_K6_STAR,
A
Avi Kivity 已提交
250
};
251
#define NR_VMX_MSR ARRAY_SIZE(vmx_msr_index)
A
Avi Kivity 已提交
252

253
static inline bool is_page_fault(u32 intr_info)
A
Avi Kivity 已提交
254 255 256
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
257
		(INTR_TYPE_HARD_EXCEPTION | PF_VECTOR | INTR_INFO_VALID_MASK);
A
Avi Kivity 已提交
258 259
}

260
static inline bool is_no_device(u32 intr_info)
261 262 263
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
264
		(INTR_TYPE_HARD_EXCEPTION | NM_VECTOR | INTR_INFO_VALID_MASK);
265 266
}

267
static inline bool is_invalid_opcode(u32 intr_info)
268 269 270
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
			     INTR_INFO_VALID_MASK)) ==
271
		(INTR_TYPE_HARD_EXCEPTION | UD_VECTOR | INTR_INFO_VALID_MASK);
272 273
}

274
static inline bool is_external_interrupt(u32 intr_info)
A
Avi Kivity 已提交
275 276 277 278 279
{
	return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VALID_MASK))
		== (INTR_TYPE_EXT_INTR | INTR_INFO_VALID_MASK);
}

280
static inline bool is_machine_check(u32 intr_info)
A
Andi Kleen 已提交
281 282 283 284 285 286
{
	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);
}

287
static inline bool cpu_has_vmx_msr_bitmap(void)
S
Sheng Yang 已提交
288
{
289
	return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS;
S
Sheng Yang 已提交
290 291
}

292
static inline bool cpu_has_vmx_tpr_shadow(void)
293
{
294
	return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW;
295 296
}

297
static inline bool vm_need_tpr_shadow(struct kvm *kvm)
298
{
299
	return (cpu_has_vmx_tpr_shadow()) && (irqchip_in_kernel(kvm));
300 301
}

302
static inline bool cpu_has_secondary_exec_ctrls(void)
303
{
304 305
	return vmcs_config.cpu_based_exec_ctrl &
		CPU_BASED_ACTIVATE_SECONDARY_CONTROLS;
306 307
}

308
static inline bool cpu_has_vmx_virtualize_apic_accesses(void)
309
{
310 311 312 313 314 315 316 317
	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();
318 319
}

320 321
static inline bool cpu_has_vmx_ept_execute_only(void)
{
322
	return vmx_capability.ept & VMX_EPT_EXECUTE_ONLY_BIT;
323 324 325 326
}

static inline bool cpu_has_vmx_eptp_uncacheable(void)
{
327
	return vmx_capability.ept & VMX_EPTP_UC_BIT;
328 329 330 331
}

static inline bool cpu_has_vmx_eptp_writeback(void)
{
332
	return vmx_capability.ept & VMX_EPTP_WB_BIT;
333 334 335 336
}

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

340 341
static inline bool cpu_has_vmx_ept_1g_page(void)
{
342
	return vmx_capability.ept & VMX_EPT_1GB_PAGE_BIT;
343 344
}

345 346 347 348 349
static inline bool cpu_has_vmx_ept_4levels(void)
{
	return vmx_capability.ept & VMX_EPT_PAGE_WALK_4_BIT;
}

350
static inline bool cpu_has_vmx_invept_individual_addr(void)
S
Sheng Yang 已提交
351
{
352
	return vmx_capability.ept & VMX_EPT_EXTENT_INDIVIDUAL_BIT;
S
Sheng Yang 已提交
353 354
}

355
static inline bool cpu_has_vmx_invept_context(void)
S
Sheng Yang 已提交
356
{
357
	return vmx_capability.ept & VMX_EPT_EXTENT_CONTEXT_BIT;
S
Sheng Yang 已提交
358 359
}

360
static inline bool cpu_has_vmx_invept_global(void)
S
Sheng Yang 已提交
361
{
362
	return vmx_capability.ept & VMX_EPT_EXTENT_GLOBAL_BIT;
S
Sheng Yang 已提交
363 364
}

365 366 367 368 369
static inline bool cpu_has_vmx_invvpid_single(void)
{
	return vmx_capability.vpid & VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT;
}

370 371 372 373 374
static inline bool cpu_has_vmx_invvpid_global(void)
{
	return vmx_capability.vpid & VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT;
}

375
static inline bool cpu_has_vmx_ept(void)
S
Sheng Yang 已提交
376
{
377 378
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_ENABLE_EPT;
S
Sheng Yang 已提交
379 380
}

381
static inline bool cpu_has_vmx_unrestricted_guest(void)
382 383 384 385 386
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_UNRESTRICTED_GUEST;
}

387
static inline bool cpu_has_vmx_ple(void)
388 389 390 391 392
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_PAUSE_LOOP_EXITING;
}

393
static inline bool vm_need_virtualize_apic_accesses(struct kvm *kvm)
394
{
395
	return flexpriority_enabled && irqchip_in_kernel(kvm);
396 397
}

398
static inline bool cpu_has_vmx_vpid(void)
399
{
400 401
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_ENABLE_VPID;
402 403
}

404
static inline bool cpu_has_vmx_rdtscp(void)
405 406 407 408 409
{
	return vmcs_config.cpu_based_2nd_exec_ctrl &
		SECONDARY_EXEC_RDTSCP;
}

410
static inline bool cpu_has_virtual_nmis(void)
411 412 413 414
{
	return vmcs_config.pin_based_exec_ctrl & PIN_BASED_VIRTUAL_NMIS;
}

415 416 417 418 419
static inline bool report_flexpriority(void)
{
	return flexpriority_enabled;
}

R
Rusty Russell 已提交
420
static int __find_msr_index(struct vcpu_vmx *vmx, u32 msr)
421 422 423
{
	int i;

424
	for (i = 0; i < vmx->nmsrs; ++i)
425
		if (vmx_msr_index[vmx->guest_msrs[i].index] == msr)
426 427 428 429
			return i;
	return -1;
}

430 431 432 433 434 435 436 437
static inline void __invvpid(int ext, u16 vpid, gva_t gva)
{
    struct {
	u64 vpid : 16;
	u64 rsvd : 48;
	u64 gva;
    } operand = { vpid, 0, gva };

438
    asm volatile (__ex(ASM_VMX_INVVPID)
439 440 441 442 443
		  /* CF==1 or ZF==1 --> rc = -1 */
		  "; ja 1f ; ud2 ; 1:"
		  : : "a"(&operand), "c"(ext) : "cc", "memory");
}

444 445 446 447 448 449
static inline void __invept(int ext, u64 eptp, gpa_t gpa)
{
	struct {
		u64 eptp, gpa;
	} operand = {eptp, gpa};

450
	asm volatile (__ex(ASM_VMX_INVEPT)
451 452 453 454 455
			/* CF==1 or ZF==1 --> rc = -1 */
			"; ja 1f ; ud2 ; 1:\n"
			: : "a" (&operand), "c" (ext) : "cc", "memory");
}

456
static struct shared_msr_entry *find_msr_entry(struct vcpu_vmx *vmx, u32 msr)
457 458 459
{
	int i;

R
Rusty Russell 已提交
460
	i = __find_msr_index(vmx, msr);
461
	if (i >= 0)
462
		return &vmx->guest_msrs[i];
A
Al Viro 已提交
463
	return NULL;
464 465
}

A
Avi Kivity 已提交
466 467 468 469 470
static void vmcs_clear(struct vmcs *vmcs)
{
	u64 phys_addr = __pa(vmcs);
	u8 error;

471
	asm volatile (__ex(ASM_VMX_VMCLEAR_RAX) "; setna %0"
A
Avi Kivity 已提交
472 473 474 475 476 477 478
		      : "=g"(error) : "a"(&phys_addr), "m"(phys_addr)
		      : "cc", "memory");
	if (error)
		printk(KERN_ERR "kvm: vmclear fail: %p/%llx\n",
		       vmcs, phys_addr);
}

479 480 481 482 483 484 485 486 487 488 489 490 491
static void vmcs_load(struct vmcs *vmcs)
{
	u64 phys_addr = __pa(vmcs);
	u8 error;

	asm volatile (__ex(ASM_VMX_VMPTRLD_RAX) "; setna %0"
			: "=g"(error) : "a"(&phys_addr), "m"(phys_addr)
			: "cc", "memory");
	if (error)
		printk(KERN_ERR "kvm: vmptrld %p/%llx fail\n",
		       vmcs, phys_addr);
}

A
Avi Kivity 已提交
492 493
static void __vcpu_clear(void *arg)
{
R
Rusty Russell 已提交
494
	struct vcpu_vmx *vmx = arg;
495
	int cpu = raw_smp_processor_id();
A
Avi Kivity 已提交
496

R
Rusty Russell 已提交
497
	if (vmx->vcpu.cpu == cpu)
498 499
		vmcs_clear(vmx->vmcs);
	if (per_cpu(current_vmcs, cpu) == vmx->vmcs)
A
Avi Kivity 已提交
500
		per_cpu(current_vmcs, cpu) = NULL;
501
	rdtscll(vmx->vcpu.arch.host_tsc);
502 503 504
	list_del(&vmx->local_vcpus_link);
	vmx->vcpu.cpu = -1;
	vmx->launched = 0;
A
Avi Kivity 已提交
505 506
}

R
Rusty Russell 已提交
507
static void vcpu_clear(struct vcpu_vmx *vmx)
A
Avi Kivity 已提交
508
{
509 510
	if (vmx->vcpu.cpu == -1)
		return;
511
	smp_call_function_single(vmx->vcpu.cpu, __vcpu_clear, vmx, 1);
A
Avi Kivity 已提交
512 513
}

514
static inline void vpid_sync_vcpu_single(struct vcpu_vmx *vmx)
515 516 517 518
{
	if (vmx->vpid == 0)
		return;

519 520
	if (cpu_has_vmx_invvpid_single())
		__invvpid(VMX_VPID_EXTENT_SINGLE_CONTEXT, vmx->vpid, 0);
521 522
}

523 524 525 526 527 528 529 530 531
static inline void vpid_sync_vcpu_global(void)
{
	if (cpu_has_vmx_invvpid_global())
		__invvpid(VMX_VPID_EXTENT_ALL_CONTEXT, 0, 0);
}

static inline void vpid_sync_context(struct vcpu_vmx *vmx)
{
	if (cpu_has_vmx_invvpid_single())
532
		vpid_sync_vcpu_single(vmx);
533 534 535 536
	else
		vpid_sync_vcpu_global();
}

537 538 539 540 541 542 543 544
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)
{
545
	if (enable_ept) {
546 547 548 549 550 551 552 553 554
		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)
{
555
	if (enable_ept) {
556 557 558 559 560 561 562 563
		if (cpu_has_vmx_invept_individual_addr())
			__invept(VMX_EPT_EXTENT_INDIVIDUAL_ADDR,
					eptp, gpa);
		else
			ept_sync_context(eptp);
	}
}

A
Avi Kivity 已提交
564 565 566 567
static unsigned long vmcs_readl(unsigned long field)
{
	unsigned long value;

568
	asm volatile (__ex(ASM_VMX_VMREAD_RDX_RAX)
A
Avi Kivity 已提交
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
		      : "=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)
{
585
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
586 587 588 589 590 591
	return vmcs_readl(field);
#else
	return vmcs_readl(field) | ((u64)vmcs_readl(field+1) << 32);
#endif
}

592 593 594 595 596 597 598
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 已提交
599 600 601 602
static void vmcs_writel(unsigned long field, unsigned long value)
{
	u8 error;

603
	asm volatile (__ex(ASM_VMX_VMWRITE_RAX_RDX) "; setna %0"
M
Mike Day 已提交
604
		       : "=q"(error) : "a"(value), "d"(field) : "cc");
605 606
	if (unlikely(error))
		vmwrite_error(field, value);
A
Avi Kivity 已提交
607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
}

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);
622
#ifndef CONFIG_X86_64
A
Avi Kivity 已提交
623 624 625 626 627
	asm volatile ("");
	vmcs_writel(field+1, value >> 32);
#endif
}

628 629 630 631 632 633 634 635 636 637
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);
}

638 639 640 641
static void update_exception_bitmap(struct kvm_vcpu *vcpu)
{
	u32 eb;

J
Jan Kiszka 已提交
642 643 644 645 646 647
	eb = (1u << PF_VECTOR) | (1u << UD_VECTOR) | (1u << MC_VECTOR) |
	     (1u << NM_VECTOR) | (1u << DB_VECTOR);
	if ((vcpu->guest_debug &
	     (KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_SW_BP)) ==
	    (KVM_GUESTDBG_ENABLE | KVM_GUESTDBG_USE_SW_BP))
		eb |= 1u << BP_VECTOR;
648
	if (to_vmx(vcpu)->rmode.vm86_active)
649
		eb = ~0;
650
	if (enable_ept)
651
		eb &= ~(1u << PF_VECTOR); /* bypass_guest_pf = 0 */
652 653
	if (vcpu->fpu_active)
		eb &= ~(1u << NM_VECTOR);
654 655 656
	vmcs_write32(EXCEPTION_BITMAP, eb);
}

657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
static void clear_atomic_switch_msr(struct vcpu_vmx *vmx, unsigned msr)
{
	unsigned i;
	struct msr_autoload *m = &vmx->msr_autoload;

	for (i = 0; i < m->nr; ++i)
		if (m->guest[i].index == msr)
			break;

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

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

	for (i = 0; i < m->nr; ++i)
		if (m->guest[i].index == msr)
			break;

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

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

697 698 699 700 701
static void reload_tss(void)
{
	/*
	 * VT restores TR but not its size.  Useless.
	 */
702
	struct desc_ptr gdt;
703
	struct desc_struct *descs;
704

705
	native_store_gdt(&gdt);
706
	descs = (void *)gdt.address;
707 708 709 710
	descs[GDT_ENTRY_TSS].type = 9; /* available TSS */
	load_TR_desc();
}

A
Avi Kivity 已提交
711
static bool update_transition_efer(struct vcpu_vmx *vmx, int efer_offset)
712
{
R
Roel Kluin 已提交
713
	u64 guest_efer;
714 715
	u64 ignore_bits;

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

718 719 720 721 722 723 724 725 726 727 728 729 730
	/*
	 * 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;
731
	vmx->guest_msrs[efer_offset].data = guest_efer;
732
	vmx->guest_msrs[efer_offset].mask = ~ignore_bits;
733 734 735 736 737 738 739 740 741 742 743

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

744
	return true;
745 746
}

747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783
static unsigned long segment_base(u16 selector)
{
	struct desc_ptr gdt;
	struct desc_struct *d;
	unsigned long table_base;
	unsigned long v;

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

	native_store_gdt(&gdt);
	table_base = gdt.address;

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

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

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

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

784
static void vmx_save_host_state(struct kvm_vcpu *vcpu)
785
{
786
	struct vcpu_vmx *vmx = to_vmx(vcpu);
787
	int i;
788

789
	if (vmx->host_state.loaded)
790 791
		return;

792
	vmx->host_state.loaded = 1;
793 794 795 796
	/*
	 * Set host fs and gs selectors.  Unfortunately, 22.2.3 does not
	 * allow segment selectors with cpl > 0 or ti == 1.
	 */
797
	vmx->host_state.ldt_sel = kvm_read_ldt();
798
	vmx->host_state.gs_ldt_reload_needed = vmx->host_state.ldt_sel;
799
	vmx->host_state.fs_sel = kvm_read_fs();
800
	if (!(vmx->host_state.fs_sel & 7)) {
801
		vmcs_write16(HOST_FS_SELECTOR, vmx->host_state.fs_sel);
802 803
		vmx->host_state.fs_reload_needed = 0;
	} else {
804
		vmcs_write16(HOST_FS_SELECTOR, 0);
805
		vmx->host_state.fs_reload_needed = 1;
806
	}
807
	vmx->host_state.gs_sel = kvm_read_gs();
808 809
	if (!(vmx->host_state.gs_sel & 7))
		vmcs_write16(HOST_GS_SELECTOR, vmx->host_state.gs_sel);
810 811
	else {
		vmcs_write16(HOST_GS_SELECTOR, 0);
812
		vmx->host_state.gs_ldt_reload_needed = 1;
813 814 815 816 817 818
	}

#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
819 820
	vmcs_writel(HOST_FS_BASE, segment_base(vmx->host_state.fs_sel));
	vmcs_writel(HOST_GS_BASE, segment_base(vmx->host_state.gs_sel));
821
#endif
822 823

#ifdef CONFIG_X86_64
824 825 826 827
	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);
	}
828
#endif
829 830
	for (i = 0; i < vmx->save_nmsrs; ++i)
		kvm_set_shared_msr(vmx->guest_msrs[i].index,
831 832
				   vmx->guest_msrs[i].data,
				   vmx->guest_msrs[i].mask);
833 834
}

835
static void __vmx_load_host_state(struct vcpu_vmx *vmx)
836
{
837
	unsigned long flags;
838

839
	if (!vmx->host_state.loaded)
840 841
		return;

842
	++vmx->vcpu.stat.host_state_reload;
843
	vmx->host_state.loaded = 0;
844
	if (vmx->host_state.fs_reload_needed)
845
		kvm_load_fs(vmx->host_state.fs_sel);
846
	if (vmx->host_state.gs_ldt_reload_needed) {
847
		kvm_load_ldt(vmx->host_state.ldt_sel);
848 849 850 851
		/*
		 * If we have to reload gs, we must take care to
		 * preserve our gs base.
		 */
852
		local_irq_save(flags);
853
		kvm_load_gs(vmx->host_state.gs_sel);
854 855 856
#ifdef CONFIG_X86_64
		wrmsrl(MSR_GS_BASE, vmcs_readl(HOST_GS_BASE));
#endif
857
		local_irq_restore(flags);
858
	}
859
	reload_tss();
860 861 862 863 864 865
#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
866 867
	if (current_thread_info()->status & TS_USEDFPU)
		clts();
868 869
}

870 871 872 873 874 875 876
static void vmx_load_host_state(struct vcpu_vmx *vmx)
{
	preempt_disable();
	__vmx_load_host_state(vmx);
	preempt_enable();
}

A
Avi Kivity 已提交
877 878 879 880
/*
 * Switches to specified vcpu, until a matching vcpu_put(), but assumes
 * vcpu mutex is already taken.
 */
881
static void vmx_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
A
Avi Kivity 已提交
882
{
883
	struct vcpu_vmx *vmx = to_vmx(vcpu);
884
	u64 tsc_this, delta, new_offset;
885
	u64 phys_addr = __pa(per_cpu(vmxarea, cpu));
A
Avi Kivity 已提交
886

887 888 889
	if (!vmm_exclusive)
		kvm_cpu_vmxon(phys_addr);
	else if (vcpu->cpu != cpu)
R
Rusty Russell 已提交
890
		vcpu_clear(vmx);
A
Avi Kivity 已提交
891

892 893
	if (per_cpu(current_vmcs, cpu) != vmx->vmcs) {
		per_cpu(current_vmcs, cpu) = vmx->vmcs;
894
		vmcs_load(vmx->vmcs);
A
Avi Kivity 已提交
895 896 897
	}

	if (vcpu->cpu != cpu) {
898
		struct desc_ptr dt;
A
Avi Kivity 已提交
899 900
		unsigned long sysenter_esp;

901 902 903 904 905 906 907
		kvm_migrate_timers(vcpu);
		set_bit(KVM_REQ_TLB_FLUSH, &vcpu->requests);
		local_irq_disable();
		list_add(&vmx->local_vcpus_link,
			 &per_cpu(vcpus_on_cpu, cpu));
		local_irq_enable();

A
Avi Kivity 已提交
908 909 910 911 912
		vcpu->cpu = cpu;
		/*
		 * Linux uses per-cpu TSS and GDT, so set these when switching
		 * processors.
		 */
913
		vmcs_writel(HOST_TR_BASE, kvm_read_tr_base()); /* 22.2.4 */
914
		native_store_gdt(&dt);
915
		vmcs_writel(HOST_GDTR_BASE, dt.address);   /* 22.2.4 */
A
Avi Kivity 已提交
916 917 918

		rdmsrl(MSR_IA32_SYSENTER_ESP, sysenter_esp);
		vmcs_writel(HOST_IA32_SYSENTER_ESP, sysenter_esp); /* 22.2.3 */
919 920 921 922 923

		/*
		 * Make sure the time stamp counter is monotonous.
		 */
		rdtscll(tsc_this);
924 925 926 927 928
		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 已提交
929 930 931 932 933
	}
}

static void vmx_vcpu_put(struct kvm_vcpu *vcpu)
{
934
	__vmx_load_host_state(to_vmx(vcpu));
935
	if (!vmm_exclusive) {
936
		__vcpu_clear(to_vmx(vcpu));
937 938
		kvm_cpu_vmxoff();
	}
A
Avi Kivity 已提交
939 940
}

941 942
static void vmx_fpu_activate(struct kvm_vcpu *vcpu)
{
943 944
	ulong cr0;

945 946 947
	if (vcpu->fpu_active)
		return;
	vcpu->fpu_active = 1;
948 949 950 951
	cr0 = vmcs_readl(GUEST_CR0);
	cr0 &= ~(X86_CR0_TS | X86_CR0_MP);
	cr0 |= kvm_read_cr0_bits(vcpu, X86_CR0_TS | X86_CR0_MP);
	vmcs_writel(GUEST_CR0, cr0);
952
	update_exception_bitmap(vcpu);
953 954
	vcpu->arch.cr0_guest_owned_bits = X86_CR0_TS;
	vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits);
955 956
}

957 958
static void vmx_decache_cr0_guest_bits(struct kvm_vcpu *vcpu);

959 960
static void vmx_fpu_deactivate(struct kvm_vcpu *vcpu)
{
961
	vmx_decache_cr0_guest_bits(vcpu);
962
	vmcs_set_bits(GUEST_CR0, X86_CR0_TS | X86_CR0_MP);
963
	update_exception_bitmap(vcpu);
964 965 966
	vcpu->arch.cr0_guest_owned_bits = 0;
	vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits);
	vmcs_writel(CR0_READ_SHADOW, vcpu->arch.cr0);
967 968
}

A
Avi Kivity 已提交
969 970
static unsigned long vmx_get_rflags(struct kvm_vcpu *vcpu)
{
971
	unsigned long rflags, save_rflags;
972 973

	rflags = vmcs_readl(GUEST_RFLAGS);
974 975 976 977 978
	if (to_vmx(vcpu)->rmode.vm86_active) {
		rflags &= RMODE_GUEST_OWNED_EFLAGS_BITS;
		save_rflags = to_vmx(vcpu)->rmode.save_rflags;
		rflags |= save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS;
	}
979
	return rflags;
A
Avi Kivity 已提交
980 981 982 983
}

static void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags)
{
984 985
	if (to_vmx(vcpu)->rmode.vm86_active) {
		to_vmx(vcpu)->rmode.save_rflags = rflags;
986
		rflags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM;
987
	}
A
Avi Kivity 已提交
988 989 990
	vmcs_writel(GUEST_RFLAGS, rflags);
}

991 992 993 994 995 996
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)
997
		ret |= KVM_X86_SHADOW_INT_STI;
998
	if (interruptibility & GUEST_INTR_STATE_MOV_SS)
999
		ret |= KVM_X86_SHADOW_INT_MOV_SS;
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010

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

1011
	if (mask & KVM_X86_SHADOW_INT_MOV_SS)
1012
		interruptibility |= GUEST_INTR_STATE_MOV_SS;
1013
	else if (mask & KVM_X86_SHADOW_INT_STI)
1014 1015 1016 1017 1018 1019
		interruptibility |= GUEST_INTR_STATE_STI;

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

A
Avi Kivity 已提交
1020 1021 1022 1023
static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
{
	unsigned long rip;

1024
	rip = kvm_rip_read(vcpu);
A
Avi Kivity 已提交
1025
	rip += vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
1026
	kvm_rip_write(vcpu, rip);
A
Avi Kivity 已提交
1027

1028 1029
	/* skipping an emulated instruction also counts */
	vmx_set_interrupt_shadow(vcpu, 0);
A
Avi Kivity 已提交
1030 1031
}

1032
static void vmx_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
1033 1034
				bool has_error_code, u32 error_code,
				bool reinject)
1035
{
1036
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1037
	u32 intr_info = nr | INTR_INFO_VALID_MASK;
1038

1039
	if (has_error_code) {
1040
		vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, error_code);
1041 1042
		intr_info |= INTR_INFO_DELIVER_CODE_MASK;
	}
1043

1044
	if (vmx->rmode.vm86_active) {
1045 1046 1047
		vmx->rmode.irq.pending = true;
		vmx->rmode.irq.vector = nr;
		vmx->rmode.irq.rip = kvm_rip_read(vcpu);
1048 1049 1050
		if (kvm_exception_is_soft(nr))
			vmx->rmode.irq.rip +=
				vmx->vcpu.arch.event_exit_inst_len;
1051 1052
		intr_info |= INTR_TYPE_SOFT_INTR;
		vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info);
1053 1054 1055 1056 1057
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, 1);
		kvm_rip_write(vcpu, vmx->rmode.irq.rip - 1);
		return;
	}

1058 1059 1060
	if (kvm_exception_is_soft(nr)) {
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN,
			     vmx->vcpu.arch.event_exit_inst_len);
1061 1062 1063 1064 1065
		intr_info |= INTR_TYPE_SOFT_EXCEPTION;
	} else
		intr_info |= INTR_TYPE_HARD_EXCEPTION;

	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info);
1066 1067
}

1068 1069 1070 1071 1072
static bool vmx_rdtscp_supported(void)
{
	return cpu_has_vmx_rdtscp();
}

1073 1074 1075
/*
 * Swap MSR entry in host/guest MSR entry array.
 */
R
Rusty Russell 已提交
1076
static void move_msr_up(struct vcpu_vmx *vmx, int from, int to)
1077
{
1078
	struct shared_msr_entry tmp;
1079 1080 1081 1082

	tmp = vmx->guest_msrs[to];
	vmx->guest_msrs[to] = vmx->guest_msrs[from];
	vmx->guest_msrs[from] = tmp;
1083 1084
}

1085 1086 1087 1088 1089
/*
 * 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 已提交
1090
static void setup_msrs(struct vcpu_vmx *vmx)
1091
{
1092
	int save_nmsrs, index;
1093
	unsigned long *msr_bitmap;
1094

1095
	vmx_load_host_state(vmx);
1096 1097
	save_nmsrs = 0;
#ifdef CONFIG_X86_64
R
Rusty Russell 已提交
1098 1099
	if (is_long_mode(&vmx->vcpu)) {
		index = __find_msr_index(vmx, MSR_SYSCALL_MASK);
1100
		if (index >= 0)
R
Rusty Russell 已提交
1101 1102
			move_msr_up(vmx, index, save_nmsrs++);
		index = __find_msr_index(vmx, MSR_LSTAR);
1103
		if (index >= 0)
R
Rusty Russell 已提交
1104 1105
			move_msr_up(vmx, index, save_nmsrs++);
		index = __find_msr_index(vmx, MSR_CSTAR);
1106
		if (index >= 0)
R
Rusty Russell 已提交
1107
			move_msr_up(vmx, index, save_nmsrs++);
1108 1109 1110
		index = __find_msr_index(vmx, MSR_TSC_AUX);
		if (index >= 0 && vmx->rdtscp_enabled)
			move_msr_up(vmx, index, save_nmsrs++);
1111 1112 1113 1114
		/*
		 * MSR_K6_STAR is only needed on long mode guests, and only
		 * if efer.sce is enabled.
		 */
R
Rusty Russell 已提交
1115
		index = __find_msr_index(vmx, MSR_K6_STAR);
1116
		if ((index >= 0) && (vmx->vcpu.arch.efer & EFER_SCE))
R
Rusty Russell 已提交
1117
			move_msr_up(vmx, index, save_nmsrs++);
1118 1119
	}
#endif
A
Avi Kivity 已提交
1120 1121
	index = __find_msr_index(vmx, MSR_EFER);
	if (index >= 0 && update_transition_efer(vmx, index))
1122
		move_msr_up(vmx, index, save_nmsrs++);
1123

1124
	vmx->save_nmsrs = save_nmsrs;
1125 1126 1127 1128 1129 1130 1131 1132 1133

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

A
Avi Kivity 已提交
1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
/*
 * 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
 */
1153
static void guest_write_tsc(u64 guest_tsc, u64 host_tsc)
A
Avi Kivity 已提交
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
{
	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;
1166
	struct shared_msr_entry *msr;
A
Avi Kivity 已提交
1167 1168 1169 1170 1171 1172 1173

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

	switch (msr_index) {
1174
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
1175 1176 1177 1178 1179 1180
	case MSR_FS_BASE:
		data = vmcs_readl(GUEST_FS_BASE);
		break;
	case MSR_GS_BASE:
		data = vmcs_readl(GUEST_GS_BASE);
		break;
1181 1182 1183 1184
	case MSR_KERNEL_GS_BASE:
		vmx_load_host_state(to_vmx(vcpu));
		data = to_vmx(vcpu)->msr_guest_kernel_gs_base;
		break;
1185
#endif
A
Avi Kivity 已提交
1186
	case MSR_EFER:
1187
		return kvm_get_msr_common(vcpu, msr_index, pdata);
1188
	case MSR_IA32_TSC:
A
Avi Kivity 已提交
1189 1190 1191 1192 1193 1194
		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 已提交
1195
		data = vmcs_readl(GUEST_SYSENTER_EIP);
A
Avi Kivity 已提交
1196 1197
		break;
	case MSR_IA32_SYSENTER_ESP:
A
Avi Kivity 已提交
1198
		data = vmcs_readl(GUEST_SYSENTER_ESP);
A
Avi Kivity 已提交
1199
		break;
1200 1201 1202 1203
	case MSR_TSC_AUX:
		if (!to_vmx(vcpu)->rdtscp_enabled)
			return 1;
		/* Otherwise falls through */
A
Avi Kivity 已提交
1204
	default:
1205
		vmx_load_host_state(to_vmx(vcpu));
R
Rusty Russell 已提交
1206
		msr = find_msr_entry(to_vmx(vcpu), msr_index);
1207
		if (msr) {
1208
			vmx_load_host_state(to_vmx(vcpu));
1209 1210
			data = msr->data;
			break;
A
Avi Kivity 已提交
1211
		}
1212
		return kvm_get_msr_common(vcpu, msr_index, pdata);
A
Avi Kivity 已提交
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
	}

	*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)
{
1226
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1227
	struct shared_msr_entry *msr;
1228
	u64 host_tsc;
1229 1230
	int ret = 0;

A
Avi Kivity 已提交
1231
	switch (msr_index) {
1232
	case MSR_EFER:
1233
		vmx_load_host_state(vmx);
1234 1235
		ret = kvm_set_msr_common(vcpu, msr_index, data);
		break;
1236
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
1237 1238 1239 1240 1241 1242
	case MSR_FS_BASE:
		vmcs_writel(GUEST_FS_BASE, data);
		break;
	case MSR_GS_BASE:
		vmcs_writel(GUEST_GS_BASE, data);
		break;
1243 1244 1245 1246
	case MSR_KERNEL_GS_BASE:
		vmx_load_host_state(vmx);
		vmx->msr_guest_kernel_gs_base = data;
		break;
A
Avi Kivity 已提交
1247 1248 1249 1250 1251
#endif
	case MSR_IA32_SYSENTER_CS:
		vmcs_write32(GUEST_SYSENTER_CS, data);
		break;
	case MSR_IA32_SYSENTER_EIP:
A
Avi Kivity 已提交
1252
		vmcs_writel(GUEST_SYSENTER_EIP, data);
A
Avi Kivity 已提交
1253 1254
		break;
	case MSR_IA32_SYSENTER_ESP:
A
Avi Kivity 已提交
1255
		vmcs_writel(GUEST_SYSENTER_ESP, data);
A
Avi Kivity 已提交
1256
		break;
1257
	case MSR_IA32_TSC:
1258 1259
		rdtscll(host_tsc);
		guest_write_tsc(data, host_tsc);
A
Avi Kivity 已提交
1260
		break;
S
Sheng Yang 已提交
1261 1262 1263 1264 1265 1266
	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;
		}
1267 1268 1269 1270 1271 1272 1273 1274 1275
		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 已提交
1276
	default:
R
Rusty Russell 已提交
1277
		msr = find_msr_entry(vmx, msr_index);
1278
		if (msr) {
1279
			vmx_load_host_state(vmx);
1280 1281
			msr->data = data;
			break;
A
Avi Kivity 已提交
1282
		}
1283
		ret = kvm_set_msr_common(vcpu, msr_index, data);
A
Avi Kivity 已提交
1284 1285
	}

1286
	return ret;
A
Avi Kivity 已提交
1287 1288
}

1289
static void vmx_cache_reg(struct kvm_vcpu *vcpu, enum kvm_reg reg)
A
Avi Kivity 已提交
1290
{
1291 1292 1293 1294 1295 1296 1297 1298
	__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 已提交
1299 1300 1301 1302
	case VCPU_EXREG_PDPTR:
		if (enable_ept)
			ept_save_pdptrs(vcpu);
		break;
1303 1304 1305
	default:
		break;
	}
A
Avi Kivity 已提交
1306 1307
}

1308
static void set_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg)
A
Avi Kivity 已提交
1309
{
1310 1311 1312 1313 1314
	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);

1315
	update_exception_bitmap(vcpu);
A
Avi Kivity 已提交
1316 1317 1318 1319
}

static __init int cpu_has_kvm_support(void)
{
1320
	return cpu_has_vmx();
A
Avi Kivity 已提交
1321 1322 1323 1324 1325 1326 1327
}

static __init int vmx_disabled_by_bios(void)
{
	u64 msr;

	rdmsrl(MSR_IA32_FEATURE_CONTROL, msr);
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
	if (msr & FEATURE_CONTROL_LOCKED) {
		if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX)
			&& tboot_enabled())
			return 1;
		if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX)
			&& !tboot_enabled())
			return 1;
	}

	return 0;
1338
	/* locked but not enabled */
A
Avi Kivity 已提交
1339 1340
}

1341 1342 1343 1344 1345 1346 1347
static void kvm_cpu_vmxon(u64 addr)
{
	asm volatile (ASM_VMX_VMXON_RAX
			: : "a"(&addr), "m"(addr)
			: "memory", "cc");
}

1348
static int hardware_enable(void *garbage)
A
Avi Kivity 已提交
1349 1350 1351
{
	int cpu = raw_smp_processor_id();
	u64 phys_addr = __pa(per_cpu(vmxarea, cpu));
1352
	u64 old, test_bits;
A
Avi Kivity 已提交
1353

1354 1355 1356
	if (read_cr4() & X86_CR4_VMXE)
		return -EBUSY;

1357
	INIT_LIST_HEAD(&per_cpu(vcpus_on_cpu, cpu));
A
Avi Kivity 已提交
1358
	rdmsrl(MSR_IA32_FEATURE_CONTROL, old);
1359 1360 1361 1362 1363 1364 1365

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

	if ((old & test_bits) != test_bits) {
A
Avi Kivity 已提交
1366
		/* enable and lock */
1367 1368
		wrmsrl(MSR_IA32_FEATURE_CONTROL, old | test_bits);
	}
1369
	write_cr4(read_cr4() | X86_CR4_VMXE); /* FIXME: not cpu hotplug safe */
1370

1371 1372 1373 1374
	if (vmm_exclusive) {
		kvm_cpu_vmxon(phys_addr);
		ept_sync_global();
	}
1375 1376

	return 0;
A
Avi Kivity 已提交
1377 1378
}

1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
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);
}

1389 1390 1391 1392 1393

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

1398 1399
static void hardware_disable(void *garbage)
{
1400 1401 1402 1403
	if (vmm_exclusive) {
		vmclear_local_vcpus();
		kvm_cpu_vmxoff();
	}
1404
	write_cr4(read_cr4() & ~X86_CR4_VMXE);
1405 1406
}

1407
static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt,
M
Mike Day 已提交
1408
				      u32 msr, u32 *result)
1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
{
	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 已提交
1420
		return -EIO;
1421 1422 1423 1424 1425

	*result = ctl;
	return 0;
}

Y
Yang, Sheng 已提交
1426
static __init int setup_vmcs_config(struct vmcs_config *vmcs_conf)
A
Avi Kivity 已提交
1427 1428
{
	u32 vmx_msr_low, vmx_msr_high;
S
Sheng Yang 已提交
1429
	u32 min, opt, min2, opt2;
1430 1431
	u32 _pin_based_exec_control = 0;
	u32 _cpu_based_exec_control = 0;
1432
	u32 _cpu_based_2nd_exec_control = 0;
1433 1434 1435 1436
	u32 _vmexit_control = 0;
	u32 _vmentry_control = 0;

	min = PIN_BASED_EXT_INTR_MASK | PIN_BASED_NMI_EXITING;
1437
	opt = PIN_BASED_VIRTUAL_NMIS;
1438 1439
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PINBASED_CTLS,
				&_pin_based_exec_control) < 0)
Y
Yang, Sheng 已提交
1440
		return -EIO;
1441 1442 1443 1444 1445 1446

	min = CPU_BASED_HLT_EXITING |
#ifdef CONFIG_X86_64
	      CPU_BASED_CR8_LOAD_EXITING |
	      CPU_BASED_CR8_STORE_EXITING |
#endif
S
Sheng Yang 已提交
1447 1448
	      CPU_BASED_CR3_LOAD_EXITING |
	      CPU_BASED_CR3_STORE_EXITING |
1449 1450
	      CPU_BASED_USE_IO_BITMAPS |
	      CPU_BASED_MOV_DR_EXITING |
M
Marcelo Tosatti 已提交
1451
	      CPU_BASED_USE_TSC_OFFSETING |
1452 1453
	      CPU_BASED_MWAIT_EXITING |
	      CPU_BASED_MONITOR_EXITING |
M
Marcelo Tosatti 已提交
1454
	      CPU_BASED_INVLPG_EXITING;
1455
	opt = CPU_BASED_TPR_SHADOW |
S
Sheng Yang 已提交
1456
	      CPU_BASED_USE_MSR_BITMAPS |
1457
	      CPU_BASED_ACTIVATE_SECONDARY_CONTROLS;
1458 1459
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PROCBASED_CTLS,
				&_cpu_based_exec_control) < 0)
Y
Yang, Sheng 已提交
1460
		return -EIO;
1461 1462 1463 1464 1465
#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
1466
	if (_cpu_based_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) {
S
Sheng Yang 已提交
1467 1468
		min2 = 0;
		opt2 = SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES |
1469
			SECONDARY_EXEC_WBINVD_EXITING |
S
Sheng Yang 已提交
1470
			SECONDARY_EXEC_ENABLE_VPID |
1471
			SECONDARY_EXEC_ENABLE_EPT |
1472
			SECONDARY_EXEC_UNRESTRICTED_GUEST |
1473 1474
			SECONDARY_EXEC_PAUSE_LOOP_EXITING |
			SECONDARY_EXEC_RDTSCP;
S
Sheng Yang 已提交
1475 1476
		if (adjust_vmx_controls(min2, opt2,
					MSR_IA32_VMX_PROCBASED_CTLS2,
1477 1478 1479 1480 1481 1482 1483 1484
					&_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 已提交
1485
	if (_cpu_based_2nd_exec_control & SECONDARY_EXEC_ENABLE_EPT) {
M
Marcelo Tosatti 已提交
1486 1487
		/* CR3 accesses and invlpg don't need to cause VM Exits when EPT
		   enabled */
1488 1489 1490
		_cpu_based_exec_control &= ~(CPU_BASED_CR3_LOAD_EXITING |
					     CPU_BASED_CR3_STORE_EXITING |
					     CPU_BASED_INVLPG_EXITING);
S
Sheng Yang 已提交
1491 1492 1493
		rdmsr(MSR_IA32_VMX_EPT_VPID_CAP,
		      vmx_capability.ept, vmx_capability.vpid);
	}
1494 1495 1496 1497 1498

	min = 0;
#ifdef CONFIG_X86_64
	min |= VM_EXIT_HOST_ADDR_SPACE_SIZE;
#endif
S
Sheng Yang 已提交
1499
	opt = VM_EXIT_SAVE_IA32_PAT | VM_EXIT_LOAD_IA32_PAT;
1500 1501
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_EXIT_CTLS,
				&_vmexit_control) < 0)
Y
Yang, Sheng 已提交
1502
		return -EIO;
1503

S
Sheng Yang 已提交
1504 1505
	min = 0;
	opt = VM_ENTRY_LOAD_IA32_PAT;
1506 1507
	if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_ENTRY_CTLS,
				&_vmentry_control) < 0)
Y
Yang, Sheng 已提交
1508
		return -EIO;
A
Avi Kivity 已提交
1509

N
Nguyen Anh Quynh 已提交
1510
	rdmsr(MSR_IA32_VMX_BASIC, vmx_msr_low, vmx_msr_high);
1511 1512 1513

	/* IA-32 SDM Vol 3B: VMCS size is never greater than 4kB. */
	if ((vmx_msr_high & 0x1fff) > PAGE_SIZE)
Y
Yang, Sheng 已提交
1514
		return -EIO;
1515 1516 1517 1518

#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 已提交
1519
		return -EIO;
1520 1521 1522 1523
#endif

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

Y
Yang, Sheng 已提交
1526 1527 1528
	vmcs_conf->size = vmx_msr_high & 0x1fff;
	vmcs_conf->order = get_order(vmcs_config.size);
	vmcs_conf->revision_id = vmx_msr_low;
1529

Y
Yang, Sheng 已提交
1530 1531
	vmcs_conf->pin_based_exec_ctrl = _pin_based_exec_control;
	vmcs_conf->cpu_based_exec_ctrl = _cpu_based_exec_control;
1532
	vmcs_conf->cpu_based_2nd_exec_ctrl = _cpu_based_2nd_exec_control;
Y
Yang, Sheng 已提交
1533 1534
	vmcs_conf->vmexit_ctrl         = _vmexit_control;
	vmcs_conf->vmentry_ctrl        = _vmentry_control;
1535 1536

	return 0;
N
Nguyen Anh Quynh 已提交
1537
}
A
Avi Kivity 已提交
1538 1539 1540 1541 1542 1543 1544

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

1545
	pages = alloc_pages_exact_node(node, GFP_KERNEL, vmcs_config.order);
A
Avi Kivity 已提交
1546 1547 1548
	if (!pages)
		return NULL;
	vmcs = page_address(pages);
1549 1550
	memset(vmcs, 0, vmcs_config.size);
	vmcs->revision_id = vmcs_config.revision_id; /* vmcs revision id */
A
Avi Kivity 已提交
1551 1552 1553 1554 1555
	return vmcs;
}

static struct vmcs *alloc_vmcs(void)
{
1556
	return alloc_vmcs_cpu(raw_smp_processor_id());
A
Avi Kivity 已提交
1557 1558 1559 1560
}

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

1564
static void free_kvm_area(void)
A
Avi Kivity 已提交
1565 1566 1567
{
	int cpu;

Z
Zachary Amsden 已提交
1568
	for_each_possible_cpu(cpu) {
A
Avi Kivity 已提交
1569
		free_vmcs(per_cpu(vmxarea, cpu));
Z
Zachary Amsden 已提交
1570 1571
		per_cpu(vmxarea, cpu) = NULL;
	}
A
Avi Kivity 已提交
1572 1573 1574 1575 1576 1577
}

static __init int alloc_kvm_area(void)
{
	int cpu;

Z
Zachary Amsden 已提交
1578
	for_each_possible_cpu(cpu) {
A
Avi Kivity 已提交
1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
		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 已提交
1594 1595
	if (setup_vmcs_config(&vmcs_config) < 0)
		return -EIO;
1596 1597 1598 1599

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

S
Sheng Yang 已提交
1600 1601 1602
	if (!cpu_has_vmx_vpid())
		enable_vpid = 0;

1603 1604
	if (!cpu_has_vmx_ept() ||
	    !cpu_has_vmx_ept_4levels()) {
S
Sheng Yang 已提交
1605
		enable_ept = 0;
1606 1607 1608 1609 1610
		enable_unrestricted_guest = 0;
	}

	if (!cpu_has_vmx_unrestricted_guest())
		enable_unrestricted_guest = 0;
S
Sheng Yang 已提交
1611 1612 1613 1614

	if (!cpu_has_vmx_flexpriority())
		flexpriority_enabled = 0;

1615 1616 1617
	if (!cpu_has_vmx_tpr_shadow())
		kvm_x86_ops->update_cr8_intercept = NULL;

1618 1619 1620
	if (enable_ept && !cpu_has_vmx_ept_2m_page())
		kvm_disable_largepages();

1621 1622 1623
	if (!cpu_has_vmx_ple())
		ple_gap = 0;

A
Avi Kivity 已提交
1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635
	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];

1636
	if (vmcs_readl(sf->base) == save->base && (save->base & AR_S_MASK)) {
A
Avi Kivity 已提交
1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650
		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;
1651
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Avi Kivity 已提交
1652

1653
	vmx->emulation_required = 1;
1654
	vmx->rmode.vm86_active = 0;
A
Avi Kivity 已提交
1655

1656 1657 1658
	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 已提交
1659 1660

	flags = vmcs_readl(GUEST_RFLAGS);
1661 1662
	flags &= RMODE_GUEST_OWNED_EFLAGS_BITS;
	flags |= vmx->rmode.save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS;
A
Avi Kivity 已提交
1663 1664
	vmcs_writel(GUEST_RFLAGS, flags);

1665 1666
	vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~X86_CR4_VME) |
			(vmcs_readl(CR4_READ_SHADOW) & X86_CR4_VME));
A
Avi Kivity 已提交
1667 1668 1669

	update_exception_bitmap(vcpu);

1670 1671 1672
	if (emulate_invalid_guest_state)
		return;

1673 1674 1675 1676
	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 已提交
1677 1678 1679 1680 1681 1682 1683 1684 1685

	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 已提交
1686
static gva_t rmode_tss_base(struct kvm *kvm)
A
Avi Kivity 已提交
1687
{
1688
	if (!kvm->arch.tss_addr) {
1689 1690 1691
		struct kvm_memslots *slots;
		gfn_t base_gfn;

1692
		slots = kvm_memslots(kvm);
1693
		base_gfn = slots->memslots[0].base_gfn +
1694
				 kvm->memslots->memslots[0].npages - 3;
1695 1696
		return base_gfn << PAGE_SHIFT;
	}
1697
	return kvm->arch.tss_addr;
A
Avi Kivity 已提交
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707
}

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);
1708 1709
	vmcs_write16(sf->selector, save->base >> 4);
	vmcs_write32(sf->base, save->base & 0xfffff);
A
Avi Kivity 已提交
1710 1711 1712 1713 1714 1715 1716
	vmcs_write32(sf->limit, 0xffff);
	vmcs_write32(sf->ar_bytes, 0xf3);
}

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

1719 1720 1721
	if (enable_unrestricted_guest)
		return;

1722
	vmx->emulation_required = 1;
1723
	vmx->rmode.vm86_active = 1;
A
Avi Kivity 已提交
1724

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

1728
	vmx->rmode.tr.limit = vmcs_read32(GUEST_TR_LIMIT);
A
Avi Kivity 已提交
1729 1730
	vmcs_write32(GUEST_TR_LIMIT, RMODE_TSS_SIZE - 1);

1731
	vmx->rmode.tr.ar = vmcs_read32(GUEST_TR_AR_BYTES);
A
Avi Kivity 已提交
1732 1733 1734
	vmcs_write32(GUEST_TR_AR_BYTES, 0x008b);

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

1737
	flags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM;
A
Avi Kivity 已提交
1738 1739

	vmcs_writel(GUEST_RFLAGS, flags);
1740
	vmcs_writel(GUEST_CR4, vmcs_readl(GUEST_CR4) | X86_CR4_VME);
A
Avi Kivity 已提交
1741 1742
	update_exception_bitmap(vcpu);

1743 1744 1745
	if (emulate_invalid_guest_state)
		goto continue_rmode;

A
Avi Kivity 已提交
1746 1747 1748 1749 1750
	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);
1751
	vmcs_write32(GUEST_CS_LIMIT, 0xffff);
1752 1753
	if (vmcs_readl(GUEST_CS_BASE) == 0xffff0000)
		vmcs_writel(GUEST_CS_BASE, 0xf0000);
A
Avi Kivity 已提交
1754 1755
	vmcs_write16(GUEST_CS_SELECTOR, vmcs_readl(GUEST_CS_BASE) >> 4);

1756 1757 1758 1759
	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);
1760

1761
continue_rmode:
1762
	kvm_mmu_reset_context(vcpu);
1763
	init_rmode(vcpu->kvm);
A
Avi Kivity 已提交
1764 1765
}

1766 1767 1768
static void vmx_set_efer(struct kvm_vcpu *vcpu, u64 efer)
{
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1769 1770 1771 1772
	struct shared_msr_entry *msr = find_msr_entry(vmx, MSR_EFER);

	if (!msr)
		return;
1773

1774 1775 1776 1777 1778
	/*
	 * 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));
1779
	vcpu->arch.efer = efer;
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794
	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);
}

1795
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
1796 1797 1798 1799 1800 1801 1802 1803

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",
1804
		       __func__);
A
Avi Kivity 已提交
1805 1806 1807 1808
		vmcs_write32(GUEST_TR_AR_BYTES,
			     (guest_tr_ar & ~AR_TYPE_MASK)
			     | AR_TYPE_BUSY_64_TSS);
	}
1809
	vmx_set_efer(vcpu, vcpu->arch.efer | EFER_LMA);
A
Avi Kivity 已提交
1810 1811 1812 1813 1814 1815
}

static void exit_lmode(struct kvm_vcpu *vcpu)
{
	vmcs_write32(VM_ENTRY_CONTROLS,
		     vmcs_read32(VM_ENTRY_CONTROLS)
1816
		     & ~VM_ENTRY_IA32E_MODE);
1817
	vmx_set_efer(vcpu, vcpu->arch.efer & ~EFER_LMA);
A
Avi Kivity 已提交
1818 1819 1820 1821
}

#endif

1822 1823
static void vmx_flush_tlb(struct kvm_vcpu *vcpu)
{
1824
	vpid_sync_context(to_vmx(vcpu));
1825
	if (enable_ept)
1826
		ept_sync_context(construct_eptp(vcpu->arch.mmu.root_hpa));
1827 1828
}

1829 1830 1831 1832 1833 1834 1835 1836
static void vmx_decache_cr0_guest_bits(struct kvm_vcpu *vcpu)
{
	ulong cr0_guest_owned_bits = vcpu->arch.cr0_guest_owned_bits;

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

1837
static void vmx_decache_cr4_guest_bits(struct kvm_vcpu *vcpu)
1838
{
1839 1840 1841 1842
	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;
1843 1844
}

1845 1846
static void ept_load_pdptrs(struct kvm_vcpu *vcpu)
{
A
Avi Kivity 已提交
1847 1848 1849 1850
	if (!test_bit(VCPU_EXREG_PDPTR,
		      (unsigned long *)&vcpu->arch.regs_dirty))
		return;

1851 1852 1853 1854 1855 1856 1857 1858
	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]);
	}
}

1859 1860 1861 1862 1863 1864 1865 1866
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 已提交
1867 1868 1869 1870 1871

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

1874 1875 1876 1877 1878 1879 1880 1881 1882
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,
1883
			     vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) |
1884 1885 1886
			     (CPU_BASED_CR3_LOAD_EXITING |
			      CPU_BASED_CR3_STORE_EXITING));
		vcpu->arch.cr0 = cr0;
1887
		vmx_set_cr4(vcpu, kvm_read_cr4(vcpu));
1888 1889 1890
	} else if (!is_paging(vcpu)) {
		/* From nonpaging to paging */
		vmcs_write32(CPU_BASED_VM_EXEC_CONTROL,
1891
			     vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) &
1892 1893 1894
			     ~(CPU_BASED_CR3_LOAD_EXITING |
			       CPU_BASED_CR3_STORE_EXITING));
		vcpu->arch.cr0 = cr0;
1895
		vmx_set_cr4(vcpu, kvm_read_cr4(vcpu));
1896
	}
1897 1898 1899

	if (!(cr0 & X86_CR0_WP))
		*hw_cr0 &= ~X86_CR0_WP;
1900 1901
}

A
Avi Kivity 已提交
1902 1903
static void vmx_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
{
1904
	struct vcpu_vmx *vmx = to_vmx(vcpu);
1905 1906 1907 1908 1909 1910 1911
	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;
1912

1913
	if (vmx->rmode.vm86_active && (cr0 & X86_CR0_PE))
A
Avi Kivity 已提交
1914 1915
		enter_pmode(vcpu);

1916
	if (!vmx->rmode.vm86_active && !(cr0 & X86_CR0_PE))
A
Avi Kivity 已提交
1917 1918
		enter_rmode(vcpu);

1919
#ifdef CONFIG_X86_64
1920
	if (vcpu->arch.efer & EFER_LME) {
1921
		if (!is_paging(vcpu) && (cr0 & X86_CR0_PG))
A
Avi Kivity 已提交
1922
			enter_lmode(vcpu);
1923
		if (is_paging(vcpu) && !(cr0 & X86_CR0_PG))
A
Avi Kivity 已提交
1924 1925 1926 1927
			exit_lmode(vcpu);
	}
#endif

1928
	if (enable_ept)
1929 1930
		ept_update_paging_mode_cr0(&hw_cr0, cr0, vcpu);

1931
	if (!vcpu->fpu_active)
1932
		hw_cr0 |= X86_CR0_TS | X86_CR0_MP;
1933

A
Avi Kivity 已提交
1934
	vmcs_writel(CR0_READ_SHADOW, cr0);
1935
	vmcs_writel(GUEST_CR0, hw_cr0);
1936
	vcpu->arch.cr0 = cr0;
A
Avi Kivity 已提交
1937 1938
}

1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
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 已提交
1951 1952
static void vmx_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
{
1953 1954 1955 1956
	unsigned long guest_cr3;
	u64 eptp;

	guest_cr3 = cr3;
1957
	if (enable_ept) {
1958 1959 1960
		eptp = construct_eptp(cr3);
		vmcs_write64(EPT_POINTER, eptp);
		guest_cr3 = is_paging(vcpu) ? vcpu->arch.cr3 :
1961
			vcpu->kvm->arch.ept_identity_map_addr;
1962
		ept_load_pdptrs(vcpu);
1963 1964
	}

1965
	vmx_flush_tlb(vcpu);
1966
	vmcs_writel(GUEST_CR3, guest_cr3);
A
Avi Kivity 已提交
1967 1968 1969 1970
}

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

1974
	vcpu->arch.cr4 = cr4;
1975 1976 1977 1978 1979 1980 1981 1982
	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;
		}
	}
1983 1984 1985

	vmcs_writel(CR4_READ_SHADOW, cr4);
	vmcs_writel(GUEST_CR4, hw_cr4);
A
Avi Kivity 已提交
1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
}

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);
2005
	if ((ar & AR_UNUSABLE_MASK) && !emulate_invalid_guest_state)
A
Avi Kivity 已提交
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017
		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;
}

2018 2019
static int vmx_get_cpl(struct kvm_vcpu *vcpu)
{
2020
	if (!is_protmode(vcpu))
2021 2022 2023 2024 2025
		return 0;

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

A
Avi Kivity 已提交
2026
	return vmcs_read16(GUEST_CS_SELECTOR) & 3;
2027 2028
}

2029
static u32 vmx_segment_access_rights(struct kvm_segment *var)
A
Avi Kivity 已提交
2030 2031 2032
{
	u32 ar;

2033
	if (var->unusable)
A
Avi Kivity 已提交
2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044
		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;
	}
2045 2046
	if (ar == 0) /* a 0 value means unusable */
		ar = AR_UNUSABLE_MASK;
2047 2048 2049 2050 2051 2052 2053

	return ar;
}

static void vmx_set_segment(struct kvm_vcpu *vcpu,
			    struct kvm_segment *var, int seg)
{
2054
	struct vcpu_vmx *vmx = to_vmx(vcpu);
2055 2056 2057
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
	u32 ar;

2058 2059 2060 2061 2062
	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);
2063 2064 2065 2066 2067
		return;
	}
	vmcs_writel(sf->base, var->base);
	vmcs_write32(sf->limit, var->limit);
	vmcs_write16(sf->selector, var->selector);
2068
	if (vmx->rmode.vm86_active && var->s) {
2069 2070 2071 2072 2073 2074 2075 2076
		/*
		 * 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);
2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091

	/*
	 *   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 已提交
2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
	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;
}

2103
static void vmx_get_idt(struct kvm_vcpu *vcpu, struct desc_ptr *dt)
A
Avi Kivity 已提交
2104
{
2105 2106
	dt->size = vmcs_read32(GUEST_IDTR_LIMIT);
	dt->address = vmcs_readl(GUEST_IDTR_BASE);
A
Avi Kivity 已提交
2107 2108
}

2109
static void vmx_set_idt(struct kvm_vcpu *vcpu, struct desc_ptr *dt)
A
Avi Kivity 已提交
2110
{
2111 2112
	vmcs_write32(GUEST_IDTR_LIMIT, dt->size);
	vmcs_writel(GUEST_IDTR_BASE, dt->address);
A
Avi Kivity 已提交
2113 2114
}

2115
static void vmx_get_gdt(struct kvm_vcpu *vcpu, struct desc_ptr *dt)
A
Avi Kivity 已提交
2116
{
2117 2118
	dt->size = vmcs_read32(GUEST_GDTR_LIMIT);
	dt->address = vmcs_readl(GUEST_GDTR_BASE);
A
Avi Kivity 已提交
2119 2120
}

2121
static void vmx_set_gdt(struct kvm_vcpu *vcpu, struct desc_ptr *dt)
A
Avi Kivity 已提交
2122
{
2123 2124
	vmcs_write32(GUEST_GDTR_LIMIT, dt->size);
	vmcs_writel(GUEST_GDTR_BASE, dt->address);
A
Avi Kivity 已提交
2125 2126
}

2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152
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;

2153 2154
	if (cs.unusable)
		return false;
2155 2156 2157 2158
	if (~cs.type & (AR_TYPE_CODE_MASK|AR_TYPE_ACCESSES_MASK))
		return false;
	if (!cs.s)
		return false;
2159
	if (cs.type & AR_TYPE_WRITEABLE_MASK) {
2160 2161
		if (cs.dpl > cs_rpl)
			return false;
2162
	} else {
2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180
		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;

2181 2182 2183
	if (ss.unusable)
		return true;
	if (ss.type != 3 && ss.type != 7)
2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
		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;

2203 2204
	if (var.unusable)
		return true;
2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225
	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);

2226 2227
	if (tr.unusable)
		return false;
2228 2229
	if (tr.selector & SELECTOR_TI_MASK)	/* TI = 1 */
		return false;
2230
	if (tr.type != 3 && tr.type != 11) /* TODO: Check if guest is in IA32e mode */
2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243
		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);

2244 2245
	if (ldtr.unusable)
		return true;
2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
	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 */
2275
	if (!is_protmode(vcpu)) {
2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316
		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 已提交
2317
static int init_rmode_tss(struct kvm *kvm)
A
Avi Kivity 已提交
2318 2319
{
	gfn_t fn = rmode_tss_base(kvm) >> PAGE_SHIFT;
2320
	u16 data = 0;
2321
	int ret = 0;
2322
	int r;
A
Avi Kivity 已提交
2323

2324 2325
	r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
	if (r < 0)
2326
		goto out;
2327
	data = TSS_BASE_SIZE + TSS_REDIRECTION_SIZE;
2328 2329
	r = kvm_write_guest_page(kvm, fn++, &data,
			TSS_IOPB_BASE_OFFSET, sizeof(u16));
2330
	if (r < 0)
2331
		goto out;
2332 2333
	r = kvm_clear_guest_page(kvm, fn++, 0, PAGE_SIZE);
	if (r < 0)
2334
		goto out;
2335 2336
	r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE);
	if (r < 0)
2337
		goto out;
2338
	data = ~0;
2339 2340 2341
	r = kvm_write_guest_page(kvm, fn, &data,
				 RMODE_TSS_SIZE - 2 * PAGE_SIZE - 1,
				 sizeof(u8));
2342
	if (r < 0)
2343 2344 2345 2346 2347
		goto out;

	ret = 1;
out:
	return ret;
A
Avi Kivity 已提交
2348 2349
}

2350 2351 2352 2353 2354 2355
static int init_rmode_identity_map(struct kvm *kvm)
{
	int i, r, ret;
	pfn_t identity_map_pfn;
	u32 tmp;

2356
	if (!enable_ept)
2357 2358 2359 2360 2361 2362 2363 2364 2365
		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;
2366
	identity_map_pfn = kvm->arch.ept_identity_map_addr >> PAGE_SHIFT;
2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384
	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 已提交
2385 2386 2387
static void seg_setup(int seg)
{
	struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
2388
	unsigned int ar;
A
Avi Kivity 已提交
2389 2390 2391 2392

	vmcs_write16(sf->selector, 0);
	vmcs_writel(sf->base, 0);
	vmcs_write32(sf->limit, 0xffff);
2393 2394 2395 2396 2397 2398 2399 2400
	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 已提交
2401 2402
}

2403 2404 2405 2406 2407
static int alloc_apic_access_page(struct kvm *kvm)
{
	struct kvm_userspace_memory_region kvm_userspace_mem;
	int r = 0;

2408
	mutex_lock(&kvm->slots_lock);
2409
	if (kvm->arch.apic_access_page)
2410 2411 2412 2413 2414 2415 2416 2417
		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;
2418

2419
	kvm->arch.apic_access_page = gfn_to_page(kvm, 0xfee00);
2420
out:
2421
	mutex_unlock(&kvm->slots_lock);
2422 2423 2424
	return r;
}

2425 2426 2427 2428 2429
static int alloc_identity_pagetable(struct kvm *kvm)
{
	struct kvm_userspace_memory_region kvm_userspace_mem;
	int r = 0;

2430
	mutex_lock(&kvm->slots_lock);
2431 2432 2433 2434
	if (kvm->arch.ept_identity_pagetable)
		goto out;
	kvm_userspace_mem.slot = IDENTITY_PAGETABLE_PRIVATE_MEMSLOT;
	kvm_userspace_mem.flags = 0;
2435 2436
	kvm_userspace_mem.guest_phys_addr =
		kvm->arch.ept_identity_map_addr;
2437 2438 2439 2440 2441 2442
	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,
2443
			kvm->arch.ept_identity_map_addr >> PAGE_SHIFT);
2444
out:
2445
	mutex_unlock(&kvm->slots_lock);
2446 2447 2448
	return r;
}

2449 2450 2451 2452 2453
static void allocate_vpid(struct vcpu_vmx *vmx)
{
	int vpid;

	vmx->vpid = 0;
2454
	if (!enable_vpid)
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
		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);
}

2465 2466 2467 2468 2469 2470 2471 2472 2473 2474
static void free_vpid(struct vcpu_vmx *vmx)
{
	if (!enable_vpid)
		return;
	spin_lock(&vmx_vpid_lock);
	if (vmx->vpid != 0)
		__clear_bit(vmx->vpid, vmx_vpid_bitmap);
	spin_unlock(&vmx_vpid_lock);
}

2475
static void __vmx_disable_intercept_for_msr(unsigned long *msr_bitmap, u32 msr)
S
Sheng Yang 已提交
2476
{
2477
	int f = sizeof(unsigned long);
S
Sheng Yang 已提交
2478 2479 2480 2481 2482 2483 2484 2485 2486 2487

	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) {
2488 2489
		__clear_bit(msr, msr_bitmap + 0x000 / f); /* read-low */
		__clear_bit(msr, msr_bitmap + 0x800 / f); /* write-low */
S
Sheng Yang 已提交
2490 2491
	} else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) {
		msr &= 0x1fff;
2492 2493
		__clear_bit(msr, msr_bitmap + 0x400 / f); /* read-high */
		__clear_bit(msr, msr_bitmap + 0xc00 / f); /* write-high */
S
Sheng Yang 已提交
2494 2495 2496
	}
}

2497 2498 2499 2500 2501 2502 2503
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 已提交
2504 2505 2506
/*
 * Sets up the vmcs for emulated real mode.
 */
R
Rusty Russell 已提交
2507
static int vmx_vcpu_setup(struct vcpu_vmx *vmx)
A
Avi Kivity 已提交
2508
{
S
Sheng Yang 已提交
2509
	u32 host_sysenter_cs, msr_low, msr_high;
A
Avi Kivity 已提交
2510
	u32 junk;
2511
	u64 host_pat, tsc_this, tsc_base;
A
Avi Kivity 已提交
2512
	unsigned long a;
2513
	struct desc_ptr dt;
A
Avi Kivity 已提交
2514
	int i;
2515
	unsigned long kvm_vmx_return;
2516
	u32 exec_control;
A
Avi Kivity 已提交
2517 2518

	/* I/O */
2519 2520
	vmcs_write64(IO_BITMAP_A, __pa(vmx_io_bitmap_a));
	vmcs_write64(IO_BITMAP_B, __pa(vmx_io_bitmap_b));
A
Avi Kivity 已提交
2521

S
Sheng Yang 已提交
2522
	if (cpu_has_vmx_msr_bitmap())
2523
		vmcs_write64(MSR_BITMAP, __pa(vmx_msr_bitmap_legacy));
S
Sheng Yang 已提交
2524

A
Avi Kivity 已提交
2525 2526 2527
	vmcs_write64(VMCS_LINK_POINTER, -1ull); /* 22.3.1.5 */

	/* Control */
2528 2529
	vmcs_write32(PIN_BASED_VM_EXEC_CONTROL,
		vmcs_config.pin_based_exec_ctrl);
2530 2531 2532 2533 2534 2535 2536 2537 2538

	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
	}
2539
	if (!enable_ept)
S
Sheng Yang 已提交
2540
		exec_control |= CPU_BASED_CR3_STORE_EXITING |
2541 2542
				CPU_BASED_CR3_LOAD_EXITING  |
				CPU_BASED_INVLPG_EXITING;
2543
	vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, exec_control);
A
Avi Kivity 已提交
2544

2545 2546 2547 2548 2549
	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;
2550 2551
		if (vmx->vpid == 0)
			exec_control &= ~SECONDARY_EXEC_ENABLE_VPID;
2552
		if (!enable_ept) {
S
Sheng Yang 已提交
2553
			exec_control &= ~SECONDARY_EXEC_ENABLE_EPT;
2554 2555
			enable_unrestricted_guest = 0;
		}
2556 2557
		if (!enable_unrestricted_guest)
			exec_control &= ~SECONDARY_EXEC_UNRESTRICTED_GUEST;
2558 2559
		if (!ple_gap)
			exec_control &= ~SECONDARY_EXEC_PAUSE_LOOP_EXITING;
2560 2561
		vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control);
	}
2562

2563 2564 2565 2566 2567
	if (ple_gap) {
		vmcs_write32(PLE_GAP, ple_gap);
		vmcs_write32(PLE_WINDOW, ple_window);
	}

2568 2569
	vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, !!bypass_guest_pf);
	vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, !!bypass_guest_pf);
A
Avi Kivity 已提交
2570 2571
	vmcs_write32(CR3_TARGET_COUNT, 0);           /* 22.2.1 */

2572
	vmcs_writel(HOST_CR0, read_cr0() | X86_CR0_TS);  /* 22.2.3 */
A
Avi Kivity 已提交
2573 2574 2575 2576 2577 2578
	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 */
2579 2580
	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 已提交
2581
	vmcs_write16(HOST_SS_SELECTOR, __KERNEL_DS);  /* 22.2.4 */
2582
#ifdef CONFIG_X86_64
A
Avi Kivity 已提交
2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593
	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 */

2594
	native_store_idt(&dt);
2595
	vmcs_writel(HOST_IDTR_BASE, dt.address);   /* 22.2.4 */
A
Avi Kivity 已提交
2596

M
Mike Day 已提交
2597
	asm("mov $.Lkvm_vmx_return, %0" : "=r"(kvm_vmx_return));
2598
	vmcs_writel(HOST_RIP, kvm_vmx_return); /* 22.2.5 */
2599 2600
	vmcs_write32(VM_EXIT_MSR_STORE_COUNT, 0);
	vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, 0);
2601
	vmcs_write64(VM_EXIT_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.host));
2602
	vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, 0);
2603
	vmcs_write64(VM_ENTRY_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.guest));
A
Avi Kivity 已提交
2604 2605 2606 2607 2608 2609 2610 2611

	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 已提交
2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625
	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 已提交
2626 2627 2628
	for (i = 0; i < NR_VMX_MSR; ++i) {
		u32 index = vmx_msr_index[i];
		u32 data_low, data_high;
2629
		int j = vmx->nmsrs;
A
Avi Kivity 已提交
2630 2631 2632

		if (rdmsr_safe(index, &data_low, &data_high) < 0)
			continue;
2633 2634
		if (wrmsr_safe(index, data_low, data_high) < 0)
			continue;
2635 2636
		vmx->guest_msrs[j].index = i;
		vmx->guest_msrs[j].data = 0;
2637
		vmx->guest_msrs[j].mask = -1ull;
2638
		++vmx->nmsrs;
A
Avi Kivity 已提交
2639 2640
	}

2641
	vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl);
A
Avi Kivity 已提交
2642 2643

	/* 22.2.1, 20.8.1 */
2644 2645
	vmcs_write32(VM_ENTRY_CONTROLS, vmcs_config.vmentry_ctrl);

2646
	vmcs_writel(CR0_GUEST_HOST_MASK, ~0UL);
2647
	vmx->vcpu.arch.cr4_guest_owned_bits = KVM_CR4_GUEST_OWNED_BITS;
2648 2649
	if (enable_ept)
		vmx->vcpu.arch.cr4_guest_owned_bits |= X86_CR4_PGE;
2650
	vmcs_writel(CR4_GUEST_HOST_MASK, ~vmx->vcpu.arch.cr4_guest_owned_bits);
2651

2652 2653 2654 2655 2656 2657
	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);
2658

2659 2660 2661
	return 0;
}

2662 2663
static int init_rmode(struct kvm *kvm)
{
2664 2665 2666
	int idx, ret = 0;

	idx = srcu_read_lock(&kvm->srcu);
2667
	if (!init_rmode_tss(kvm))
2668
		goto exit;
2669
	if (!init_rmode_identity_map(kvm))
2670 2671 2672 2673 2674 2675
		goto exit;

	ret = 1;
exit:
	srcu_read_unlock(&kvm->srcu, idx);
	return ret;
2676 2677
}

2678 2679 2680 2681
static int vmx_vcpu_reset(struct kvm_vcpu *vcpu)
{
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	u64 msr;
2682
	int ret;
2683

2684
	vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) | (1 << VCPU_REGS_RSP));
2685
	if (!init_rmode(vmx->vcpu.kvm)) {
2686 2687 2688 2689
		ret = -ENOMEM;
		goto out;
	}

2690
	vmx->rmode.vm86_active = 0;
2691

2692 2693
	vmx->soft_vnmi_blocked = 0;

2694
	vmx->vcpu.arch.regs[VCPU_REGS_RDX] = get_rdx_init_val();
2695
	kvm_set_cr8(&vmx->vcpu, 0);
2696
	msr = 0xfee00000 | MSR_IA32_APICBASE_ENABLE;
2697
	if (kvm_vcpu_is_bsp(&vmx->vcpu))
2698 2699 2700
		msr |= MSR_IA32_APICBASE_BSP;
	kvm_set_apic_base(&vmx->vcpu, msr);

2701 2702 2703
	ret = fx_init(&vmx->vcpu);
	if (ret != 0)
		goto out;
2704

2705
	seg_setup(VCPU_SREG_CS);
2706 2707 2708 2709
	/*
	 * GUEST_CS_BASE should really be 0xffff0000, but VT vm86 mode
	 * insists on having GUEST_CS_BASE == GUEST_CS_SELECTOR << 4.  Sigh.
	 */
2710
	if (kvm_vcpu_is_bsp(&vmx->vcpu)) {
2711 2712 2713
		vmcs_write16(GUEST_CS_SELECTOR, 0xf000);
		vmcs_writel(GUEST_CS_BASE, 0x000f0000);
	} else {
2714 2715
		vmcs_write16(GUEST_CS_SELECTOR, vmx->vcpu.arch.sipi_vector << 8);
		vmcs_writel(GUEST_CS_BASE, vmx->vcpu.arch.sipi_vector << 12);
2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738
	}

	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);
2739
	if (kvm_vcpu_is_bsp(&vmx->vcpu))
2740
		kvm_rip_write(vcpu, 0xfff0);
2741
	else
2742 2743
		kvm_rip_write(vcpu, 0);
	kvm_register_write(vcpu, VCPU_REGS_RSP, 0);
2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761

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

2764 2765 2766 2767
	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,
2768
				page_to_phys(vmx->vcpu.arch.apic->regs_page));
2769 2770 2771 2772 2773
		vmcs_write32(TPR_THRESHOLD, 0);
	}

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

2776 2777 2778
	if (vmx->vpid != 0)
		vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid);

2779
	vmx->vcpu.arch.cr0 = X86_CR0_NW | X86_CR0_CD | X86_CR0_ET;
2780
	vmx_set_cr0(&vmx->vcpu, kvm_read_cr0(vcpu)); /* enter rmode */
R
Rusty Russell 已提交
2781 2782 2783 2784
	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 已提交
2785

2786
	vpid_sync_context(vmx);
2787

2788
	ret = 0;
A
Avi Kivity 已提交
2789

2790 2791 2792
	/* HACK: Don't enable emulation on guest boot/reset */
	vmx->emulation_required = 0;

A
Avi Kivity 已提交
2793 2794 2795 2796
out:
	return ret;
}

2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819
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);
}

2820
static void vmx_inject_irq(struct kvm_vcpu *vcpu)
2821
{
2822
	struct vcpu_vmx *vmx = to_vmx(vcpu);
2823 2824
	uint32_t intr;
	int irq = vcpu->arch.interrupt.nr;
2825

2826
	trace_kvm_inj_virq(irq);
F
Feng (Eric) Liu 已提交
2827

2828
	++vcpu->stat.irq_injections;
2829
	if (vmx->rmode.vm86_active) {
2830 2831
		vmx->rmode.irq.pending = true;
		vmx->rmode.irq.vector = irq;
2832
		vmx->rmode.irq.rip = kvm_rip_read(vcpu);
2833 2834 2835
		if (vcpu->arch.interrupt.soft)
			vmx->rmode.irq.rip +=
				vmx->vcpu.arch.event_exit_inst_len;
2836 2837 2838
		vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
			     irq | INTR_TYPE_SOFT_INTR | INTR_INFO_VALID_MASK);
		vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, 1);
2839
		kvm_rip_write(vcpu, vmx->rmode.irq.rip - 1);
2840 2841
		return;
	}
2842 2843 2844 2845 2846 2847 2848 2849
	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);
2850 2851
}

2852 2853
static void vmx_inject_nmi(struct kvm_vcpu *vcpu)
{
J
Jan Kiszka 已提交
2854 2855
	struct vcpu_vmx *vmx = to_vmx(vcpu);

2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
	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;
	}

2869
	++vcpu->stat.nmi_injections;
2870
	if (vmx->rmode.vm86_active) {
J
Jan Kiszka 已提交
2871 2872 2873 2874 2875 2876 2877 2878 2879 2880
		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;
	}
2881 2882 2883 2884
	vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
			INTR_TYPE_NMI_INTR | INTR_INFO_VALID_MASK | NMI_VECTOR);
}

2885
static int vmx_nmi_allowed(struct kvm_vcpu *vcpu)
2886
{
2887
	if (!cpu_has_virtual_nmis() && to_vmx(vcpu)->soft_vnmi_blocked)
2888
		return 0;
2889

2890
	return	!(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
2891
			(GUEST_INTR_STATE_MOV_SS | GUEST_INTR_STATE_NMI));
2892 2893
}

J
Jan Kiszka 已提交
2894 2895 2896 2897
static bool vmx_get_nmi_mask(struct kvm_vcpu *vcpu)
{
	if (!cpu_has_virtual_nmis())
		return to_vmx(vcpu)->soft_vnmi_blocked;
2898
	return vmcs_read32(GUEST_INTERRUPTIBILITY_INFO)	& GUEST_INTR_STATE_NMI;
J
Jan Kiszka 已提交
2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919
}

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

2920 2921
static int vmx_interrupt_allowed(struct kvm_vcpu *vcpu)
{
2922 2923 2924
	return (vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) &&
		!(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
			(GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS));
2925 2926
}

2927 2928 2929 2930
static int vmx_set_tss_addr(struct kvm *kvm, unsigned int addr)
{
	int ret;
	struct kvm_userspace_memory_region tss_mem = {
2931
		.slot = TSS_PRIVATE_MEMSLOT,
2932 2933 2934 2935 2936 2937 2938 2939
		.guest_phys_addr = addr,
		.memory_size = PAGE_SIZE * 3,
		.flags = 0,
	};

	ret = kvm_set_memory_region(kvm, &tss_mem, 0);
	if (ret)
		return ret;
2940
	kvm->arch.tss_addr = addr;
2941 2942 2943
	return 0;
}

A
Avi Kivity 已提交
2944 2945 2946
static int handle_rmode_exception(struct kvm_vcpu *vcpu,
				  int vec, u32 err_code)
{
2947 2948 2949 2950 2951
	/*
	 * 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 已提交
2952
		if (emulate_instruction(vcpu, 0, 0, 0) == EMULATE_DONE)
A
Avi Kivity 已提交
2953
			return 1;
2954 2955 2956 2957 2958 2959 2960
	/*
	 * 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 已提交
2961 2962 2963 2964 2965
		if (vcpu->guest_debug &
		    (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP))
			return 0;
		kvm_queue_exception(vcpu, vec);
		return 1;
2966
	case BP_VECTOR:
2967 2968 2969 2970 2971 2972
		/*
		 * Update instruction length as we may reinject the exception
		 * from user space while in guest debugging mode.
		 */
		to_vmx(vcpu)->vcpu.arch.event_exit_inst_len =
			vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
J
Jan Kiszka 已提交
2973 2974 2975 2976
		if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP)
			return 0;
		/* fall through */
	case DE_VECTOR:
2977 2978 2979 2980 2981 2982 2983 2984 2985 2986
	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 已提交
2987 2988 2989
	return 0;
}

A
Andi Kleen 已提交
2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008
/*
 * 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 已提交
3009
static int handle_machine_check(struct kvm_vcpu *vcpu)
A
Andi Kleen 已提交
3010 3011 3012 3013 3014
{
	/* already handled by vcpu_run */
	return 1;
}

A
Avi Kivity 已提交
3015
static int handle_exception(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3016
{
3017
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Avi Kivity 已提交
3018
	struct kvm_run *kvm_run = vcpu->run;
J
Jan Kiszka 已提交
3019
	u32 intr_info, ex_no, error_code;
3020
	unsigned long cr2, rip, dr6;
A
Avi Kivity 已提交
3021 3022 3023
	u32 vect_info;
	enum emulation_result er;

3024
	vect_info = vmx->idt_vectoring_info;
A
Avi Kivity 已提交
3025 3026
	intr_info = vmcs_read32(VM_EXIT_INTR_INFO);

A
Andi Kleen 已提交
3027
	if (is_machine_check(intr_info))
A
Avi Kivity 已提交
3028
		return handle_machine_check(vcpu);
A
Andi Kleen 已提交
3029

A
Avi Kivity 已提交
3030
	if ((vect_info & VECTORING_INFO_VALID_MASK) &&
3031 3032 3033 3034 3035 3036 3037 3038
	    !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 已提交
3039

3040
	if ((intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR)
3041
		return 1;  /* already handled by vmx_vcpu_run() */
3042 3043

	if (is_no_device(intr_info)) {
3044
		vmx_fpu_activate(vcpu);
3045 3046 3047
		return 1;
	}

3048
	if (is_invalid_opcode(intr_info)) {
A
Avi Kivity 已提交
3049
		er = emulate_instruction(vcpu, 0, 0, EMULTYPE_TRAP_UD);
3050
		if (er != EMULATE_DONE)
3051
			kvm_queue_exception(vcpu, UD_VECTOR);
3052 3053 3054
		return 1;
	}

A
Avi Kivity 已提交
3055
	error_code = 0;
3056
	rip = kvm_rip_read(vcpu);
3057
	if (intr_info & INTR_INFO_DELIVER_CODE_MASK)
A
Avi Kivity 已提交
3058 3059
		error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE);
	if (is_page_fault(intr_info)) {
3060
		/* EPT won't cause page fault directly */
3061
		if (enable_ept)
3062
			BUG();
A
Avi Kivity 已提交
3063
		cr2 = vmcs_readl(EXIT_QUALIFICATION);
3064 3065
		trace_kvm_page_fault(cr2, error_code);

3066
		if (kvm_event_needs_reinjection(vcpu))
3067
			kvm_mmu_unprotect_page_virt(vcpu, cr2);
3068
		return kvm_mmu_page_fault(vcpu, cr2, error_code);
A
Avi Kivity 已提交
3069 3070
	}

3071
	if (vmx->rmode.vm86_active &&
A
Avi Kivity 已提交
3072
	    handle_rmode_exception(vcpu, intr_info & INTR_INFO_VECTOR_MASK,
3073
								error_code)) {
3074 3075
		if (vcpu->arch.halt_request) {
			vcpu->arch.halt_request = 0;
3076 3077
			return kvm_emulate_halt(vcpu);
		}
A
Avi Kivity 已提交
3078
		return 1;
3079
	}
A
Avi Kivity 已提交
3080

J
Jan Kiszka 已提交
3081
	ex_no = intr_info & INTR_INFO_VECTOR_MASK;
3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094
	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:
3095 3096 3097 3098 3099 3100 3101
		/*
		 * Update instruction length as we may reinject #BP from
		 * user space while in guest debugging mode. Reading it for
		 * #DB as well causes no harm, it is not used in that case.
		 */
		vmx->vcpu.arch.event_exit_inst_len =
			vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
A
Avi Kivity 已提交
3102
		kvm_run->exit_reason = KVM_EXIT_DEBUG;
J
Jan Kiszka 已提交
3103 3104
		kvm_run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + rip;
		kvm_run->debug.arch.exception = ex_no;
3105 3106
		break;
	default:
J
Jan Kiszka 已提交
3107 3108 3109
		kvm_run->exit_reason = KVM_EXIT_EXCEPTION;
		kvm_run->ex.exception = ex_no;
		kvm_run->ex.error_code = error_code;
3110
		break;
A
Avi Kivity 已提交
3111 3112 3113 3114
	}
	return 0;
}

A
Avi Kivity 已提交
3115
static int handle_external_interrupt(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3116
{
A
Avi Kivity 已提交
3117
	++vcpu->stat.irq_exits;
A
Avi Kivity 已提交
3118 3119 3120
	return 1;
}

A
Avi Kivity 已提交
3121
static int handle_triple_fault(struct kvm_vcpu *vcpu)
3122
{
A
Avi Kivity 已提交
3123
	vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN;
3124 3125
	return 0;
}
A
Avi Kivity 已提交
3126

A
Avi Kivity 已提交
3127
static int handle_io(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3128
{
3129
	unsigned long exit_qualification;
3130
	int size, in, string;
3131
	unsigned port;
A
Avi Kivity 已提交
3132

3133
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
3134
	string = (exit_qualification & 16) != 0;
3135
	in = (exit_qualification & 8) != 0;
3136

3137
	++vcpu->stat.io_exits;
3138

3139
	if (string || in)
3140
		return emulate_instruction(vcpu, 0, 0, 0) == EMULATE_DONE;
3141

3142 3143
	port = exit_qualification >> 16;
	size = (exit_qualification & 7) + 1;
3144
	skip_emulated_instruction(vcpu);
3145 3146

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

I
Ingo Molnar 已提交
3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159
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;
}

3160 3161 3162 3163 3164 3165 3166 3167
static void complete_insn_gp(struct kvm_vcpu *vcpu, int err)
{
	if (err)
		kvm_inject_gp(vcpu, 0);
	else
		skip_emulated_instruction(vcpu);
}

A
Avi Kivity 已提交
3168
static int handle_cr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3169
{
3170
	unsigned long exit_qualification, val;
A
Avi Kivity 已提交
3171 3172
	int cr;
	int reg;
3173
	int err;
A
Avi Kivity 已提交
3174

3175
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
A
Avi Kivity 已提交
3176 3177 3178 3179
	cr = exit_qualification & 15;
	reg = (exit_qualification >> 8) & 15;
	switch ((exit_qualification >> 4) & 3) {
	case 0: /* mov to cr */
3180 3181
		val = kvm_register_read(vcpu, reg);
		trace_kvm_cr_write(cr, val);
A
Avi Kivity 已提交
3182 3183
		switch (cr) {
		case 0:
3184 3185
			err = kvm_set_cr0(vcpu, val);
			complete_insn_gp(vcpu, err);
A
Avi Kivity 已提交
3186 3187
			return 1;
		case 3:
3188 3189
			err = kvm_set_cr3(vcpu, val);
			complete_insn_gp(vcpu, err);
A
Avi Kivity 已提交
3190 3191
			return 1;
		case 4:
3192 3193
			err = kvm_set_cr4(vcpu, val);
			complete_insn_gp(vcpu, err);
A
Avi Kivity 已提交
3194
			return 1;
3195 3196 3197 3198 3199 3200 3201 3202 3203
		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 已提交
3204
				vcpu->run->exit_reason = KVM_EXIT_SET_TPR;
3205 3206
				return 0;
			}
A
Avi Kivity 已提交
3207 3208
		};
		break;
3209
	case 2: /* clts */
3210
		vmx_set_cr0(vcpu, kvm_read_cr0_bits(vcpu, ~X86_CR0_TS));
3211
		trace_kvm_cr_write(0, kvm_read_cr0(vcpu));
3212
		skip_emulated_instruction(vcpu);
A
Avi Kivity 已提交
3213
		vmx_fpu_activate(vcpu);
3214
		return 1;
A
Avi Kivity 已提交
3215 3216 3217
	case 1: /*mov from cr*/
		switch (cr) {
		case 3:
3218
			kvm_register_write(vcpu, reg, vcpu->arch.cr3);
3219
			trace_kvm_cr_read(cr, vcpu->arch.cr3);
A
Avi Kivity 已提交
3220 3221 3222
			skip_emulated_instruction(vcpu);
			return 1;
		case 8:
3223 3224 3225
			val = kvm_get_cr8(vcpu);
			kvm_register_write(vcpu, reg, val);
			trace_kvm_cr_read(cr, val);
A
Avi Kivity 已提交
3226 3227 3228 3229 3230
			skip_emulated_instruction(vcpu);
			return 1;
		}
		break;
	case 3: /* lmsw */
3231
		val = (exit_qualification >> LMSW_SOURCE_DATA_SHIFT) & 0x0f;
3232
		trace_kvm_cr_write(0, (kvm_read_cr0(vcpu) & ~0xful) | val);
3233
		kvm_lmsw(vcpu, val);
A
Avi Kivity 已提交
3234 3235 3236 3237 3238 3239

		skip_emulated_instruction(vcpu);
		return 1;
	default:
		break;
	}
A
Avi Kivity 已提交
3240
	vcpu->run->exit_reason = 0;
3241
	pr_unimpl(vcpu, "unhandled control register: op %d cr %d\n",
A
Avi Kivity 已提交
3242 3243 3244 3245
	       (int)(exit_qualification >> 4) & 3, cr);
	return 0;
}

A
Avi Kivity 已提交
3246
static int handle_dr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3247
{
3248
	unsigned long exit_qualification;
A
Avi Kivity 已提交
3249 3250
	int dr, reg;

3251
	/* Do not handle if the CPL > 0, will trigger GP on re-entry */
3252 3253
	if (!kvm_require_cpl(vcpu, 0))
		return 1;
3254 3255 3256 3257 3258 3259 3260 3261
	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 已提交
3262 3263 3264
			vcpu->run->debug.arch.dr6 = vcpu->arch.dr6;
			vcpu->run->debug.arch.dr7 = dr;
			vcpu->run->debug.arch.pc =
3265 3266
				vmcs_readl(GUEST_CS_BASE) +
				vmcs_readl(GUEST_RIP);
A
Avi Kivity 已提交
3267 3268
			vcpu->run->debug.arch.exception = DB_VECTOR;
			vcpu->run->exit_reason = KVM_EXIT_DEBUG;
3269 3270 3271 3272 3273 3274 3275 3276 3277 3278
			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;
		}
	}

3279
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
3280 3281 3282
	dr = exit_qualification & DEBUG_REG_ACCESS_NUM;
	reg = DEBUG_REG_ACCESS_REG(exit_qualification);
	if (exit_qualification & TYPE_MOV_FROM_DR) {
3283 3284 3285 3286 3287
		unsigned long val;
		if (!kvm_get_dr(vcpu, dr, &val))
			kvm_register_write(vcpu, reg, val);
	} else
		kvm_set_dr(vcpu, dr, vcpu->arch.regs[reg]);
A
Avi Kivity 已提交
3288 3289 3290 3291
	skip_emulated_instruction(vcpu);
	return 1;
}

3292 3293 3294 3295 3296
static void vmx_set_dr7(struct kvm_vcpu *vcpu, unsigned long val)
{
	vmcs_writel(GUEST_DR7, val);
}

A
Avi Kivity 已提交
3297
static int handle_cpuid(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3298
{
3299 3300
	kvm_emulate_cpuid(vcpu);
	return 1;
A
Avi Kivity 已提交
3301 3302
}

A
Avi Kivity 已提交
3303
static int handle_rdmsr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3304
{
3305
	u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX];
A
Avi Kivity 已提交
3306 3307 3308
	u64 data;

	if (vmx_get_msr(vcpu, ecx, &data)) {
3309
		trace_kvm_msr_read_ex(ecx);
3310
		kvm_inject_gp(vcpu, 0);
A
Avi Kivity 已提交
3311 3312 3313
		return 1;
	}

3314
	trace_kvm_msr_read(ecx, data);
F
Feng (Eric) Liu 已提交
3315

A
Avi Kivity 已提交
3316
	/* FIXME: handling of bits 32:63 of rax, rdx */
3317 3318
	vcpu->arch.regs[VCPU_REGS_RAX] = data & -1u;
	vcpu->arch.regs[VCPU_REGS_RDX] = (data >> 32) & -1u;
A
Avi Kivity 已提交
3319 3320 3321 3322
	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3323
static int handle_wrmsr(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3324
{
3325 3326 3327
	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 已提交
3328 3329

	if (vmx_set_msr(vcpu, ecx, data) != 0) {
3330
		trace_kvm_msr_write_ex(ecx, data);
3331
		kvm_inject_gp(vcpu, 0);
A
Avi Kivity 已提交
3332 3333 3334
		return 1;
	}

3335
	trace_kvm_msr_write(ecx, data);
A
Avi Kivity 已提交
3336 3337 3338 3339
	skip_emulated_instruction(vcpu);
	return 1;
}

A
Avi Kivity 已提交
3340
static int handle_tpr_below_threshold(struct kvm_vcpu *vcpu)
3341 3342 3343 3344
{
	return 1;
}

A
Avi Kivity 已提交
3345
static int handle_interrupt_window(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3346
{
3347 3348 3349 3350 3351 3352
	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 已提交
3353

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

3356 3357 3358 3359
	/*
	 * If the user space waits to inject interrupts, exit as soon as
	 * possible
	 */
3360
	if (!irqchip_in_kernel(vcpu->kvm) &&
A
Avi Kivity 已提交
3361
	    vcpu->run->request_interrupt_window &&
3362
	    !kvm_cpu_has_interrupt(vcpu)) {
A
Avi Kivity 已提交
3363
		vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
3364 3365
		return 0;
	}
A
Avi Kivity 已提交
3366 3367 3368
	return 1;
}

A
Avi Kivity 已提交
3369
static int handle_halt(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3370 3371
{
	skip_emulated_instruction(vcpu);
3372
	return kvm_emulate_halt(vcpu);
A
Avi Kivity 已提交
3373 3374
}

A
Avi Kivity 已提交
3375
static int handle_vmcall(struct kvm_vcpu *vcpu)
3376
{
3377
	skip_emulated_instruction(vcpu);
3378 3379
	kvm_emulate_hypercall(vcpu);
	return 1;
3380 3381
}

A
Avi Kivity 已提交
3382
static int handle_vmx_insn(struct kvm_vcpu *vcpu)
3383 3384 3385 3386 3387
{
	kvm_queue_exception(vcpu, UD_VECTOR);
	return 1;
}

A
Avi Kivity 已提交
3388
static int handle_invlpg(struct kvm_vcpu *vcpu)
M
Marcelo Tosatti 已提交
3389
{
3390
	unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
M
Marcelo Tosatti 已提交
3391 3392 3393 3394 3395 3396

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

A
Avi Kivity 已提交
3397
static int handle_wbinvd(struct kvm_vcpu *vcpu)
E
Eddie Dong 已提交
3398 3399 3400 3401 3402 3403
{
	skip_emulated_instruction(vcpu);
	/* TODO: Add support for VT-d/pass-through device */
	return 1;
}

3404 3405 3406 3407 3408 3409 3410 3411 3412 3413
static int handle_xsetbv(struct kvm_vcpu *vcpu)
{
	u64 new_bv = kvm_read_edx_eax(vcpu);
	u32 index = kvm_register_read(vcpu, VCPU_REGS_RCX);

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

A
Avi Kivity 已提交
3414
static int handle_apic_access(struct kvm_vcpu *vcpu)
3415
{
3416
	return emulate_instruction(vcpu, 0, 0, 0) == EMULATE_DONE;
3417 3418
}

A
Avi Kivity 已提交
3419
static int handle_task_switch(struct kvm_vcpu *vcpu)
3420
{
J
Jan Kiszka 已提交
3421
	struct vcpu_vmx *vmx = to_vmx(vcpu);
3422
	unsigned long exit_qualification;
3423 3424
	bool has_error_code = false;
	u32 error_code = 0;
3425
	u16 tss_selector;
3426 3427 3428 3429
	int reason, type, idt_v;

	idt_v = (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK);
	type = (vmx->idt_vectoring_info & VECTORING_INFO_TYPE_MASK);
3430 3431 3432 3433

	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);

	reason = (u32)exit_qualification >> 30;
3434 3435 3436 3437 3438 3439 3440 3441 3442
	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:
3443
		case INTR_TYPE_SOFT_INTR:
3444 3445 3446
			kvm_clear_interrupt_queue(vcpu);
			break;
		case INTR_TYPE_HARD_EXCEPTION:
3447 3448 3449 3450 3451 3452 3453
			if (vmx->idt_vectoring_info &
			    VECTORING_INFO_DELIVER_CODE_MASK) {
				has_error_code = true;
				error_code =
					vmcs_read32(IDT_VECTORING_ERROR_CODE);
			}
			/* fall through */
3454 3455 3456 3457 3458 3459
		case INTR_TYPE_SOFT_EXCEPTION:
			kvm_clear_exception_queue(vcpu);
			break;
		default:
			break;
		}
J
Jan Kiszka 已提交
3460
	}
3461 3462
	tss_selector = exit_qualification;

3463 3464 3465 3466 3467
	if (!idt_v || (type != INTR_TYPE_HARD_EXCEPTION &&
		       type != INTR_TYPE_EXT_INTR &&
		       type != INTR_TYPE_NMI_INTR))
		skip_emulated_instruction(vcpu);

3468 3469 3470 3471 3472
	if (kvm_task_switch(vcpu, tss_selector, reason,
				has_error_code, error_code) == EMULATE_FAIL) {
		vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
		vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION;
		vcpu->run->internal.ndata = 0;
3473
		return 0;
3474
	}
3475 3476 3477 3478 3479 3480 3481 3482 3483 3484

	/* 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;
3485 3486
}

A
Avi Kivity 已提交
3487
static int handle_ept_violation(struct kvm_vcpu *vcpu)
3488
{
3489
	unsigned long exit_qualification;
3490 3491 3492
	gpa_t gpa;
	int gla_validity;

3493
	exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
3494 3495 3496

	if (exit_qualification & (1 << 6)) {
		printk(KERN_ERR "EPT: GPA exceeds GAW!\n");
3497
		return -EINVAL;
3498 3499 3500 3501 3502 3503 3504
	}

	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),
3505
			vmcs_readl(GUEST_LINEAR_ADDRESS));
3506 3507
		printk(KERN_ERR "EPT: Exit qualification is 0x%lx\n",
			(long unsigned int)exit_qualification);
A
Avi Kivity 已提交
3508 3509
		vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
		vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_VIOLATION;
3510
		return 0;
3511 3512 3513
	}

	gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS);
3514
	trace_kvm_page_fault(gpa, exit_qualification);
3515
	return kvm_mmu_page_fault(vcpu, gpa & PAGE_MASK, 0);
3516 3517
}

3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578
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 已提交
3579
static int handle_ept_misconfig(struct kvm_vcpu *vcpu)
3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594
{
	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 已提交
3595 3596
	vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
	vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_MISCONFIG;
3597 3598 3599 3600

	return 0;
}

A
Avi Kivity 已提交
3601
static int handle_nmi_window(struct kvm_vcpu *vcpu)
3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613
{
	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;
}

3614
static int handle_invalid_guest_state(struct kvm_vcpu *vcpu)
3615
{
3616 3617
	struct vcpu_vmx *vmx = to_vmx(vcpu);
	enum emulation_result err = EMULATE_DONE;
3618
	int ret = 1;
3619 3620

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

3623 3624 3625 3626
		if (err == EMULATE_DO_MMIO) {
			ret = 0;
			goto out;
		}
3627

3628 3629
		if (err != EMULATE_DONE)
			return 0;
3630 3631

		if (signal_pending(current))
3632
			goto out;
3633 3634 3635 3636
		if (need_resched())
			schedule();
	}

3637 3638 3639
	vmx->emulation_required = 0;
out:
	return ret;
3640 3641
}

3642 3643 3644 3645
/*
 * Indicate a busy-waiting vcpu in spinlock. We do not enable the PAUSE
 * exiting, so only get here on cpu with PAUSE-Loop-Exiting.
 */
3646
static int handle_pause(struct kvm_vcpu *vcpu)
3647 3648 3649 3650 3651 3652 3653
{
	skip_emulated_instruction(vcpu);
	kvm_vcpu_on_spin(vcpu);

	return 1;
}

3654 3655 3656 3657 3658 3659
static int handle_invalid_op(struct kvm_vcpu *vcpu)
{
	kvm_queue_exception(vcpu, UD_VECTOR);
	return 1;
}

A
Avi Kivity 已提交
3660 3661 3662 3663 3664
/*
 * 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 已提交
3665
static int (*kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu) = {
A
Avi Kivity 已提交
3666 3667
	[EXIT_REASON_EXCEPTION_NMI]           = handle_exception,
	[EXIT_REASON_EXTERNAL_INTERRUPT]      = handle_external_interrupt,
3668
	[EXIT_REASON_TRIPLE_FAULT]            = handle_triple_fault,
3669
	[EXIT_REASON_NMI_WINDOW]	      = handle_nmi_window,
A
Avi Kivity 已提交
3670 3671 3672 3673 3674 3675 3676 3677
	[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 已提交
3678
	[EXIT_REASON_INVLPG]		      = handle_invlpg,
3679
	[EXIT_REASON_VMCALL]                  = handle_vmcall,
3680 3681 3682 3683 3684 3685 3686 3687 3688
	[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,
3689 3690
	[EXIT_REASON_TPR_BELOW_THRESHOLD]     = handle_tpr_below_threshold,
	[EXIT_REASON_APIC_ACCESS]             = handle_apic_access,
E
Eddie Dong 已提交
3691
	[EXIT_REASON_WBINVD]                  = handle_wbinvd,
3692
	[EXIT_REASON_XSETBV]                  = handle_xsetbv,
3693
	[EXIT_REASON_TASK_SWITCH]             = handle_task_switch,
A
Andi Kleen 已提交
3694
	[EXIT_REASON_MCE_DURING_VMENTRY]      = handle_machine_check,
3695 3696
	[EXIT_REASON_EPT_VIOLATION]	      = handle_ept_violation,
	[EXIT_REASON_EPT_MISCONFIG]           = handle_ept_misconfig,
3697
	[EXIT_REASON_PAUSE_INSTRUCTION]       = handle_pause,
3698 3699
	[EXIT_REASON_MWAIT_INSTRUCTION]	      = handle_invalid_op,
	[EXIT_REASON_MONITOR_INSTRUCTION]     = handle_invalid_op,
A
Avi Kivity 已提交
3700 3701 3702
};

static const int kvm_vmx_max_exit_handlers =
3703
	ARRAY_SIZE(kvm_vmx_exit_handlers);
A
Avi Kivity 已提交
3704 3705 3706 3707 3708

/*
 * The guest has exited.  See if we can fix it or if we need userspace
 * assistance.
 */
A
Avi Kivity 已提交
3709
static int vmx_handle_exit(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3710
{
3711
	struct vcpu_vmx *vmx = to_vmx(vcpu);
A
Andi Kleen 已提交
3712
	u32 exit_reason = vmx->exit_reason;
3713
	u32 vectoring_info = vmx->idt_vectoring_info;
3714

3715
	trace_kvm_exit(exit_reason, vcpu);
F
Feng (Eric) Liu 已提交
3716

3717 3718 3719
	/* If guest state is invalid, start emulating */
	if (vmx->emulation_required && emulate_invalid_guest_state)
		return handle_invalid_guest_state(vcpu);
3720

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

3726 3727 3728 3729 3730 3731 3732
	if (exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY) {
		vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;
		vcpu->run->fail_entry.hardware_entry_failure_reason
			= exit_reason;
		return 0;
	}

3733
	if (unlikely(vmx->fail)) {
A
Avi Kivity 已提交
3734 3735
		vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY;
		vcpu->run->fail_entry.hardware_entry_failure_reason
3736 3737 3738
			= vmcs_read32(VM_INSTRUCTION_ERROR);
		return 0;
	}
A
Avi Kivity 已提交
3739

M
Mike Day 已提交
3740
	if ((vectoring_info & VECTORING_INFO_VALID_MASK) &&
3741
			(exit_reason != EXIT_REASON_EXCEPTION_NMI &&
J
Jan Kiszka 已提交
3742 3743 3744 3745 3746
			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);
3747 3748

	if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked)) {
3749
		if (vmx_interrupt_allowed(vcpu)) {
3750 3751
			vmx->soft_vnmi_blocked = 0;
		} else if (vmx->vnmi_blocked_time > 1000000000LL &&
3752
			   vcpu->arch.nmi_pending) {
3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765
			/*
			 * 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 已提交
3766 3767
	if (exit_reason < kvm_vmx_max_exit_handlers
	    && kvm_vmx_exit_handlers[exit_reason])
A
Avi Kivity 已提交
3768
		return kvm_vmx_exit_handlers[exit_reason](vcpu);
A
Avi Kivity 已提交
3769
	else {
A
Avi Kivity 已提交
3770 3771
		vcpu->run->exit_reason = KVM_EXIT_UNKNOWN;
		vcpu->run->hw.hardware_exit_reason = exit_reason;
A
Avi Kivity 已提交
3772 3773 3774 3775
	}
	return 0;
}

3776
static void update_cr8_intercept(struct kvm_vcpu *vcpu, int tpr, int irr)
3777
{
3778
	if (irr == -1 || tpr < irr) {
3779 3780 3781 3782
		vmcs_write32(TPR_THRESHOLD, 0);
		return;
	}

3783
	vmcs_write32(TPR_THRESHOLD, irr);
3784 3785
}

3786 3787 3788
static void vmx_complete_interrupts(struct vcpu_vmx *vmx)
{
	u32 exit_intr_info;
3789
	u32 idt_vectoring_info = vmx->idt_vectoring_info;
3790 3791
	bool unblock_nmi;
	u8 vector;
3792 3793
	int type;
	bool idtv_info_valid;
3794 3795

	exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO);
3796

A
Andi Kleen 已提交
3797 3798 3799 3800 3801 3802 3803 3804
	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();

3805 3806
	/* We need to handle NMIs before interrupts are enabled */
	if ((exit_intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR &&
3807 3808
	    (exit_intr_info & INTR_INFO_VALID_MASK)) {
		kvm_before_handle_nmi(&vmx->vcpu);
3809
		asm("int $2");
3810 3811
		kvm_after_handle_nmi(&vmx->vcpu);
	}
3812 3813 3814

	idtv_info_valid = idt_vectoring_info & VECTORING_INFO_VALID_MASK;

3815 3816 3817 3818
	if (cpu_has_virtual_nmis()) {
		unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0;
		vector = exit_intr_info & INTR_INFO_VECTOR_MASK;
		/*
3819
		 * SDM 3: 27.7.1.2 (September 2008)
3820 3821
		 * Re-set bit "block by NMI" before VM entry if vmexit caused by
		 * a guest IRET fault.
3822 3823 3824 3825 3826
		 * 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.
3827
		 */
3828 3829
		if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi &&
		    vector != DF_VECTOR && !idtv_info_valid)
3830 3831
			vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
				      GUEST_INTR_STATE_NMI);
3832 3833 3834
	} else if (unlikely(vmx->soft_vnmi_blocked))
		vmx->vnmi_blocked_time +=
			ktime_to_ns(ktime_sub(ktime_get(), vmx->entry_time));
3835

3836 3837 3838 3839 3840 3841 3842
	vmx->vcpu.arch.nmi_injected = false;
	kvm_clear_exception_queue(&vmx->vcpu);
	kvm_clear_interrupt_queue(&vmx->vcpu);

	if (!idtv_info_valid)
		return;

3843 3844
	vector = idt_vectoring_info & VECTORING_INFO_VECTOR_MASK;
	type = idt_vectoring_info & VECTORING_INFO_TYPE_MASK;
3845

3846
	switch (type) {
3847 3848
	case INTR_TYPE_NMI_INTR:
		vmx->vcpu.arch.nmi_injected = true;
3849
		/*
3850
		 * SDM 3: 27.7.1.2 (September 2008)
3851 3852
		 * Clear bit "block by NMI" before VM entry if a NMI
		 * delivery faulted.
3853
		 */
3854 3855 3856 3857
		vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO,
				GUEST_INTR_STATE_NMI);
		break;
	case INTR_TYPE_SOFT_EXCEPTION:
3858 3859 3860 3861
		vmx->vcpu.arch.event_exit_inst_len =
			vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
		/* fall through */
	case INTR_TYPE_HARD_EXCEPTION:
3862
		if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) {
3863 3864
			u32 err = vmcs_read32(IDT_VECTORING_ERROR_CODE);
			kvm_queue_exception_e(&vmx->vcpu, vector, err);
3865 3866
		} else
			kvm_queue_exception(&vmx->vcpu, vector);
3867
		break;
3868 3869 3870 3871
	case INTR_TYPE_SOFT_INTR:
		vmx->vcpu.arch.event_exit_inst_len =
			vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
		/* fall through */
3872
	case INTR_TYPE_EXT_INTR:
3873 3874
		kvm_queue_interrupt(&vmx->vcpu, vector,
			type == INTR_TYPE_SOFT_INTR);
3875 3876 3877
		break;
	default:
		break;
3878
	}
3879 3880
}

3881 3882 3883 3884 3885 3886 3887 3888 3889
/*
 * 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;
3890
	if (kvm_rip_read(&vmx->vcpu) + 1 != vmx->rmode.irq.rip)
3891
		return;
3892
	kvm_rip_write(&vmx->vcpu, vmx->rmode.irq.rip);
3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903
	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;
}

3904 3905 3906 3907 3908 3909 3910 3911
#ifdef CONFIG_X86_64
#define R "r"
#define Q "q"
#else
#define R "e"
#define Q "l"
#endif

A
Avi Kivity 已提交
3912
static void vmx_vcpu_run(struct kvm_vcpu *vcpu)
A
Avi Kivity 已提交
3913
{
3914
	struct vcpu_vmx *vmx = to_vmx(vcpu);
3915

3916 3917 3918 3919
	/* 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();

3920 3921 3922
	/* 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)
3923 3924
		return;

3925 3926 3927 3928 3929
	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]);

3930 3931 3932 3933 3934 3935 3936 3937
	/* 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);

M
Mike Day 已提交
3938
	asm(
A
Avi Kivity 已提交
3939
		/* Store host registers */
3940 3941
		"push %%"R"dx; push %%"R"bp;"
		"push %%"R"cx \n\t"
3942 3943 3944
		"cmp %%"R"sp, %c[host_rsp](%0) \n\t"
		"je 1f \n\t"
		"mov %%"R"sp, %c[host_rsp](%0) \n\t"
3945
		__ex(ASM_VMX_VMWRITE_RSP_RDX) "\n\t"
3946
		"1: \n\t"
3947 3948 3949 3950 3951 3952 3953
		/* 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 已提交
3954
		/* Check if vmlaunch of vmresume is needed */
3955
		"cmpl $0, %c[launched](%0) \n\t"
A
Avi Kivity 已提交
3956
		/* Load guest registers.  Don't clobber flags. */
3957 3958 3959 3960 3961 3962
		"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"
3963
#ifdef CONFIG_X86_64
3964 3965 3966 3967 3968 3969 3970 3971
		"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 已提交
3972
#endif
3973 3974
		"mov %c[rcx](%0), %%"R"cx \n\t" /* kills %0 (ecx) */

A
Avi Kivity 已提交
3975
		/* Enter guest mode */
3976
		"jne .Llaunched \n\t"
3977
		__ex(ASM_VMX_VMLAUNCH) "\n\t"
3978
		"jmp .Lkvm_vmx_return \n\t"
3979
		".Llaunched: " __ex(ASM_VMX_VMRESUME) "\n\t"
3980
		".Lkvm_vmx_return: "
A
Avi Kivity 已提交
3981
		/* Save guest registers, load host registers, keep flags */
3982 3983 3984 3985 3986 3987 3988 3989
		"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"
3990
#ifdef CONFIG_X86_64
3991 3992 3993 3994 3995 3996 3997 3998
		"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 已提交
3999
#endif
4000 4001 4002 4003
		"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"
4004 4005 4006 4007
		"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)),
4008
		[host_rsp]"i"(offsetof(struct vcpu_vmx, host_rsp)),
4009 4010 4011 4012 4013 4014 4015
		[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])),
4016
#ifdef CONFIG_X86_64
4017 4018 4019 4020 4021 4022 4023 4024
		[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 已提交
4025
#endif
4026
		[cr2]"i"(offsetof(struct vcpu_vmx, vcpu.arch.cr2))
4027
	      : "cc", "memory"
4028
		, R"bx", R"di", R"si"
4029 4030 4031 4032
#ifdef CONFIG_X86_64
		, "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
#endif
	      );
A
Avi Kivity 已提交
4033

A
Avi Kivity 已提交
4034 4035
	vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) | (1 << VCPU_REGS_RSP)
				  | (1 << VCPU_EXREG_PDPTR));
4036 4037
	vcpu->arch.regs_dirty = 0;

4038
	vmx->idt_vectoring_info = vmcs_read32(IDT_VECTORING_INFO_FIELD);
4039 4040
	if (vmx->rmode.irq.pending)
		fixup_rmode_irq(vmx);
4041

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

4045
	vmx_complete_interrupts(vmx);
A
Avi Kivity 已提交
4046 4047
}

4048 4049 4050
#undef R
#undef Q

A
Avi Kivity 已提交
4051 4052
static void vmx_free_vmcs(struct kvm_vcpu *vcpu)
{
4053 4054 4055
	struct vcpu_vmx *vmx = to_vmx(vcpu);

	if (vmx->vmcs) {
4056
		vcpu_clear(vmx);
4057 4058
		free_vmcs(vmx->vmcs);
		vmx->vmcs = NULL;
A
Avi Kivity 已提交
4059 4060 4061 4062 4063
	}
}

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

4066
	free_vpid(vmx);
A
Avi Kivity 已提交
4067
	vmx_free_vmcs(vcpu);
R
Rusty Russell 已提交
4068 4069
	kfree(vmx->guest_msrs);
	kvm_vcpu_uninit(vcpu);
4070
	kmem_cache_free(kvm_vcpu_cache, vmx);
A
Avi Kivity 已提交
4071 4072
}

4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085
static inline void vmcs_init(struct vmcs *vmcs)
{
	u64 phys_addr = __pa(per_cpu(vmxarea, raw_smp_processor_id()));

	if (!vmm_exclusive)
		kvm_cpu_vmxon(phys_addr);

	vmcs_clear(vmcs);

	if (!vmm_exclusive)
		kvm_cpu_vmxoff();
}

R
Rusty Russell 已提交
4086
static struct kvm_vcpu *vmx_create_vcpu(struct kvm *kvm, unsigned int id)
A
Avi Kivity 已提交
4087
{
R
Rusty Russell 已提交
4088
	int err;
4089
	struct vcpu_vmx *vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL);
4090
	int cpu;
A
Avi Kivity 已提交
4091

4092
	if (!vmx)
R
Rusty Russell 已提交
4093 4094
		return ERR_PTR(-ENOMEM);

4095 4096
	allocate_vpid(vmx);

R
Rusty Russell 已提交
4097 4098 4099
	err = kvm_vcpu_init(&vmx->vcpu, kvm, id);
	if (err)
		goto free_vcpu;
4100

4101
	vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL);
R
Rusty Russell 已提交
4102 4103 4104 4105
	if (!vmx->guest_msrs) {
		err = -ENOMEM;
		goto uninit_vcpu;
	}
4106

4107 4108
	vmx->vmcs = alloc_vmcs();
	if (!vmx->vmcs)
R
Rusty Russell 已提交
4109
		goto free_msrs;
4110

4111
	vmcs_init(vmx->vmcs);
4112

4113 4114
	cpu = get_cpu();
	vmx_vcpu_load(&vmx->vcpu, cpu);
R
Rusty Russell 已提交
4115
	err = vmx_vcpu_setup(vmx);
R
Rusty Russell 已提交
4116
	vmx_vcpu_put(&vmx->vcpu);
4117
	put_cpu();
R
Rusty Russell 已提交
4118 4119
	if (err)
		goto free_vmcs;
4120 4121 4122
	if (vm_need_virtualize_apic_accesses(kvm))
		if (alloc_apic_access_page(kvm) != 0)
			goto free_vmcs;
R
Rusty Russell 已提交
4123

4124 4125 4126 4127
	if (enable_ept) {
		if (!kvm->arch.ept_identity_map_addr)
			kvm->arch.ept_identity_map_addr =
				VMX_EPT_IDENTITY_PAGETABLE_ADDR;
4128 4129
		if (alloc_identity_pagetable(kvm) != 0)
			goto free_vmcs;
4130
	}
4131

R
Rusty Russell 已提交
4132 4133 4134 4135 4136 4137 4138 4139 4140
	return &vmx->vcpu;

free_vmcs:
	free_vmcs(vmx->vmcs);
free_msrs:
	kfree(vmx->guest_msrs);
uninit_vcpu:
	kvm_vcpu_uninit(&vmx->vcpu);
free_vcpu:
4141
	free_vpid(vmx);
4142
	kmem_cache_free(kvm_vcpu_cache, vmx);
R
Rusty Russell 已提交
4143
	return ERR_PTR(err);
A
Avi Kivity 已提交
4144 4145
}

Y
Yang, Sheng 已提交
4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159
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;
	}
}

4160 4161 4162 4163 4164
static int get_ept_level(void)
{
	return VMX_EPT_DEFAULT_GAW + 1;
}

4165
static u64 vmx_get_mt_mask(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio)
S
Sheng Yang 已提交
4166
{
4167 4168
	u64 ret;

4169 4170 4171 4172 4173 4174 4175 4176
	/* 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.
4177
	 * 3. EPT without VT-d: always map as WB and set IPAT=1 to keep
4178 4179
	 *    consistent with host MTRR
	 */
4180 4181
	if (is_mmio)
		ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT;
4182 4183 4184 4185
	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;
4186
	else
4187
		ret = (MTRR_TYPE_WRBACK << VMX_EPT_MT_EPTE_SHIFT)
4188
			| VMX_EPT_IPAT_BIT;
4189 4190

	return ret;
S
Sheng Yang 已提交
4191 4192
}

4193 4194
#define _ER(x) { EXIT_REASON_##x, #x }

4195
static const struct trace_print_flags vmx_exit_reasons_str[] = {
4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230
	_ER(EXCEPTION_NMI),
	_ER(EXTERNAL_INTERRUPT),
	_ER(TRIPLE_FAULT),
	_ER(PENDING_INTERRUPT),
	_ER(NMI_WINDOW),
	_ER(TASK_SWITCH),
	_ER(CPUID),
	_ER(HLT),
	_ER(INVLPG),
	_ER(RDPMC),
	_ER(RDTSC),
	_ER(VMCALL),
	_ER(VMCLEAR),
	_ER(VMLAUNCH),
	_ER(VMPTRLD),
	_ER(VMPTRST),
	_ER(VMREAD),
	_ER(VMRESUME),
	_ER(VMWRITE),
	_ER(VMOFF),
	_ER(VMON),
	_ER(CR_ACCESS),
	_ER(DR_ACCESS),
	_ER(IO_INSTRUCTION),
	_ER(MSR_READ),
	_ER(MSR_WRITE),
	_ER(MWAIT_INSTRUCTION),
	_ER(MONITOR_INSTRUCTION),
	_ER(PAUSE_INSTRUCTION),
	_ER(MCE_DURING_VMENTRY),
	_ER(TPR_BELOW_THRESHOLD),
	_ER(APIC_ACCESS),
	_ER(EPT_VIOLATION),
	_ER(EPT_MISCONFIG),
	_ER(WBINVD),
4231 4232 4233
	{ -1, NULL }
};

4234 4235
#undef _ER

4236
static int vmx_get_lpage_level(void)
4237
{
4238 4239 4240 4241 4242
	if (enable_ept && !cpu_has_vmx_ept_1g_page())
		return PT_DIRECTORY_LEVEL;
	else
		/* For shadow and EPT supported 1GB page */
		return PT_PDPE_LEVEL;
4243 4244
}

4245 4246 4247 4248 4249
static inline u32 bit(int bitno)
{
	return 1 << (bitno & 31);
}

4250 4251
static void vmx_cpuid_update(struct kvm_vcpu *vcpu)
{
4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269
	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);
			}
		}
	}
4270 4271
}

4272 4273 4274 4275
static void vmx_set_supported_cpuid(u32 func, struct kvm_cpuid_entry2 *entry)
{
}

4276
static struct kvm_x86_ops vmx_x86_ops = {
A
Avi Kivity 已提交
4277 4278 4279 4280
	.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 已提交
4281
	.check_processor_compatibility = vmx_check_processor_compat,
A
Avi Kivity 已提交
4282 4283
	.hardware_enable = hardware_enable,
	.hardware_disable = hardware_disable,
4284
	.cpu_has_accelerated_tpr = report_flexpriority,
A
Avi Kivity 已提交
4285 4286 4287

	.vcpu_create = vmx_create_vcpu,
	.vcpu_free = vmx_free_vcpu,
4288
	.vcpu_reset = vmx_vcpu_reset,
A
Avi Kivity 已提交
4289

4290
	.prepare_guest_switch = vmx_save_host_state,
A
Avi Kivity 已提交
4291 4292 4293 4294 4295 4296 4297 4298 4299
	.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,
4300
	.get_cpl = vmx_get_cpl,
A
Avi Kivity 已提交
4301
	.get_cs_db_l_bits = vmx_get_cs_db_l_bits,
4302
	.decache_cr0_guest_bits = vmx_decache_cr0_guest_bits,
4303
	.decache_cr4_guest_bits = vmx_decache_cr4_guest_bits,
A
Avi Kivity 已提交
4304 4305 4306 4307 4308 4309 4310 4311
	.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,
4312
	.set_dr7 = vmx_set_dr7,
4313
	.cache_reg = vmx_cache_reg,
A
Avi Kivity 已提交
4314 4315
	.get_rflags = vmx_get_rflags,
	.set_rflags = vmx_set_rflags,
4316
	.fpu_activate = vmx_fpu_activate,
4317
	.fpu_deactivate = vmx_fpu_deactivate,
A
Avi Kivity 已提交
4318 4319 4320 4321

	.tlb_flush = vmx_flush_tlb,

	.run = vmx_vcpu_run,
4322
	.handle_exit = vmx_handle_exit,
A
Avi Kivity 已提交
4323
	.skip_emulated_instruction = skip_emulated_instruction,
4324 4325
	.set_interrupt_shadow = vmx_set_interrupt_shadow,
	.get_interrupt_shadow = vmx_get_interrupt_shadow,
I
Ingo Molnar 已提交
4326
	.patch_hypercall = vmx_patch_hypercall,
E
Eddie Dong 已提交
4327
	.set_irq = vmx_inject_irq,
4328
	.set_nmi = vmx_inject_nmi,
4329
	.queue_exception = vmx_queue_exception,
4330
	.interrupt_allowed = vmx_interrupt_allowed,
4331
	.nmi_allowed = vmx_nmi_allowed,
J
Jan Kiszka 已提交
4332 4333
	.get_nmi_mask = vmx_get_nmi_mask,
	.set_nmi_mask = vmx_set_nmi_mask,
4334 4335 4336 4337
	.enable_nmi_window = enable_nmi_window,
	.enable_irq_window = enable_irq_window,
	.update_cr8_intercept = update_cr8_intercept,

4338
	.set_tss_addr = vmx_set_tss_addr,
4339
	.get_tdp_level = get_ept_level,
4340
	.get_mt_mask = vmx_get_mt_mask,
4341 4342

	.exit_reasons_str = vmx_exit_reasons_str,
4343
	.get_lpage_level = vmx_get_lpage_level,
4344 4345

	.cpuid_update = vmx_cpuid_update,
4346 4347

	.rdtscp_supported = vmx_rdtscp_supported,
4348 4349

	.set_supported_cpuid = vmx_set_supported_cpuid,
A
Avi Kivity 已提交
4350 4351 4352 4353
};

static int __init vmx_init(void)
{
4354 4355 4356 4357 4358 4359
	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]);
4360

4361
	vmx_io_bitmap_a = (unsigned long *)__get_free_page(GFP_KERNEL);
4362 4363 4364
	if (!vmx_io_bitmap_a)
		return -ENOMEM;

4365
	vmx_io_bitmap_b = (unsigned long *)__get_free_page(GFP_KERNEL);
4366 4367 4368 4369 4370
	if (!vmx_io_bitmap_b) {
		r = -ENOMEM;
		goto out;
	}

4371 4372
	vmx_msr_bitmap_legacy = (unsigned long *)__get_free_page(GFP_KERNEL);
	if (!vmx_msr_bitmap_legacy) {
S
Sheng Yang 已提交
4373 4374 4375 4376
		r = -ENOMEM;
		goto out1;
	}

4377 4378 4379 4380 4381 4382
	vmx_msr_bitmap_longmode = (unsigned long *)__get_free_page(GFP_KERNEL);
	if (!vmx_msr_bitmap_longmode) {
		r = -ENOMEM;
		goto out2;
	}

4383 4384 4385 4386
	/*
	 * Allow direct access to the PC debug port (it is often used for I/O
	 * delays, but the vmexits simply slow things down).
	 */
4387 4388
	memset(vmx_io_bitmap_a, 0xff, PAGE_SIZE);
	clear_bit(0x80, vmx_io_bitmap_a);
4389

4390
	memset(vmx_io_bitmap_b, 0xff, PAGE_SIZE);
4391

4392 4393
	memset(vmx_msr_bitmap_legacy, 0xff, PAGE_SIZE);
	memset(vmx_msr_bitmap_longmode, 0xff, PAGE_SIZE);
S
Sheng Yang 已提交
4394

4395 4396
	set_bit(0, vmx_vpid_bitmap); /* 0 is reserved for host */

4397 4398
	r = kvm_init(&vmx_x86_ops, sizeof(struct vcpu_vmx),
		     __alignof__(struct vcpu_vmx), THIS_MODULE);
4399
	if (r)
4400
		goto out3;
S
Sheng Yang 已提交
4401

4402 4403 4404 4405 4406 4407
	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);
4408

4409
	if (enable_ept) {
4410
		bypass_guest_pf = 0;
4411
		kvm_mmu_set_base_ptes(VMX_EPT_READABLE_MASK |
4412
			VMX_EPT_WRITABLE_MASK);
4413
		kvm_mmu_set_mask_ptes(0ull, 0ull, 0ull, 0ull,
4414
				VMX_EPT_EXECUTABLE_MASK);
4415 4416 4417
		kvm_enable_tdp();
	} else
		kvm_disable_tdp();
4418

4419 4420 4421
	if (bypass_guest_pf)
		kvm_mmu_set_nonpresent_ptes(~0xffeull, 0ull);

4422 4423
	return 0;

4424 4425
out3:
	free_page((unsigned long)vmx_msr_bitmap_longmode);
S
Sheng Yang 已提交
4426
out2:
4427
	free_page((unsigned long)vmx_msr_bitmap_legacy);
4428
out1:
4429
	free_page((unsigned long)vmx_io_bitmap_b);
4430
out:
4431
	free_page((unsigned long)vmx_io_bitmap_a);
4432
	return r;
A
Avi Kivity 已提交
4433 4434 4435 4436
}

static void __exit vmx_exit(void)
{
4437 4438
	free_page((unsigned long)vmx_msr_bitmap_legacy);
	free_page((unsigned long)vmx_msr_bitmap_longmode);
4439 4440
	free_page((unsigned long)vmx_io_bitmap_b);
	free_page((unsigned long)vmx_io_bitmap_a);
4441

4442
	kvm_exit();
A
Avi Kivity 已提交
4443 4444 4445 4446
}

module_init(vmx_init)
module_exit(vmx_exit)