x86: Handle buggy user_contexts (XCC)
[akaros.git] / kern / arch / x86 / process64.c
1 #include <arch/arch.h>
2 #include <trap.h>
3 #include <process.h>
4 #include <pmap.h>
5 #include <smp.h>
6 #include <arch/fsgsbase.h>
7
8 #include <string.h>
9 #include <assert.h>
10 #include <stdio.h>
11
12 static void __attribute__((noreturn)) proc_pop_hwtf(struct hw_trapframe *tf)
13 {
14         /* for both HW and SW, note we pass an offset into the TF, beyond the fs and
15          * gs bases */
16         if (x86_hwtf_is_partial(tf)) {
17                 swap_gs();
18         } else {
19                 write_gsbase(tf->tf_gsbase);
20                 write_fsbase(tf->tf_fsbase);
21         }
22         asm volatile (".globl __asm_pop_hwtf_start;"
23                       "__asm_pop_hwtf_start:    "
24                       "movq %0, %%rsp;          "
25                       "popq %%rax;              "
26                       "popq %%rbx;              "
27                       "popq %%rcx;              "
28                       "popq %%rdx;              "
29                       "popq %%rbp;              "
30                       "popq %%rsi;              "
31                       "popq %%rdi;              "
32                       "popq %%r8;               "
33                       "popq %%r9;               "
34                       "popq %%r10;              "
35                       "popq %%r11;              "
36                       "popq %%r12;              "
37                       "popq %%r13;              "
38                       "popq %%r14;              "
39                       "popq %%r15;              "
40                       "addq $0x10, %%rsp;       "
41                       "iretq;                   "
42                       ".globl __asm_pop_hwtf_end;"
43                       "__asm_pop_hwtf_end:      "
44                       : : "g" (&tf->tf_rax) : "memory");
45         panic("iretq failed");
46 }
47
48 static void __attribute__((noreturn)) proc_pop_swtf(struct sw_trapframe *tf)
49 {
50         if (x86_swtf_is_partial(tf)) {
51                 swap_gs();
52         } else {
53                 write_gsbase(tf->tf_gsbase);
54                 write_fsbase(tf->tf_fsbase);
55         }
56         /* We need to 0 out any registers that aren't part of the sw_tf and that we
57          * won't use/clobber on the out-path.  While these aren't part of the sw_tf,
58          * we also don't want to leak any kernel register content. */
59         asm volatile (".globl __asm_pop_swtf_start;"
60                       "__asm_pop_swtf_start:    "
61                       "movq %0, %%rsp;          "
62                       "movq $0, %%rax;          "
63                       "movq $0, %%rdx;          "
64                       "movq $0, %%rsi;          "
65                       "movq $0, %%rdi;          "
66                       "movq $0, %%r8;           "
67                       "movq $0, %%r9;           "
68                       "movq $0, %%r10;          "
69                       "popq %%rbx;              "
70                       "popq %%rbp;              "
71                       "popq %%r12;              "
72                       "popq %%r13;              "
73                       "popq %%r14;              "
74                       "popq %%r15;              "
75                       "movq %1, %%r11;          "
76                       "popq %%rcx;              "
77                       "popq %%rsp;              "
78                       "rex.w sysret;            "
79                       ".globl __asm_pop_swtf_end;"
80                       "__asm_pop_swtf_end:      "
81                       : : "g"(&tf->tf_rbx), "i"(FL_IF) : "memory");
82         panic("sysret failed");
83 }
84
85 /* If popping a VM TF fails for some reason, we need to reflect it back to the
86  * user.  It is possible that the reflection fails.  We still need to run
87  * something, and it's a lousy time to try something else.  So We'll give them a
88  * TF that will probably fault right away and kill them. */
89 static void __attribute__((noreturn)) handle_bad_vm_tf(struct vm_trapframe *tf)
90 {
91         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
92
93         tf->tf_exit_reason |= VMX_EXIT_REASONS_FAILED_VMENTRY;
94         tf->tf_flags |= VMCTX_FL_HAS_FAULT;
95         if (reflect_current_context()) {
96                 printk("[kernel] Unable to reflect after a bad VM enter\n");
97                 proc_init_ctx(pcpui->cur_ctx, 0, 0xcafebabe, 0, 0);
98         }
99         proc_pop_ctx(pcpui->cur_ctx);
100 }
101
102 static void __attribute__((noreturn)) proc_pop_vmtf(struct vm_trapframe *tf)
103 {
104         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
105         struct proc *p = pcpui->cur_proc;
106         struct guest_pcore *gpc;
107
108         if (x86_vmtf_is_partial(tf)) {
109                 gpc = lookup_guest_pcore(p, tf->tf_guest_pcoreid);
110                 assert(gpc);
111                 assert(pcpui->guest_pcoreid == tf->tf_guest_pcoreid);
112                 assert(gpc->should_vmresume);
113         } else {
114                 gpc = load_guest_pcore(p, tf->tf_guest_pcoreid);
115                 if (!gpc) {
116                         tf->tf_exit_reason = EXIT_REASON_GUEST_IN_USE;
117                         handle_bad_vm_tf(tf);
118                 }
119         }
120         vmcs_write(GUEST_RSP, tf->tf_rsp);
121         vmcs_write(GUEST_CR3, tf->tf_cr3);
122         vmcs_write(GUEST_RIP, tf->tf_rip);
123         vmcs_write(GUEST_RFLAGS, tf->tf_rflags);
124         /* The host stacktop could have changed, even if we are still a partial
125          * context.  Consider a vmcall that blocks.  We'll restart the partial
126          * context, but be on a new stack.  set_stack_top() doesn't really know
127          * about the VMCS. */
128         vmcs_write(HOST_RSP, pcpui->stacktop);
129         /* cr2 is not part of the VMCS state; we need to save/restore it manually */
130         lcr2(tf->tf_cr2);
131         vmcs_write(VM_ENTRY_INTR_INFO_FIELD, tf->tf_trap_inject);
132         /* Someone may have tried poking the guest and posting an IRQ, but the IPI
133          * missed (concurrent vmexit).  In these cases, the 'outstanding
134          * notification' bit should still be set, and we can resend the IPI.  This
135          * will arrive after we vmenter, since IRQs are currently disabled. */
136         if (test_bit(VMX_POSTED_OUTSTANDING_NOTIF, gpc->posted_irq_desc))
137                 send_self_ipi(I_POKE_GUEST);
138         /* The first time a VMCS is started after being loaded, it must be launched.
139          * Subsequent starts must be resumes.  Once the VMCS is cleared, we start
140          * with a launch again.  Note this is the VMCS, not the GPC unload. */
141         if (gpc->should_vmresume) {
142                 tf->tf_flags |= VMCTX_FL_VMRESUME;
143         } else {
144                 tf->tf_flags &= ~VMCTX_FL_VMRESUME;
145                 gpc->should_vmresume = TRUE;
146         }
147         /* vmlaunch/resume can fail, so we need to be able to return from this.
148          * Thus we can't clobber rsp via the popq style of setting the registers.
149          * Likewise, we don't want to lose rbp via the clobber list.
150          *
151          * Partial contexts have already been launched, so we resume them. */
152         asm volatile (".globl __asm_pop_vmtf_start;"
153                       "__asm_pop_vmtf_start:     "
154                       "testl $"STRINGIFY(VMCTX_FL_VMRESUME)", %c[flags](%0);"
155                       "pushq %%rbp;              "      /* save in case we fail */
156                       "movq %c[rbx](%0), %%rbx;  "
157                       "movq %c[rcx](%0), %%rcx;  "
158                       "movq %c[rdx](%0), %%rdx;  "
159                       "movq %c[rbp](%0), %%rbp;  "
160                       "movq %c[rsi](%0), %%rsi;  "
161                       "movq %c[rdi](%0), %%rdi;  "
162                       "movq %c[r8](%0),  %%r8;   "
163                       "movq %c[r9](%0),  %%r9;   "
164                       "movq %c[r10](%0), %%r10;  "
165                       "movq %c[r11](%0), %%r11;  "
166                       "movq %c[r12](%0), %%r12;  "
167                       "movq %c[r13](%0), %%r13;  "
168                       "movq %c[r14](%0), %%r14;  "
169                       "movq %c[r15](%0), %%r15;  "
170                       "movq %c[rax](%0), %%rax;  "      /* clobber our *tf last */
171                       "jnz 1f;                   "      /* jump if resume */
172                       ASM_VMX_VMLAUNCH";         "      /* non-resume gets launched */
173                       "jmp 2f;                   "
174                       "1: "ASM_VMX_VMRESUME";    "
175                       "2: popq %%rbp;            "      /* vmlaunch failed */
176                       ".globl __asm_pop_vmtf_end;"
177                       "__asm_pop_vmtf_end:       "
178                       :
179                       : "a" (tf),
180                         [rax]"i"(offsetof(struct vm_trapframe, tf_rax)),
181                         [rbx]"i"(offsetof(struct vm_trapframe, tf_rbx)),
182                         [rcx]"i"(offsetof(struct vm_trapframe, tf_rcx)),
183                         [rdx]"i"(offsetof(struct vm_trapframe, tf_rdx)),
184                         [rbp]"i"(offsetof(struct vm_trapframe, tf_rbp)),
185                         [rsi]"i"(offsetof(struct vm_trapframe, tf_rsi)),
186                         [rdi]"i"(offsetof(struct vm_trapframe, tf_rdi)),
187                          [r8]"i"(offsetof(struct vm_trapframe, tf_r8)),
188                          [r9]"i"(offsetof(struct vm_trapframe, tf_r9)),
189                         [r10]"i"(offsetof(struct vm_trapframe, tf_r10)),
190                         [r11]"i"(offsetof(struct vm_trapframe, tf_r11)),
191                         [r12]"i"(offsetof(struct vm_trapframe, tf_r12)),
192                         [r13]"i"(offsetof(struct vm_trapframe, tf_r13)),
193                         [r14]"i"(offsetof(struct vm_trapframe, tf_r14)),
194                         [r15]"i"(offsetof(struct vm_trapframe, tf_r15)),
195                         [flags]"i"(offsetof(struct vm_trapframe, tf_flags))
196                       : "cc", "memory", "rbx", "rcx", "rdx", "rsi", "rdi",
197                         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15");
198         /* vmlaunch/resume failed.  It could be for a few reasons, including things
199          * like launching instead of resuming, not having a VMCS loaded, failing a
200          * host-state area check, etc.  Those are kernel problems.
201          *
202          * The user should not be able to trigger these problems.  The user could
203          * trigger a problem loading the guest-state area, such as a non-canonical
204          * address for RIP.  Those sorts of errors should appear to be a normal
205          * vmexit with some flags set.
206          *
207          * Any failed vmlaunch/resume is likely a kernel bug, but we'll still
208          * reflect it to the user for debugability.
209          *
210          * Also we should always have a non-shadow VMCS, so ZF should be 1 and we
211          * can read the error register. */
212         assert(read_flags() & FL_ZF);
213         tf->tf_exit_reason = EXIT_REASON_VMENTER_FAILED;
214         tf->tf_exit_qual = vmcs_read(VM_INSTRUCTION_ERROR);
215         tf->tf_flags |= VMCTX_FL_PARTIAL;
216         warn("vmlaunch / vmresume failed!, check userspace's reflected fault");
217         handle_bad_vm_tf(tf);
218 }
219
220 void proc_pop_ctx(struct user_context *ctx)
221 {
222         disable_irq();
223         switch (ctx->type) {
224         case ROS_HW_CTX:
225                 proc_pop_hwtf(&ctx->tf.hw_tf);
226                 break;
227         case ROS_SW_CTX:
228                 proc_pop_swtf(&ctx->tf.sw_tf);
229                 break;
230         case ROS_VM_CTX:
231                 proc_pop_vmtf(&ctx->tf.vm_tf);
232                 break;
233         default:
234                 /* We should have caught this when securing the ctx */
235                 panic("Unknown context type %d!", ctx->type);
236         }
237 }
238
239 void proc_init_ctx(struct user_context *ctx, uint32_t vcoreid, uintptr_t entryp,
240                    uintptr_t stack_top, uintptr_t tls_desc)
241 {
242         struct sw_trapframe *sw_tf = &ctx->tf.sw_tf;
243         /* zero the entire structure for any type, prevent potential disclosure */
244         memset(ctx, 0, sizeof(struct user_context));
245         ctx->type = ROS_SW_CTX;
246         /* Stack pointers in x86 C functions need to be such that adding or
247          * subtracting 8 will result in 16 byte alignment (AMD64 ABI), which we call
248          * an odd-8-byte alignment.  The reason is so that input arguments (on the
249          * stack) are 16 byte aligned.  The extra 8 bytes is the retaddr, pushed on
250          * the stack.  Compilers know they can subtract 8 to get 16 byte alignment
251          * for instructions like movaps.
252          *
253          * However, the kernel will start contexts at 16 byte aligned stacks.  This
254          * is because glibc's _start (in ASM) expects this.  Parlib x86's vcore
255          * entry does the same.
256          *
257          * We init contexts for both an elf startup as well as vcore entry.  It is
258          * up to the caller (including the user) to make sure the stack is aligned
259          * properly.  elf.c doesn't know about these concerns, so if it messes up,
260          * there's nothing we can really do, since the args are just wrong.  ld will
261          * fail immediately though, so we'll find out quickly. */
262         sw_tf->tf_rsp = stack_top;
263         sw_tf->tf_rip = entryp;
264         sw_tf->tf_rbp = 0;      /* for potential backtraces */
265         sw_tf->tf_mxcsr = 0x00001f80;   /* x86 default mxcsr */
266         sw_tf->tf_fpucw = 0x037f;               /* x86 default FP CW */
267         /* Coupled closely with user's entry.S.  id is the vcoreid, which entry.S
268          * uses to determine what to do.  vcoreid == 0 is the main core/context. */
269         sw_tf->tf_rbx = vcoreid;
270         sw_tf->tf_fsbase = tls_desc;
271         proc_secure_ctx(ctx);
272 }
273
274 static void proc_secure_hwtf(struct hw_trapframe *tf)
275 {
276         enforce_user_canon(&tf->tf_gsbase);
277         enforce_user_canon(&tf->tf_fsbase);
278         enforce_user_canon(&tf->tf_rip);
279         enforce_user_canon(&tf->tf_rsp);
280         /* GD_UD is the user data segment selector in the GDT, and
281          * GD_UT is the user text segment selector (see inc/memlayout.h).
282          * The low 2 bits of each segment register contains the
283          * Requestor Privilege Level (RPL); 3 means user mode. */
284         tf->tf_ss = GD_UD | 3;
285         tf->tf_cs = GD_UT | 3;
286         /* Always 1: interrupts */
287         tf->tf_rflags |= FL_IF;
288         /* Always 0: IOPL must be set to 0.  VM (virtual 8086) probably doesn't
289          * matter - SDM says it can't get modified via iret anyways.  VIF and VIP
290          * are also virtual-8086 mode stuff.  Supposedly NT is settable by
291          * userspace, but there's no good reason for it.  Rather be paranoid. */
292         tf->tf_rflags &= ~(FL_IOPL_MASK | FL_VM | FL_NT | FL_VIF | FL_VIP);
293         tf->tf_rflags |= FL_RSVD_1;
294         tf->tf_rflags &= FL_RSVD_0;
295         x86_hwtf_clear_partial(tf);
296 }
297
298 static void proc_secure_swtf(struct sw_trapframe *tf)
299 {
300         enforce_user_canon(&tf->tf_gsbase);
301         enforce_user_canon(&tf->tf_fsbase);
302         enforce_user_canon(&tf->tf_rip);
303         enforce_user_canon(&tf->tf_rsp);
304         /* The kernel doesn't actually load the mxcsr or the fpucw, but we can still
305          * sanitize it in case we ever do load it. */
306         tf->tf_mxcsr &= MXCSR_RSVD_0;
307         x86_swtf_clear_partial(tf);
308 }
309
310 static void proc_secure_vmtf(struct vm_trapframe *tf)
311 {
312         /* The user can say whatever it wants for the bulk of the TF.  If they mess
313          * up something in the guest-area, it'll be treated like a vmexit.  There
314          * are a few things in the TF that we use on the kernel side.
315          *
316          * If guest_pcoreid is bad (not a guest_pcore), we'll fail to load the GPC
317          * and reflect the fault to userspace.
318          *
319          * Regarding tf_flags, some are informational for the user, some are used
320          * for our own use in the kernel.
321          * - VMCTX_FL_PARTIAL: We clear this below
322          * - VMCTX_FL_VMRESUME: Used to temporarily carry a bool in pop_vmtf, but we
323          *   never trust the value in the VM TF.
324          * These are write-only from the kernel and passed to the user:
325          * - VMCTX_FL_HAS_FAULT
326          * - VMCTX_FL_EPT_VMR_BACKED */
327         x86_vmtf_clear_partial(tf);
328 }
329
330 void proc_secure_ctx(struct user_context *ctx)
331 {
332         switch (ctx->type) {
333         case ROS_HW_CTX:
334                 proc_secure_hwtf(&ctx->tf.hw_tf);
335                 break;
336         case ROS_SW_CTX:
337                 proc_secure_swtf(&ctx->tf.sw_tf);
338                 break;
339         case ROS_VM_CTX:
340                 proc_secure_vmtf(&ctx->tf.vm_tf);
341                 break;
342         default:
343                 /* If we aren't another ctx type, we're assuming (and forcing) a HW ctx.
344                  * If this is somehow fucked up, userspace should die rather quickly. */
345                 ctx->type = ROS_HW_CTX;
346                 proc_secure_hwtf(&ctx->tf.hw_tf);
347         }
348 }
349
350 /* Called when we are currently running an address space on our core and want to
351  * abandon it.  We need a known good pgdir before releasing the old one.  We
352  * decref, since current no longer tracks the proc (and current no longer
353  * protects the cr3). */
354 void __abandon_core(void)
355 {
356         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
357
358         lcr3(boot_cr3);
359         proc_decref(pcpui->cur_proc);
360         pcpui->cur_proc = 0;
361 }
362
363 void __clear_owning_proc(uint32_t coreid)
364 {
365         vmx_clear_vmcs();
366 }