vmx: Squelch per-core startup messages
[akaros.git] / kern / arch / x86 / vmm / intel / vmx.c
1 //#define DEBUG
2 /**
3  *  vmx.c - The Intel VT-x driver for Dune
4  *
5  * This file is derived from Linux KVM VT-x support.
6  * Copyright (C) 2006 Qumranet, Inc.
7  * Copyright 2010 Red Hat, Inc. and/or its affiliates.
8  *
9  * Original Authors:
10  *   Avi Kivity   <avi@qumranet.com>
11  *   Yaniv Kamay  <yaniv@qumranet.com>
12  *
13  * This modified version is simpler because it avoids the following
14  * features that are not requirements for Dune:
15  *  * Real-mode emulation
16  *  * Nested VT-x support
17  *  * I/O hardware emulation
18  *  * Any of the more esoteric X86 features and registers
19  *  * KVM-specific functionality
20  *
21  * In essence we provide only the minimum functionality needed to run
22  * a process in vmx non-root mode rather than the full hardware emulation
23  * needed to support an entire OS.
24  *
25  * This driver is a research prototype and as such has the following
26  * limitations:
27  *
28  * FIXME: Backward compatibility is currently a non-goal, and only recent
29  * full-featured (EPT, PCID, VPID, etc.) Intel hardware is supported by this
30  * driver.
31  *
32  * FIXME: Eventually we should handle concurrent user's of VT-x more
33  * gracefully instead of requiring exclusive access. This would allow
34  * Dune to interoperate with KVM and other HV solutions.
35  *
36  * FIXME: We need to support hotplugged physical CPUs.
37  *
38  * Authors:
39  *   Adam Belay   <abelay@stanford.edu>
40  */
41
42 /* Basic flow.
43  * Yep, it's confusing. This is in part because the vmcs is used twice, for two different things.
44  * You're left with the feeling that they got part way through and realized they had to have one for
45  *
46  * 1) your CPU is going to be capable of running VMs, and you need state for that.
47  *
48  * 2) you're about to start a guest, and you need state for that.
49  *
50  * So there is get cpu set up to be able to run VMs stuff, and now
51  * let's start a guest stuff.  In Akaros, CPUs will always be set up
52  * to run a VM if that is possible. Processes can flip themselves into
53  * a VM and that will require another VMCS.
54  *
55  * So: at kernel startup time, the SMP boot stuff calls
56  * k/a/x86/vmm/vmm.c:vmm_init, which calls arch-dependent bits, which
57  * in the case of this file is intel_vmm_init. That does some code
58  * that sets up stuff for ALL sockets, based on the capabilities of
59  * the socket it runs on. If any cpu supports vmx, it assumes they all
60  * do. That's a realistic assumption. So the call_function_all is kind
61  * of stupid, really; it could just see what's on the current cpu and
62  * assume it's on all. HOWEVER: there are systems in the wild that
63  * can run VMs on some but not all CPUs, due to BIOS mistakes, so we
64  * might as well allow for the chance that we'll only all VMMCPs on a
65  * subset (not implemented yet however).  So: probe all CPUs, get a
66  * count of how many support VMX and, for now, assume they all do
67  * anyway.
68  *
69  * Next, call setup_vmcs_config to configure the GLOBAL vmcs_config struct,
70  * which contains all the naughty bits settings for all the cpus that can run a VM.
71  * Realistically, all VMX-capable cpus in a system will have identical configurations.
72  * So: 0 or more cpus can run VMX; all cpus which can run VMX will have the same configuration.
73  *
74  * configure the msr_bitmap. This is the bitmap of MSRs which the
75  * guest can manipulate.  Currently, we only allow GS and FS base.
76  *
77  * Reserve bit 0 in the vpid bitmap as guests can not use that
78  *
79  * Set up the what we call the vmxarea. The vmxarea is per-cpu, not
80  * per-guest. Once set up, it is left alone.  The ONLY think we set in
81  * there is the revision area. The VMX is page-sized per cpu and
82  * page-aligned. Note that it can be smaller, but why bother? We know
83  * the max size and alignment, and it's convenient.
84  *
85  * Now that it is set up, enable vmx on all cpus. This involves
86  * testing VMXE in cr4, to see if we've been here before (TODO: delete
87  * this test), then testing MSR_IA32_FEATURE_CONTROL to see if we can
88  * do a VM, the setting the VMXE in cr4, calling vmxon (does a vmxon
89  * instruction), and syncing vpid's and ept's.  Now the CPU is ready
90  * to host guests.
91  *
92  * Setting up a guest.
93  * We divide this into two things: vmm_proc_init and vm_run.
94  * Currently, on Intel, vmm_proc_init does nothing.
95  *
96  * vm_run is really complicated. It is called with a coreid, and
97  * vmctl struct. On intel, it calls vmx_launch. vmx_launch is set
98  * up for a few test cases. If rip is 1, it sets the guest rip to
99  * a function which will deref 0 and should exit with failure 2. If rip is 0,
100  * it calls an infinite loop in the guest.
101  *
102  * The sequence of operations:
103  * create a vcpu
104  * while (1) {
105  * get a vcpu
106  * disable irqs (required or you can't enter the VM)
107  * vmx_run_vcpu()
108  * enable irqs
109  * manage the vm exit
110  * }
111  *
112  * get a vcpu
113  * See if the current cpu has a vcpu. If so, and is the same as the vcpu we want,
114  * vmcs_load(vcpu->vmcs) -- i.e. issue a VMPTRLD.
115  *
116  * If it's not the same, see if the vcpu thinks it is on the core. If it is not, call
117  * __vmx_get_cpu_helper on the other cpu, to free it up. Else vmcs_clear the one
118  * attached to this cpu. Then vmcs_load the vmcs for vcpu on this this cpu,
119  * call __vmx_setup_cpu, mark this vcpu as being attached to this cpu, done.
120  *
121  * vmx_run_vcpu this one gets messy, mainly because it's a giant wad
122  * of inline assembly with embedded CPP crap. I suspect we'll want to
123  * un-inline it someday, but maybe not.  It's called with a vcpu
124  * struct from which it loads guest state, and to which it stores
125  * non-virtualized host state. It issues a vmlaunch or vmresume
126  * instruction depending, and on return, it evaluates if things the
127  * launch/resume had an error in that operation. Note this is NOT the
128  * same as an error while in the virtual machine; this is an error in
129  * startup due to misconfiguration. Depending on what is returned it's
130  * either a failed vm startup or an exit for lots of many reasons.
131  *
132  */
133
134 /* basically: only rename those globals that might conflict
135  * with existing names. Leave all else the same.
136  * this code is more modern than the other code, yet still
137  * well encapsulated, it seems.
138  */
139 #include <kmalloc.h>
140 #include <string.h>
141 #include <stdio.h>
142 #include <assert.h>
143 #include <error.h>
144 #include <pmap.h>
145 #include <sys/queue.h>
146 #include <smp.h>
147 #include <kref.h>
148 #include <atomic.h>
149 #include <alarm.h>
150 #include <event.h>
151 #include <umem.h>
152 #include <bitops.h>
153 #include <arch/types.h>
154 #include <syscall.h>
155 #include <arch/io.h>
156 #include <percpu.h>
157
158 #include <ros/vmm.h>
159 #include "vmx.h"
160 #include "../vmm.h"
161
162 #include <trap.h>
163
164 #include <smp.h>
165 #include <ros/procinfo.h>
166
167 #define currentcpu (&per_cpu_info[core_id()])
168
169 static unsigned long *msr_bitmap;
170 #define VMX_IO_BITMAP_SZ                (1 << 16) /* 64 KB */
171 static unsigned long *io_bitmap;
172
173 int x86_ept_pte_fix_ups = 0;
174
175 struct vmx_capability vmx_capability;
176 struct vmcs_config vmcs_config;
177
178 char * const VMX_EXIT_REASON_NAMES[] = {
179         VMX_EXIT_REASONS
180 };
181
182 static char *cr_access_type[] = {
183         "move to cr",
184         "move from cr",
185         "clts",
186         "lmsw"
187 };
188
189 static char *cr_gpr[] = {
190         "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
191         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
192 };
193
194 static int guest_cr_num[16] = {
195         GUEST_CR0,
196         -1,
197         -1,
198         GUEST_CR3,
199         GUEST_CR4,
200         -1,
201         -1,
202         -1,
203         -1,     /* 8? */
204         -1, -1, -1, -1, -1, -1, -1
205 };
206
207 __always_inline unsigned long vmcs_readl(unsigned long field);
208 /* See section 24-3 of The Good Book */
209 void
210 show_cr_access(uint64_t val)
211 {
212         int crnr = val & 0xf;
213         int type = (val >> 4) & 3;
214         int reg = (val >> 11) & 0xf;
215         printk("%s: %d: ", cr_access_type[type], crnr);
216         if (type < 2) {
217                 printk("%s", cr_gpr[reg]);
218                 if (guest_cr_num[crnr] > -1) {
219                         printk(": 0x%x", vmcs_readl(guest_cr_num[crnr]));
220                 }
221         }
222         printk("\n");
223 }
224
225 void
226 ept_flush(uint64_t eptp)
227 {
228         ept_sync_context(eptp);
229 }
230
231 static void
232 vmcs_clear(struct vmcs *vmcs)
233 {
234         uint64_t phys_addr = PADDR(vmcs);
235         uint8_t error;
236
237         asm volatile (ASM_VMX_VMCLEAR_RAX "; setna %0":"=qm"(error):"a"(&phys_addr),
238                                   "m"(phys_addr)
239                                   :"cc", "memory");
240         if (error)
241                 printk("vmclear fail: %p/%llx\n", vmcs, phys_addr);
242 }
243
244 static void
245 vmcs_load(struct vmcs *vmcs)
246 {
247         uint64_t phys_addr = PADDR(vmcs);
248         uint8_t error;
249
250         asm volatile (ASM_VMX_VMPTRLD_RAX "; setna %0":"=qm"(error):"a"(&phys_addr),
251                                   "m"(phys_addr)
252                                   :"cc", "memory");
253         if (error)
254                 printk("vmptrld %p/%llx failed\n", vmcs, phys_addr);
255 }
256
257 /* Returns the paddr pointer of the current CPU's VMCS region, or -1 if none. */
258 static physaddr_t
259 vmcs_get_current(void)
260 {
261         physaddr_t vmcs_paddr;
262         /* RAX contains the addr of the location to store the VMCS pointer.  The
263          * compiler doesn't know the ASM will deref that pointer, hence the =m */
264         asm volatile (ASM_VMX_VMPTRST_RAX:"=m"(vmcs_paddr):"a"(&vmcs_paddr));
265         return vmcs_paddr;
266 }
267
268 __always_inline unsigned long
269 vmcs_readl(unsigned long field)
270 {
271         return vmcs_read(field);
272 }
273
274 __always_inline uint16_t
275 vmcs_read16(unsigned long field)
276 {
277         return vmcs_readl(field);
278 }
279
280 static __always_inline uint32_t
281 vmcs_read32(unsigned long field)
282 {
283         return vmcs_readl(field);
284 }
285
286 static __always_inline uint64_t
287 vmcs_read64(unsigned long field)
288 {
289         return vmcs_readl(field);
290 }
291
292 void
293 vmwrite_error(unsigned long field, unsigned long value)
294 {
295         printk("vmwrite error: reg %lx value %lx (err %d)\n",
296                    field, value, vmcs_read32(VM_INSTRUCTION_ERROR));
297 }
298
299 void
300 vmcs_writel(unsigned long field, unsigned long value)
301 {
302         if (!vmcs_write(field, value))
303                 vmwrite_error(field, value);
304 }
305
306 static void
307 vmcs_write16(unsigned long field, uint16_t value)
308 {
309         vmcs_writel(field, value);
310 }
311
312 static void
313 vmcs_write32(unsigned long field, uint32_t value)
314 {
315         vmcs_writel(field, value);
316 }
317
318 static void
319 vmcs_write64(unsigned long field, uint64_t value)
320 {
321         vmcs_writel(field, value);
322 }
323
324 void vapic_status_dump_kernel(void *vapic);
325
326 static bool vmx_control_can_be_changed(struct vmxec *v, uint32_t ctl)
327 {
328         return v->hw_changeable & v->policy_changeable & ctl;
329 }
330
331 /*
332  * A note on Things You Can't Make Up.
333  * or
334  * "George, you can type this shit, but you can't say it" -- Harrison Ford
335  *
336  * There are 5 VMCS 32-bit words that control guest permissions. If
337  * you set these correctly, you've got a guest that will behave. If
338  * you get even one bit wrong, you've got a guest that will chew your
339  * leg off. Some bits must be 1, some must be 0, and some can be set
340  * either way. To add to the fun, the docs are sort of a docudrama or,
341  * as the quote goes, "interesting if true."
342  *
343  * To determine what bit can be set in what VMCS 32-bit control word,
344  * there are 5 corresponding 64-bit MSRs.  And, to make it even more
345  * fun, the standard set of MSRs have errors in them, i.e. report
346  * incorrect values, for legacy reasons, and so you are supposed to
347  * "look around" to another set, which have correct bits in
348  * them. There are four such 'correct' registers, and they have _TRUE_
349  * in the names as you can see below. We test for the value of VMCS
350  * control bits in the _TRUE_ registers if possible. The fifth
351  * register, CPU Secondary Exec Controls, which came later, needs no
352  * _TRUE_ variant.
353  *
354  * For each MSR, the high 32 bits tell you what bits can be "1" by a
355  * "1" in that position; the low 32 bits tell you what bit can be "0"
356  * by a "0" in that position. So, for each of 32 bits in a given VMCS
357  * control word, there is a pair of bits in an MSR that tells you what
358  * values it can take. The two bits, of which there are *four*
359  * combinations, describe the *three* possible operations on a
360  * bit. The two bits, taken together, form an untruth table: There are
361  * three possibilities: The VMCS bit can be set to 0 or 1, or it can
362  * only be 0, or only 1. The fourth combination is not supposed to
363  * happen.
364  *
365  * So: there is the 1 bit from the upper 32 bits of the msr.
366  * If this bit is set, then the bit can be 1. If clear, it can not be 1.
367  *
368  * Then there is the 0 bit, from low 32 bits. If clear, the VMCS bit
369  * can be 0. If 1, the VMCS bit can not be 0.
370  *
371  * SO, let's call the 1 bit R1, and the 0 bit R0, we have:
372  *  R1 R0
373  *  0 0 -> must be 0
374  *  1 0 -> can be 1, can be 0
375  *  0 1 -> can not be 1, can not be 0. --> JACKPOT! Not seen yet.
376  *  1 1 -> must be one.
377  *
378  * It's also pretty hard to know what you can and can't set, and
379  * that's led to inadvertent opening of permissions at times.  Because
380  * of this complexity we've decided on the following: the driver must
381  * define EVERY bit, UNIQUELY, for each of the 5 registers, that it wants
382  * set. Further, for any bit that's settable, the driver must specify
383  * a setting; for any bit that's reserved, the driver settings must
384  * match that bit. If there are reserved bits we don't specify, that's
385  * ok; we'll take them as is.
386  *
387  * We use a set-means-set, and set-means-clear model, i.e. we use a
388  * 32-bit word to contain the bits we want to be 1, indicated by one;
389  * and another 32-bit word in which a bit we want to be 0 is indicated
390  * by a 1. This allows us to easily create masks of all bits we're
391  * going to set, for example.
392  *
393  * We have two 32-bit numbers for each 32-bit VMCS field: bits we want
394  * set and bits we want clear.  If you read the MSR for that field,
395  * compute the reserved 0 and 1 settings, and | them together, they
396  * need to result in 0xffffffff. You can see that we can create other
397  * tests for conflicts (i.e. overlap).
398  *
399  * At this point, I've tested check_vmx_controls in every way
400  * possible, because I kept screwing the bitfields up. You'll get a nice
401  * error it won't work at all, which is what we want: a
402  * failure-prone setup, where even errors that might result in correct
403  * values are caught -- "right answer, wrong method, zero credit." If there's
404  * weirdness in the bits, we don't want to run.
405  * The try_set stuff adds particular ugliness but we have to have it.
406  */
407 static bool check_vmxec_controls(struct vmxec *v, bool have_true_msr,
408                                  uint32_t *result)
409 {
410         bool err = false;
411         uint32_t vmx_msr_low, vmx_msr_high;
412         uint64_t msr_val;
413         uint32_t reserved_0, reserved_1, changeable_bits, try0, try1;
414
415         if (have_true_msr)
416                 msr_val = read_msr(v->truemsr);
417         else
418                 msr_val = read_msr(v->msr);
419         vmx_msr_high = high32(msr_val);
420         vmx_msr_low = low32(msr_val);
421
422         if (vmx_msr_low & ~vmx_msr_high)
423                 warn("JACKPOT: Conflicting VMX ec ctls for %s, high 0x%08x low 0x%08x",
424                          v->name, vmx_msr_high, vmx_msr_low);
425
426         reserved_0 = (~vmx_msr_low) & (~vmx_msr_high);
427         reserved_1 = vmx_msr_low & vmx_msr_high;
428         changeable_bits = ~(reserved_0 | reserved_1);
429         v->hw_changeable = changeable_bits;
430
431         /*
432          * this is very much as follows:
433          * accept the things I cannot change,
434          * change the things I can,
435          * know the difference.
436          */
437
438         /* Conflict. Don't try to both set and reset bits. */
439         if ((v->must_be_1 & (v->must_be_0 | v->try_set_1 | v->try_set_0)) ||
440             (v->must_be_0 & (v->try_set_1 | v->try_set_0)) ||
441             (v->try_set_1 & v->try_set_0)) {
442                 printk("%s: must 0 (0x%x) and must be 1 (0x%x) and try_set_0 (0x%x) and try_set_1 (0x%x) overlap\n",
443                        v->name, v->must_be_0, v->must_be_1, v->try_set_0, v->try_set_1);
444                 err = true;
445         }
446
447         /* coverage */
448         if (((v->must_be_0 | v->must_be_1 | v->try_set_0 | v->try_set_1) & changeable_bits) != changeable_bits) {
449                 printk("%s: Need to cover 0x%x and have 0x%x,0x%x\n",
450                        v->name, changeable_bits, v->must_be_0, v->must_be_1, v->try_set_0, v->try_set_1);
451                 err = true;
452         }
453
454         if ((v->must_be_0 | v->must_be_1 | v->try_set_0 | v->try_set_1 | reserved_0 | reserved_1) != 0xffffffff) {
455                 printk("%s: incomplete coverage: have 0x%x, want 0x%x\n",
456                        v->name, v->must_be_0 | v->must_be_1 | v->try_set_0 | v->try_set_1 |
457                        reserved_0 | reserved_1, 0xffffffff);
458                 err = true;
459         }
460
461         /* Don't try to change bits that can't be changed. */
462         if ((v->must_be_0 & (reserved_0 | changeable_bits)) != v->must_be_0) {
463                 printk("%s: set to 0 (0x%x) can't be done\n", v->name, v->must_be_0);
464                 err = true;
465         }
466
467         if ((v->must_be_1 & (reserved_1 | changeable_bits)) != v->must_be_1) {
468                 printk("%s: set to 1 (0x%x) can't be done\n", v->name, v->must_be_1);
469                 err = true;
470         }
471         // Note we don't REQUIRE that try_set_0 or try_set_0 be possible. We just want to try it.
472
473         // Clear bits in try_set that can't be set.
474         try1 = v->try_set_1 & (reserved_1 | changeable_bits);
475
476         /* If there's been any error at all, spill our guts and return. */
477         if (err) {
478                 printk("%s: vmx_msr_high 0x%x, vmx_msr_low 0x%x, ",
479                            v->name, vmx_msr_high, vmx_msr_low);
480                 printk("must_be_0 0x%x, try_set_0 0x%x,reserved_0 0x%x",
481                            v->must_be_0, v->try_set_0, reserved_0);
482                 printk("must_be_1 0x%x, try_set_1 0x%x,reserved_1 0x%x",
483                            v->must_be_1, v->try_set_1, reserved_1);
484                 printk(" reserved_0 0x%x", reserved_0);
485                 printk(" changeable_bits 0x%x\n", changeable_bits);
486                 return false;
487         }
488
489         *result = v->must_be_1 | try1 | reserved_1;
490
491         printk("%s: check_vmxec_controls succeeds with result 0x%x\n",
492                    v->name, *result);
493         return true;
494 }
495
496 /*
497  * We're trying to make this as readable as possible. Realistically, it will
498  * rarely if ever change, if the past is any guide.
499  */
500 static struct vmxec pbec = {
501         .name = "Pin Based Execution Controls",
502         .msr = MSR_IA32_VMX_PINBASED_CTLS,
503         .truemsr = MSR_IA32_VMX_TRUE_PINBASED_CTLS,
504
505         .must_be_1 = (PIN_BASED_EXT_INTR_MASK |
506                      PIN_BASED_NMI_EXITING |
507                      PIN_BASED_VIRTUAL_NMIS |
508                      PIN_BASED_POSTED_INTR),
509
510         .must_be_0 = (PIN_BASED_VMX_PREEMPTION_TIMER),
511 };
512
513 static struct vmxec cbec = {
514         .name = "CPU Based Execution Controls",
515         .msr = MSR_IA32_VMX_PROCBASED_CTLS,
516         .truemsr = MSR_IA32_VMX_TRUE_PROCBASED_CTLS,
517
518         .must_be_1 = (
519                  CPU_BASED_MWAIT_EXITING |
520                  CPU_BASED_HLT_EXITING |
521                      CPU_BASED_TPR_SHADOW |
522                      CPU_BASED_RDPMC_EXITING |
523                      CPU_BASED_CR8_LOAD_EXITING |
524                      CPU_BASED_CR8_STORE_EXITING |
525                      CPU_BASED_USE_MSR_BITMAPS |
526                      CPU_BASED_USE_IO_BITMAPS |
527                      CPU_BASED_ACTIVATE_SECONDARY_CONTROLS),
528
529         .must_be_0 = (
530                  CPU_BASED_VIRTUAL_INTR_PENDING |
531                      CPU_BASED_INVLPG_EXITING |
532                      CPU_BASED_USE_TSC_OFFSETING |
533                      CPU_BASED_RDTSC_EXITING |
534                      CPU_BASED_CR3_LOAD_EXITING |
535                      CPU_BASED_CR3_STORE_EXITING |
536                      CPU_BASED_MOV_DR_EXITING |
537                      CPU_BASED_VIRTUAL_NMI_PENDING |
538                      CPU_BASED_MONITOR_TRAP |
539                      CPU_BASED_PAUSE_EXITING |
540                      CPU_BASED_UNCOND_IO_EXITING),
541
542         .try_set_0 = (CPU_BASED_MONITOR_EXITING),
543         .policy_changeable = (
544                  CPU_BASED_HLT_EXITING |
545                  CPU_BASED_PAUSE_EXITING |
546                  CPU_BASED_MWAIT_EXITING |
547                  0),
548 };
549
550 static struct vmxec cb2ec = {
551         .name = "CPU Based 2nd Execution Controls",
552         .msr = MSR_IA32_VMX_PROCBASED_CTLS2,
553         .truemsr = MSR_IA32_VMX_PROCBASED_CTLS2,
554
555         .must_be_1 = (SECONDARY_EXEC_ENABLE_EPT |
556                      SECONDARY_EXEC_APIC_REGISTER_VIRT |
557                      SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY |
558                      SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE |
559                      SECONDARY_EXEC_ENABLE_INVPCID |
560                      SECONDARY_EXEC_WBINVD_EXITING),
561
562         .must_be_0 = (
563                      SECONDARY_EXEC_DESCRIPTOR_EXITING |
564                      SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES |
565                      SECONDARY_EXEC_ENABLE_VPID |
566                      SECONDARY_EXEC_UNRESTRICTED_GUEST |
567                      SECONDARY_EXEC_PAUSE_LOOP_EXITING |
568                      SECONDARY_EXEC_RDRAND_EXITING |
569                      SECONDARY_EXEC_ENABLE_VMFUNC |
570                      SECONDARY_EXEC_SHADOW_VMCS |
571                      SECONDARY_EXEC_RDSEED_EXITING |
572                      SECONDARY_EPT_VE |
573                      SECONDARY_ENABLE_XSAV_RESTORE),
574
575         .try_set_1 = SECONDARY_EXEC_RDTSCP,
576
577         .try_set_0 = SECONDARY_EXEC_TSC_SCALING | SECONDARY_EXEC_ENABLE_PML
578
579 };
580
581 static struct vmxec vmentry = {
582         .name = "VMENTRY controls",
583         .msr = MSR_IA32_VMX_ENTRY_CTLS,
584         .truemsr = MSR_IA32_VMX_TRUE_ENTRY_CTLS,
585         /* exact order from vmx.h; only the first two are enabled. */
586
587         .must_be_1 =  (VM_ENTRY_LOAD_DEBUG_CONTROLS | /* can't set to 0 */
588                       VM_ENTRY_LOAD_IA32_EFER |
589                       VM_ENTRY_IA32E_MODE),
590
591         .must_be_0 = (VM_ENTRY_SMM |
592                      VM_ENTRY_DEACT_DUAL_MONITOR |
593                      VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL |
594                      VM_ENTRY_LOAD_IA32_PAT),
595 };
596
597 static struct vmxec vmexit = {
598         .name = "VMEXIT controls",
599         .msr = MSR_IA32_VMX_EXIT_CTLS,
600         .truemsr = MSR_IA32_VMX_TRUE_EXIT_CTLS,
601
602         .must_be_1 = (VM_EXIT_SAVE_DEBUG_CONTROLS |     /* can't set to 0 */
603                                  VM_EXIT_ACK_INTR_ON_EXIT |
604                                  VM_EXIT_SAVE_IA32_EFER |
605                                 VM_EXIT_LOAD_IA32_EFER |
606                                 VM_EXIT_HOST_ADDR_SPACE_SIZE),  /* 64 bit */
607
608         .must_be_0 = (VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL |
609                                  VM_EXIT_SAVE_IA32_PAT |
610                                  VM_EXIT_LOAD_IA32_PAT |
611                                 VM_EXIT_SAVE_VMX_PREEMPTION_TIMER),
612 };
613
614 static void
615 setup_vmcs_config(void *p)
616 {
617         int *ret = p;
618         struct vmcs_config *vmcs_conf = &vmcs_config;
619         uint32_t vmx_msr_high;
620         uint64_t vmx_msr;
621         bool have_true_msrs = false;
622         bool ok;
623
624         *ret = -EIO;
625
626         vmx_msr = read_msr(MSR_IA32_VMX_BASIC);
627         vmx_msr_high = vmx_msr >> 32;
628
629         /*
630          * If bit 55 (VMX_BASIC_HAVE_TRUE_MSRS) is set, then we
631          * can go for the true MSRs.  Else, we ask you to get a better CPU.
632          */
633         if (vmx_msr & VMX_BASIC_TRUE_CTLS) {
634                 have_true_msrs = true;
635                 printd("Running with TRUE MSRs\n");
636         } else {
637                 printk("Running with non-TRUE MSRs, this is old hardware\n");
638         }
639
640         /*
641          * Don't worry that one or more of these might fail and leave
642          * the VMCS in some kind of incomplete state. If one of these
643          * fails, the caller is going to discard the VMCS.
644          * It is written this way to ensure we get results of all tests and avoid
645          * BMAFR behavior.
646          */
647         ok = check_vmxec_controls(&pbec, have_true_msrs,
648                                   &vmcs_conf->pin_based_exec_ctrl);
649         ok = check_vmxec_controls(&cbec, have_true_msrs,
650                                   &vmcs_conf->cpu_based_exec_ctrl) && ok;
651         /* Only check cb2ec if we're still ok, o/w we may GPF */
652         ok = ok && check_vmxec_controls(&cb2ec, have_true_msrs,
653                                         &vmcs_conf->cpu_based_2nd_exec_ctrl);
654         ok = check_vmxec_controls(&vmentry, have_true_msrs,
655                                   &vmcs_conf->vmentry_ctrl) && ok;
656         ok = check_vmxec_controls(&vmexit, have_true_msrs,
657                                   &vmcs_conf->vmexit_ctrl) && ok;
658         if (! ok) {
659                 printk("vmxexec controls is no good.\n");
660                 return;
661         }
662         assert(cpu_has_secondary_exec_ctrls());
663
664         /* IA-32 SDM Vol 3B: VMCS size is never greater than 4kB. */
665         if ((vmx_msr_high & 0x1fff) > PGSIZE) {
666                 printk("vmx_msr_high & 0x1fff) is 0x%x, > PAGE_SIZE 0x%x\n",
667                            vmx_msr_high & 0x1fff, PGSIZE);
668                 return;
669         }
670
671         /* IA-32 SDM Vol 3B: 64-bit CPUs always have VMX_BASIC_MSR[48]==0. */
672         if (vmx_msr & VMX_BASIC_64) {
673                 printk("VMX doesn't support 64 bit width!\n");
674                 return;
675         }
676
677         if (((vmx_msr & VMX_BASIC_MEM_TYPE_MASK) >> VMX_BASIC_MEM_TYPE_SHIFT)
678                 != VMX_BASIC_MEM_TYPE_WB) {
679                 printk("VMX doesn't support WB memory for VMCS accesses!\n");
680                 return;
681         }
682
683         vmcs_conf->size = vmx_msr_high & 0x1fff;
684         vmcs_conf->revision_id = (uint32_t) vmx_msr;
685
686         /* Read in the caps for runtime checks.  This MSR is only available if
687          * secondary controls and ept or vpid is on, which we check earlier */
688         vmx_msr = read_msr(MSR_IA32_VMX_EPT_VPID_CAP);
689         vmx_capability.vpid = high32(vmx_msr);
690         vmx_capability.ept = low32(vmx_msr);
691
692         *ret = 0;
693 }
694
695 static struct vmcs *__vmx_alloc_vmcs(int node)
696 {
697         struct vmcs *vmcs;
698
699         vmcs = kpages_alloc(vmcs_config.size, MEM_WAIT);
700         if (!vmcs)
701                 error(ENOMEM, "__vmx_alloc_vmcs: Could not get %d contig bytes",
702                       vmcs_config.size);
703         memset(vmcs, 0, vmcs_config.size);
704         vmcs->revision_id = vmcs_config.revision_id; /* vmcs revision id */
705         printd("%d: set rev id %d\n", core_id(), vmcs->revision_id);
706         return vmcs;
707 }
708
709 /**
710  * vmx_alloc_vmcs - allocates a VMCS region
711  *
712  * NOTE: Assumes the new region will be used by the current CPU.
713  *
714  * Returns a valid VMCS region.
715  */
716 static struct vmcs *
717 vmx_alloc_vmcs(void)
718 {
719         return __vmx_alloc_vmcs(numa_id());
720 }
721
722 /**
723  * vmx_free_vmcs - frees a VMCS region
724  */
725 static void
726 vmx_free_vmcs(struct vmcs *vmcs)
727 {
728         kpages_free(vmcs, vmcs_config.size);
729 }
730
731 /*
732  * Set up the vmcs's constant host-state fields, i.e., host-state fields that
733  * will not change in the lifetime of the guest.
734  * Note that host-state that does change is set elsewhere. E.g., host-state
735  * that is set differently for each CPU is set in __vmx_setup_pcpu(), not here.
736  */
737 static void vmx_setup_constant_host_state(void)
738 {
739         pseudodesc_t dt;
740
741         vmcs_writel(HOST_CR0, rcr0() & ~X86_CR0_TS);    /* 22.2.3 */
742         vmcs_writel(HOST_CR4, rcr4());  /* 22.2.3, 22.2.5 */
743         vmcs_writel(HOST_CR3, rcr3());  /* 22.2.3 */
744
745         vmcs_write16(HOST_CS_SELECTOR, GD_KT);  /* 22.2.4 */
746         vmcs_write16(HOST_DS_SELECTOR, GD_KD);  /* 22.2.4 */
747         vmcs_write16(HOST_ES_SELECTOR, GD_KD);  /* 22.2.4 */
748         vmcs_write16(HOST_SS_SELECTOR, GD_KD);  /* 22.2.4 */
749         vmcs_write16(HOST_TR_SELECTOR, GD_TSS); /* 22.2.4 */
750
751         native_store_idt(&dt);
752         vmcs_writel(HOST_IDTR_BASE, dt.pd_base);        /* 22.2.4 */
753
754         extern void vmexit_handler(void);
755         vmcs_writel(HOST_RIP, (unsigned long)vmexit_handler);
756
757         vmcs_write32(HOST_IA32_SYSENTER_CS, read_msr(MSR_IA32_SYSENTER_CS));
758         vmcs_writel(HOST_IA32_SYSENTER_EIP, read_msr(MSR_IA32_SYSENTER_EIP));
759
760         vmcs_write32(HOST_IA32_EFER, read_msr(MSR_EFER));
761
762         if (vmcs_config.vmexit_ctrl & VM_EXIT_LOAD_IA32_PAT)
763                 vmcs_write64(HOST_IA32_PAT, read_msr(MSR_IA32_CR_PAT));
764
765         vmcs_write16(HOST_FS_SELECTOR, 0);      /* 22.2.4 */
766         vmcs_write16(HOST_GS_SELECTOR, 0);      /* 22.2.4 */
767         vmcs_write(HOST_FS_BASE, 0);
768 }
769
770 /* Set up the per-core VMCS fields.  This is the host state that varies from
771  * core to core, which the hardware will switch for us on VM enters/exits. */
772 static void __vmx_setup_pcpu(struct guest_pcore *gpc)
773 {
774         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
775         struct vmx_vmm *vmx = &gpc->proc->vmm.vmx;
776
777         vmcs_write(HOST_TR_BASE, (uintptr_t)pcpui->tss);
778         vmcs_writel(HOST_GDTR_BASE, (uintptr_t)pcpui->gdt);
779         vmcs_write(HOST_GS_BASE, (uintptr_t)pcpui);
780         /* TODO: we might need to also set HOST_IA32_PERF_GLOBAL_CTRL.  Need to
781          * think about how perf will work with VMs */
782         /* Userspace can request changes to the ctls.  They take effect when we
783          * reload the GPC, which occurs after a transition from userspace to VM. */
784         vmcs_write(PIN_BASED_VM_EXEC_CONTROL, vmx->pin_exec_ctls);
785         vmcs_write(CPU_BASED_VM_EXEC_CONTROL, vmx->cpu_exec_ctls);
786         vmcs_write(SECONDARY_VM_EXEC_CONTROL, vmx->cpu2_exec_ctls);
787 }
788
789 uint64_t
790 construct_eptp(physaddr_t root_hpa)
791 {
792         uint64_t eptp;
793
794         /* set WB memory and 4 levels of walk.  we checked these in ept_init */
795         eptp = VMX_EPT_MEM_TYPE_WB | (VMX_EPT_GAW_4_LVL << VMX_EPT_GAW_EPTP_SHIFT);
796         if (cpu_has_vmx_ept_ad_bits())
797                 eptp |= VMX_EPT_AD_ENABLE_BIT;
798         eptp |= (root_hpa & PAGE_MASK);
799
800         return eptp;
801 }
802
803 /* Helper: some fields of the VMCS need a physical page address, e.g. the VAPIC
804  * page.  We have the user address.  This converts the user to phys addr and
805  * sets that up in the VMCS.  Throws on error. */
806 static void vmcs_set_pgaddr(struct proc *p, void *u_addr,
807                             unsigned long field, char *what)
808 {
809         uintptr_t kva;
810         physaddr_t paddr;
811
812         /* Enforce page alignment */
813         kva = uva2kva(p, ROUNDDOWN(u_addr, PGSIZE), PGSIZE, PROT_WRITE);
814         if (!kva)
815                 error(EINVAL, "Unmapped pgaddr %p for VMCS page %s", u_addr, what);
816
817         paddr = PADDR(kva);
818         /* TODO: need to pin the page.  A munmap would actually be okay
819          * (though probably we should kill the process), but we need to
820          * keep the page from being reused.  A refcnt would do the trick,
821          * which we decref when we destroy the guest core/vcpu. Note that
822          * this is an assert, not an error, because it represents an error
823          * in the kernel itself. */
824         assert(!PGOFF(paddr));
825         vmcs_writel(field, paddr);
826         /* Pages are inserted twice.  Once, with the full paddr.  The next field is
827          * the upper 32 bits of the paddr. */
828         vmcs_writel(field + 1, paddr >> 32);
829 }
830
831 /**
832  * vmx_setup_initial_guest_state - configures the initial state of guest
833  * registers and the VMCS.  Throws on error.
834  */
835 static void vmx_setup_initial_guest_state(struct proc *p,
836                                           struct vmm_gpcore_init *gpci)
837 {
838         unsigned long cr4 = X86_CR4_PAE | X86_CR4_VMXE | X86_CR4_OSXMMEXCPT |
839                 X86_CR4_PGE | X86_CR4_OSFXSR;
840         uint32_t protected_mode = X86_CR0_PG | X86_CR0_PE;
841
842         /*
843          * Allow guest to use xsave and read/write fs/gs base.
844          * We require these features to be present on the cpu.
845          */
846         assert(cpu_has_feat(CPU_FEAT_X86_XSAVE));
847         assert(cpu_has_feat(CPU_FEAT_X86_FSGSBASE));
848         cr4 |= X86_CR4_RDWRGSFS;
849         cr4 |= X86_CR4_OSXSAVE;
850         /* configure control and data registers */
851         vmcs_writel(GUEST_CR0, protected_mode | X86_CR0_WP |
852                                 X86_CR0_MP | X86_CR0_ET | X86_CR0_NE);
853         vmcs_writel(CR0_READ_SHADOW, protected_mode | X86_CR0_WP |
854                                 X86_CR0_MP | X86_CR0_ET | X86_CR0_NE);
855         vmcs_writel(GUEST_CR3, rcr3());
856         vmcs_writel(GUEST_CR4, cr4);
857         /* The only bits that matter in this shadow are those that are
858          * set in CR4_GUEST_HOST_MASK.  TODO: do we need to separate
859          * the setting of this value from that of
860          * CR4_GUEST_HOST_MASK? */
861         vmcs_writel(CR4_READ_SHADOW, 0);
862         vmcs_writel(GUEST_IA32_EFER, EFER_LME | EFER_LMA |
863                                 EFER_SCE | EFER_NX /*| EFER_FFXSR */ );
864         vmcs_writel(GUEST_GDTR_BASE, 0);
865         vmcs_writel(GUEST_GDTR_LIMIT, 0);
866         vmcs_writel(GUEST_IDTR_BASE, 0);
867         vmcs_writel(GUEST_IDTR_LIMIT, 0);
868         vmcs_writel(GUEST_RIP, 0xdeadbeef);
869         vmcs_writel(GUEST_RSP, 0xdeadbeef);
870         vmcs_writel(GUEST_RFLAGS, FL_RSVD_1);
871         vmcs_writel(GUEST_DR7, 0);
872
873         /* guest segment bases */
874         vmcs_writel(GUEST_CS_BASE, 0);
875         vmcs_writel(GUEST_DS_BASE, 0);
876         vmcs_writel(GUEST_ES_BASE, 0);
877         enforce_user_canon(&gpci->fsbase);
878         vmcs_writel(GUEST_FS_BASE, gpci->fsbase);
879         enforce_user_canon(&gpci->gsbase);
880         vmcs_writel(GUEST_GS_BASE, gpci->gsbase);
881         vmcs_writel(GUEST_SS_BASE, 0);
882
883         /* guest segment access rights */
884         vmcs_writel(GUEST_CS_AR_BYTES, 0xA09B);
885         vmcs_writel(GUEST_DS_AR_BYTES, 0xA093);
886         vmcs_writel(GUEST_ES_AR_BYTES, 0xA093);
887         vmcs_writel(GUEST_FS_AR_BYTES, 0xA093);
888         vmcs_writel(GUEST_GS_AR_BYTES, 0xA093);
889         vmcs_writel(GUEST_SS_AR_BYTES, 0xA093);
890
891         /* guest segment limits */
892         vmcs_write32(GUEST_CS_LIMIT, 0xFFFFFFFF);
893         vmcs_write32(GUEST_DS_LIMIT, 0xFFFFFFFF);
894         vmcs_write32(GUEST_ES_LIMIT, 0xFFFFFFFF);
895         vmcs_write32(GUEST_FS_LIMIT, 0xFFFFFFFF);
896         vmcs_write32(GUEST_GS_LIMIT, 0xFFFFFFFF);
897         vmcs_write32(GUEST_SS_LIMIT, 0xFFFFFFFF);
898
899         /* configure segment selectors */
900         vmcs_write16(GUEST_CS_SELECTOR, 0);
901         vmcs_write16(GUEST_DS_SELECTOR, 0);
902         vmcs_write16(GUEST_ES_SELECTOR, 0);
903         vmcs_write16(GUEST_FS_SELECTOR, 0);
904         vmcs_write16(GUEST_GS_SELECTOR, 0);
905         vmcs_write16(GUEST_SS_SELECTOR, 0);
906         vmcs_write16(GUEST_TR_SELECTOR, 0);
907
908         /* guest LDTR */
909         vmcs_write16(GUEST_LDTR_SELECTOR, 0);
910         vmcs_writel(GUEST_LDTR_AR_BYTES, 0x0082);
911         vmcs_writel(GUEST_LDTR_BASE, 0);
912         vmcs_writel(GUEST_LDTR_LIMIT, 0);
913
914         /* guest TSS */
915         vmcs_writel(GUEST_TR_BASE, 0);
916         vmcs_writel(GUEST_TR_AR_BYTES, 0x0080 | AR_TYPE_BUSY_64_TSS);
917         vmcs_writel(GUEST_TR_LIMIT, 0xff);
918
919         /* initialize sysenter */
920         vmcs_write32(GUEST_SYSENTER_CS, 0);
921         vmcs_writel(GUEST_SYSENTER_ESP, 0);
922         vmcs_writel(GUEST_SYSENTER_EIP, 0);
923
924         /* other random initialization */
925         vmcs_write32(GUEST_ACTIVITY_STATE, GUEST_ACTIVITY_ACTIVE);
926         vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, 0);
927         vmcs_write32(GUEST_PENDING_DBG_EXCEPTIONS, 0);
928         vmcs_write64(GUEST_IA32_DEBUGCTL, 0);
929         vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0);      /* 22.2.1 */
930
931         /* Initialize posted interrupt notification vector */
932         vmcs_write16(POSTED_NOTIFICATION_VEC, I_POKE_GUEST);
933
934         /* Clear the EOI exit bitmap */
935         vmcs_writel(EOI_EXIT_BITMAP0, 0);
936         vmcs_writel(EOI_EXIT_BITMAP0_HIGH, 0);
937         vmcs_writel(EOI_EXIT_BITMAP1, 0);
938         vmcs_writel(EOI_EXIT_BITMAP1_HIGH, 0);
939         vmcs_writel(EOI_EXIT_BITMAP2, 0);
940         vmcs_writel(EOI_EXIT_BITMAP2_HIGH, 0);
941         vmcs_writel(EOI_EXIT_BITMAP3, 0);
942         vmcs_writel(EOI_EXIT_BITMAP3_HIGH, 0);
943
944         /* Initialize parts based on the users info. */
945         vmcs_set_pgaddr(p, gpci->posted_irq_desc, POSTED_INTR_DESC_ADDR,
946                         "posted_irq_desc");
947         vmcs_set_pgaddr(p, gpci->vapic_addr, VIRTUAL_APIC_PAGE_ADDR,
948                         "vapic_addr");
949         vmcs_set_pgaddr(p, gpci->apic_addr, APIC_ACCESS_ADDR, "apic_addr");
950 }
951
952 static void __vmx_disable_intercept_for_msr(unsigned long *msr_bitmap,
953                                             uint32_t msr) {
954         int f = sizeof(unsigned long);
955         /*
956          * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals
957          * have the write-low and read-high bitmap offsets the wrong way round.
958          * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff.
959          */
960         if (msr <= 0x1fff) {
961                 __clear_bit(msr, msr_bitmap + 0x000 / f);       /* read-low */
962                 __clear_bit(msr, msr_bitmap + 0x800 / f);       /* write-low */
963         } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) {
964                 msr &= 0x1fff;
965                 __clear_bit(msr, msr_bitmap + 0x400 / f);       /* read-high */
966                 __clear_bit(msr, msr_bitmap + 0xc00 / f);       /* write-high */
967         }
968 }
969
970 /* note the io_bitmap is big enough for the 64K port space. */
971 static void __vmx_disable_intercept_for_io(unsigned long *io_bitmap,
972                                            uint16_t port) {
973         __clear_bit(port, io_bitmap);
974 }
975
976 static void dumpmsrs(void) {
977         int i;
978         int set[] = {
979                 MSR_LSTAR,
980                 MSR_FS_BASE,
981                 MSR_GS_BASE,
982                 MSR_KERNEL_GS_BASE,
983                 MSR_SFMASK,
984                 MSR_IA32_PEBS_ENABLE
985         };
986         for (i = 0; i < ARRAY_SIZE(set); i++) {
987                 printk("%p: %p\n", set[i], read_msr(set[i]));
988         }
989         printk("core id %d\n", core_id());
990 }
991
992 /* Notes on autoloading.  We can't autoload FS_BASE or GS_BASE, according to the
993  * manual, but that's because they are automatically saved and restored when all
994  * of the other architectural registers are saved and restored, such as cs, ds,
995  * es, and other fun things. (See 24.4.1).  We need to make sure we don't
996  * accidentally intercept them too, since they are magically autoloaded.
997  *
998  * We'll need to be careful of any MSR we neither autoload nor intercept
999  * whenever we vmenter/vmexit, and we intercept by default.
1000  *
1001  * Other MSRs, such as MSR_IA32_PEBS_ENABLE only work on certain architectures
1002  * only work on certain architectures. */
1003 static void setup_msr(struct guest_pcore *gpc)
1004 {
1005         /* Since PADDR(msr_bitmap) is non-zero, and the bitmap is all 0xff, we now
1006          * intercept all MSRs */
1007         vmcs_write64(MSR_BITMAP, PADDR(msr_bitmap));
1008
1009         vmcs_write64(IO_BITMAP_A, PADDR(io_bitmap));
1010         vmcs_write64(IO_BITMAP_B, PADDR((uintptr_t)io_bitmap +
1011                                         (VMX_IO_BITMAP_SZ / 2)));
1012
1013         vmcs_write32(VM_EXIT_MSR_STORE_COUNT, 0);
1014         vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, 0);
1015         vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, 0);
1016 }
1017
1018 void vmx_setup_vmx_vmm(struct vmx_vmm *vmx)
1019 {
1020         vmx->pin_exec_ctls = vmcs_config.pin_based_exec_ctrl;
1021         vmx->cpu_exec_ctls = vmcs_config.cpu_based_exec_ctrl;
1022         vmx->cpu2_exec_ctls = vmcs_config.cpu_based_2nd_exec_ctrl;
1023 }
1024
1025 /**
1026  *  vmx_setup_vmcs - configures the vmcs with starting parameters
1027  */
1028 static void vmx_setup_vmcs(struct guest_pcore *gpc)
1029 {
1030         vmcs_write16(VIRTUAL_PROCESSOR_ID, 0);
1031         vmcs_write64(VMCS_LINK_POINTER, -1ull); /* 22.3.1.5 */
1032
1033         vmcs_write64(EPT_POINTER, gpc_get_eptp(gpc));
1034
1035         vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, 0);
1036         vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, 0);
1037         vmcs_write32(CR3_TARGET_COUNT, 0);      /* 22.2.1 */
1038
1039         setup_msr(gpc);
1040
1041         vmcs_config.vmentry_ctrl |= VM_ENTRY_IA32E_MODE;
1042
1043         vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl);
1044         vmcs_write32(VM_ENTRY_CONTROLS, vmcs_config.vmentry_ctrl);
1045
1046         vmcs_writel(CR0_GUEST_HOST_MASK, 0);    // ~0ul);
1047
1048         /* Mask some bits in CR4 as host-owned by setting them in this
1049          * VMCS entry.  For example, for now, we mark the CR4_VMXE bit
1050          * as host owned.  Right now, when Linux boots, it wants to
1051          * set CR4_VMXE to 0 at first, which is fine -- we do not want
1052          * to think about nested virtualization yet. But if we don't
1053          * mark this bit as host owned we get a VMEXIT. Marking
1054          * CR4_VMXE as host owned means that the writes will succeed
1055          * with no vmexit if the value written matches the
1056          * corresponding bit in the shadow register. */
1057         vmcs_writel(CR4_GUEST_HOST_MASK, CR4_VMXE);
1058
1059         //kvm_write_tsc(&vmx->gpc, 0);
1060         vmcs_writel(TSC_OFFSET, 0);
1061
1062         vmx_setup_constant_host_state();
1063 }
1064
1065 /**
1066  * create_guest_pcore - allocates and initializes a guest physical core
1067  *
1068  * Returns: A new VCPU structure
1069  */
1070 struct guest_pcore *create_guest_pcore(struct proc *p,
1071                                        struct vmm_gpcore_init *gpci)
1072 {
1073         ERRSTACK(2);
1074         int8_t state = 0;
1075         struct guest_pcore *gpc = kmalloc(sizeof(struct guest_pcore), MEM_WAIT);
1076
1077         if (!gpc)
1078                 error(ENOMEM, "create_guest_pcore could not allocate gpc");
1079
1080         if (waserror()) {
1081                 kfree(gpc);
1082                 nexterror();
1083         }
1084
1085         memset(gpc, 0, sizeof(*gpc));
1086
1087         /* Warning: p here is uncounted (weak) reference */
1088         gpc->proc = p;
1089         gpc->vmcs = vmx_alloc_vmcs();
1090         if (waserror()) {
1091                 vmx_free_vmcs(gpc->vmcs);
1092                 nexterror();
1093         }
1094         printd("%d: gpc->vmcs is %p\n", core_id(), gpc->vmcs);
1095         gpc->cpu = -1;
1096         gpc->vmcs_core_id = -1;
1097         gpc->should_vmresume = FALSE;
1098
1099         disable_irqsave(&state);
1100         vmx_load_guest_pcore(gpc);
1101         vmx_setup_vmcs(gpc);
1102         vmx_setup_initial_guest_state(p, gpci);
1103         vmx_unload_guest_pcore(gpc);
1104         enable_irqsave(&state);
1105
1106         gpc->xcr0 = __proc_global_info.x86_default_xcr0;
1107
1108         gpc->posted_irq_desc = gpci->posted_irq_desc;
1109         poperror();
1110         poperror();
1111         return gpc;
1112 }
1113
1114 /**
1115  * destroy_guest_pcore - destroys and frees an existing guest physical core
1116  * @gpc: the GPC to destroy
1117  */
1118 void destroy_guest_pcore(struct guest_pcore *gpc)
1119 {
1120         vmx_free_vmcs(gpc->vmcs);
1121         kfree(gpc);
1122 }
1123
1124 static void vmx_step_instruction(void) {
1125         vmcs_writel(GUEST_RIP, vmcs_readl(GUEST_RIP) +
1126                     vmcs_read32(VM_EXIT_INSTRUCTION_LEN));
1127 }
1128
1129 /**
1130  * __vmx_enable - low-level enable of VMX mode on the current CPU
1131  * @vmxon_buf: an opaque buffer for use as the VMXON region
1132  */
1133 static int __vmx_enable(struct vmcs *vmxon_buf) {
1134         uint64_t phys_addr = PADDR(vmxon_buf);
1135         uint64_t old, test_bits;
1136
1137         if (rcr4() & X86_CR4_VMXE) {
1138                 panic("Should never have this happen");
1139                 return -EBUSY;
1140         }
1141
1142         old = read_msr(MSR_IA32_FEATURE_CONTROL);
1143
1144         test_bits = FEATURE_CONTROL_LOCKED;
1145         test_bits |= FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX;
1146
1147         if (0)  // tboot_enabled())
1148                 test_bits |= FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX;
1149
1150         if ((old & test_bits) != test_bits) {
1151                 /* If it's locked, then trying to set it will cause a GPF.
1152                  * No Dune for you!
1153                  */
1154                 if (old & FEATURE_CONTROL_LOCKED) {
1155                         printk("Dune: MSR_IA32_FEATURE_CONTROL is locked!\n");
1156                         return -1;
1157                 }
1158
1159                 /* enable and lock */
1160                 write_msr(MSR_IA32_FEATURE_CONTROL, old | test_bits);
1161         }
1162         lcr4(rcr4() | X86_CR4_VMXE);
1163
1164         __vmxon(phys_addr);
1165         vpid_sync_gpc_global(); /* good idea, even if we aren't using vpids */
1166         ept_sync_global();
1167
1168         return 0;
1169 }
1170
1171 /**
1172  * vmx_disable - disables VMX mode on the current CPU
1173  */
1174 static void vmx_disable(void *unused) {
1175         if (currentcpu->vmx_enabled) {
1176                 __vmxoff();
1177                 lcr4(rcr4() & ~X86_CR4_VMXE);
1178                 currentcpu->vmx_enabled = 0;
1179         }
1180 }
1181
1182 /* Probe the cpus to see which ones can do vmx.
1183  * Return -errno if it fails, and 1 if it succeeds.
1184  */
1185 static bool probe_cpu_vmx(void) {
1186         /* The best way to test this code is:
1187          * wrmsr -p <cpu> 0x3a 1
1188          * This will lock vmx off; then modprobe dune.
1189          * Frequently, however, systems have all 0x3a registers set to 5,
1190          * meaning testing is impossible, as vmx can not be disabled.
1191          * We have to simulate it being unavailable in most cases.
1192          * The 'test' variable provides an easy way to simulate
1193          * unavailability of vmx on some, none, or all cpus.
1194          */
1195         if (!cpu_has_vmx()) {
1196                 printk("Machine does not support VT-x\n");
1197                 return FALSE;
1198         } else {
1199                 printk("Machine supports VT-x\n");
1200                 return TRUE;
1201         }
1202 }
1203
1204 static int ept_init(void) {
1205         if (!cpu_has_vmx_ept()) {
1206                 printk("VMX doesn't support EPT!\n");
1207                 return -1;
1208         }
1209         if (!cpu_has_vmx_eptp_writeback()) {
1210                 printk("VMX EPT doesn't support WB memory!\n");
1211                 return -1;
1212         }
1213         if (!cpu_has_vmx_ept_4levels()) {
1214                 printk("VMX EPT doesn't support 4 level walks!\n");
1215                 return -1;
1216         }
1217         switch (arch_max_jumbo_page_shift()) {
1218         case PML3_SHIFT:
1219                 if (!cpu_has_vmx_ept_1g_page()) {
1220                         printk("VMX EPT doesn't support 1 GB pages!\n");
1221                         return -1;
1222                 }
1223                 break;
1224         case PML2_SHIFT:
1225                 if (!cpu_has_vmx_ept_2m_page()) {
1226                         printk("VMX EPT doesn't support 2 MB pages!\n");
1227                         return -1;
1228                 }
1229                 break;
1230         default:
1231                 printk("Unexpected jumbo page size %d\n",
1232                        arch_max_jumbo_page_shift());
1233                 return -1;
1234         }
1235         if (!cpu_has_vmx_ept_ad_bits()) {
1236                 printk("VMX EPT doesn't support accessed/dirty!\n");
1237                 x86_ept_pte_fix_ups |= EPTE_A | EPTE_D;
1238         }
1239         if (!cpu_has_vmx_invept() || !cpu_has_vmx_invept_global()) {
1240                 printk("VMX EPT can't invalidate PTEs/TLBs!\n");
1241                 return -1;
1242         }
1243
1244         return 0;
1245 }
1246
1247 /**
1248  * vmx_init sets up physical core data areas that are required to run a vm at all.
1249  * These data areas are not connected to a specific user process in any way. Instead,
1250  * they are in some sense externalizing what would other wise be a very large ball of
1251  * state that would be inside the CPU.
1252  */
1253 int intel_vmm_init(void) {
1254         int r, cpu, ret;
1255
1256         if (!probe_cpu_vmx()) {
1257                 return -EOPNOTSUPP;
1258         }
1259
1260         setup_vmcs_config(&ret);
1261
1262         if (ret) {
1263                 printk("setup_vmcs_config failed: %d\n", ret);
1264                 return ret;
1265         }
1266
1267         msr_bitmap = (unsigned long *)kpage_zalloc_addr();
1268         if (!msr_bitmap) {
1269                 printk("Could not allocate msr_bitmap\n");
1270                 return -ENOMEM;
1271         }
1272         io_bitmap = (unsigned long *)kpages_alloc(VMX_IO_BITMAP_SZ, MEM_WAIT);
1273         if (!io_bitmap) {
1274                 printk("Could not allocate msr_bitmap\n");
1275                 kfree(msr_bitmap);
1276                 return -ENOMEM;
1277         }
1278         /* FIXME: do we need APIC virtualization (flexpriority?) */
1279
1280         memset(msr_bitmap, 0xff, PAGE_SIZE);
1281
1282         /* The following MSRs are virtualized to the vapic page so there is no
1283          * write or read from the actual MSR. */
1284         memset((void *)msr_bitmap + INTEL_X2APIC_MSR_START, 0,
1285                INTEL_X2APIC_MSR_LENGTH);
1286         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_LAPIC_EOI);
1287         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_LAPIC_TPR);
1288         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_LAPIC_SELF_IPI);
1289
1290         memset(io_bitmap, 0xff, VMX_IO_BITMAP_SZ);
1291
1292         /* These are the only MSRs that are not intercepted.  The hardware takes
1293          * care of FS_BASE, GS_BASE, and EFER.  We do the rest manually when loading
1294          * and unloading guest pcores. */
1295         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_FS_BASE);
1296         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_GS_BASE);
1297         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_EFER);
1298         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_KERNEL_GS_BASE);
1299         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_LSTAR);
1300         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_STAR);
1301         __vmx_disable_intercept_for_msr(msr_bitmap, MSR_SFMASK);
1302
1303         /* TODO: this might be dangerous, since they can do more than just read the
1304          * CMOS */
1305         __vmx_disable_intercept_for_io(io_bitmap, CMOS_RAM_IDX);
1306         __vmx_disable_intercept_for_io(io_bitmap, CMOS_RAM_DATA);
1307
1308         if ((ret = ept_init())) {
1309                 printk("EPT init failed, %d\n", ret);
1310                 return ret;
1311         }
1312         printk("VMX setup succeeded\n");
1313         /* If this isn't true (we have VMX but not mwait), then we'll have to look
1314          * closely at CPU_BASED_MWAIT_EXITING. */
1315         assert(cpu_has_feat(CPU_FEAT_X86_MWAIT));
1316         return 0;
1317 }
1318
1319 int intel_vmm_pcpu_init(void)
1320 {
1321         struct vmcs *vmxon_buf;
1322         int ret;
1323
1324         vmxon_buf = __vmx_alloc_vmcs(core_id());
1325         if (!vmxon_buf) {
1326                 printk("setup_vmxarea failed on node %d\n", core_id());
1327                 return -1;
1328         }
1329
1330         ret = __vmx_enable(vmxon_buf);
1331         if (ret)
1332                 goto failed;
1333         currentcpu->vmx_enabled = 1;
1334         return 0;
1335 failed:
1336         printk("Failed to enable VMX on core %d, err = %d\n", core_id(), ret);
1337         return ret;
1338 }
1339
1340
1341 void vapic_status_dump_kernel(void *vapic)
1342 {
1343         uint32_t *p = (uint32_t *)vapic;
1344         int i;
1345         printk("-- BEGIN KERNEL APIC STATUS DUMP --\n");
1346         for (i = 0x100/sizeof(*p); i < 0x180/sizeof(*p); i+=4) {
1347                 printk("VISR : 0x%x: 0x%08x\n", i, p[i]);
1348         }
1349         for (i = 0x200/sizeof(*p); i < 0x280/sizeof(*p); i+=4) {
1350                 printk("VIRR : 0x%x: 0x%08x\n", i, p[i]);
1351         }
1352         i = 0x0B0/sizeof(*p);
1353         printk("EOI FIELD : 0x%x, 0x%08x\n", i, p[i]);
1354
1355         printk("-- END KERNEL APIC STATUS DUMP --\n");
1356 }
1357
1358 static DEFINE_PERCPU(struct guest_pcore *, gpc_to_clear_to);
1359
1360 /* Note this is set up to allow spurious pokes.  Someone could arbitrarily send
1361  * us this KMSG at any time.  We only actually clear when we've previously
1362  * unloaded the GPC.  gpc_to_clear_to is only set once we're just 'caching' it.
1363  * */
1364 void vmx_clear_vmcs(void)
1365 {
1366         struct guest_pcore *gpc;
1367         int8_t irq_state = 0;
1368
1369         disable_irqsave(&irq_state);
1370         gpc = PERCPU_VAR(gpc_to_clear_to);
1371         if (gpc) {
1372                 vmcs_clear(gpc->vmcs);
1373                 ept_sync_context(gpc_get_eptp(gpc));
1374                 gpc->should_vmresume = FALSE;
1375                 wmb(); /* write -1 after clearing */
1376                 gpc->vmcs_core_id = -1;
1377                 PERCPU_VAR(gpc_to_clear_to) = NULL;
1378         }
1379         enable_irqsave(&irq_state);
1380 }
1381
1382 static void __clear_vmcs(uint32_t srcid, long a0, long a1, long a2)
1383 {
1384         vmx_clear_vmcs();
1385 }
1386
1387 /* We are safe from races on GPC, other than vmcs and vmcs_core_id.  For
1388  * instance, only one core can be loading or unloading a particular GPC at a
1389  * time.  Other cores write to our GPC's vmcs_core_id and vmcs (doing a
1390  * vmcs_clear).  Once they write vmcs_core_id != -1, it's ours. */
1391 void vmx_load_guest_pcore(struct guest_pcore *gpc)
1392 {
1393         int remote_core;
1394
1395         assert(!irq_is_enabled());
1396         if (gpc->vmcs_core_id == core_id()) {
1397                 PERCPU_VAR(gpc_to_clear_to) = NULL;
1398                 return;
1399         }
1400         /* Clear ours *before* waiting on someone else; avoids deadlock (circular
1401          * wait). */
1402         __clear_vmcs(0, 0, 0, 0);
1403         remote_core = ACCESS_ONCE(gpc->vmcs_core_id);
1404         if (remote_core != -1) {
1405                 /* This is a bit nasty.  It requires the remote core to receive
1406                  * interrupts, which means we're now waiting indefinitely for them to
1407                  * enable IRQs.  They can wait on another core, and so on.  We cleared
1408                  * our vmcs first, so that we won't deadlock on *this*.
1409                  *
1410                  * However, this means we can't wait on another core with IRQs disabled
1411                  * for any *other* reason.  For instance, if some other subsystem
1412                  * decides to have one core wait with IRQs disabled on another, the core
1413                  * that has our VMCS could be waiting on us to do something that we'll
1414                  * never do. */
1415                 send_kernel_message(remote_core, __clear_vmcs, 0, 0, 0, KMSG_IMMEDIATE);
1416                 while (gpc->vmcs_core_id != -1)
1417                         cpu_relax();
1418         }
1419         vmcs_load(gpc->vmcs);
1420         __vmx_setup_pcpu(gpc);
1421         gpc->vmcs_core_id = core_id();
1422 }
1423
1424 void vmx_unload_guest_pcore(struct guest_pcore *gpc)
1425 {
1426         /* We don't have to worry about races yet.  No one will try to load gpc
1427          * until we've returned and unlocked, and no one will clear an old VMCS to
1428          * this GPC, since it was cleared before we finished loading (above). */
1429         assert(!irq_is_enabled());
1430         gpc->vmcs_core_id = core_id();
1431         PERCPU_VAR(gpc_to_clear_to) = gpc;
1432 }
1433
1434 uint64_t gpc_get_eptp(struct guest_pcore *gpc)
1435 {
1436         return gpc->proc->env_pgdir.eptp;
1437 }
1438
1439 int vmx_ctl_get_exits(struct vmx_vmm *vmx)
1440 {
1441         int ret = 0;
1442
1443         if (vmx->cpu_exec_ctls & CPU_BASED_HLT_EXITING)
1444                 ret |= VMM_CTL_EXIT_HALT;
1445         if (vmx->cpu_exec_ctls & CPU_BASED_PAUSE_EXITING)
1446                 ret |= VMM_CTL_EXIT_PAUSE;
1447         if (vmx->cpu_exec_ctls & CPU_BASED_MWAIT_EXITING)
1448                 ret |= VMM_CTL_EXIT_MWAIT;
1449         return ret;
1450 }
1451
1452 int vmx_ctl_set_exits(struct vmx_vmm *vmx, int vmm_exits)
1453 {
1454         int toggle_want;
1455         int vmx_toggle_do = 0;
1456
1457         toggle_want = (vmx_ctl_get_exits(vmx) ^ vmm_exits) & VMM_CTL_ALL_EXITS;
1458         if (toggle_want & VMM_CTL_EXIT_HALT) {
1459             if (!vmx_control_can_be_changed(&cbec, CPU_BASED_HLT_EXITING))
1460                         error(ENOSYS, "VMX can't toggle EXIT_HALT");
1461                 vmx_toggle_do |= CPU_BASED_HLT_EXITING;
1462         }
1463         if (toggle_want & VMM_CTL_EXIT_PAUSE) {
1464             if (!vmx_control_can_be_changed(&cbec, CPU_BASED_PAUSE_EXITING))
1465                         error(ENOSYS, "VMX can't toggle EXIT_PAUSE");
1466                 vmx_toggle_do |= CPU_BASED_PAUSE_EXITING;
1467         }
1468         if (toggle_want & VMM_CTL_EXIT_MWAIT) {
1469             if (!vmx_control_can_be_changed(&cbec, CPU_BASED_MWAIT_EXITING))
1470                         error(ENOSYS, "VMX can't toggle EXIT_MWAIT");
1471                 vmx_toggle_do |= CPU_BASED_MWAIT_EXITING;
1472         }
1473         /* This is being read concurrently by load_guest_pcore. */
1474         WRITE_ONCE(vmx->cpu_exec_ctls, vmx->cpu_exec_ctls ^ vmx_toggle_do);
1475         return 0;
1476 }