1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * tools/testing/selftests/kvm/lib/x86_64/svm.c
4 * Helpers used for nested SVM testing
5 * Largely inspired from KVM unit test svm.c
6 *
7 * Copyright (C) 2020, Red Hat, Inc.
8 */
9
10 #include "test_util.h"
11 #include "kvm_util.h"
12 #include "../kvm_util_internal.h"
13 #include "processor.h"
14 #include "svm_util.h"
15
16 struct gpr64_regs guest_regs;
17 u64 rflags;
18
19 /* Allocate memory regions for nested SVM tests.
20 *
21 * Input Args:
22 * vm - The VM to allocate guest-virtual addresses in.
23 *
24 * Output Args:
25 * p_svm_gva - The guest virtual address for the struct svm_test_data.
26 *
27 * Return:
28 * Pointer to structure with the addresses of the SVM areas.
29 */
30 struct svm_test_data *
vcpu_alloc_svm(struct kvm_vm * vm,vm_vaddr_t * p_svm_gva)31 vcpu_alloc_svm(struct kvm_vm *vm, vm_vaddr_t *p_svm_gva)
32 {
33 vm_vaddr_t svm_gva = vm_vaddr_alloc(vm, getpagesize(),
34 0x10000, 0, 0);
35 struct svm_test_data *svm = addr_gva2hva(vm, svm_gva);
36
37 svm->vmcb = (void *)vm_vaddr_alloc(vm, getpagesize(),
38 0x10000, 0, 0);
39 svm->vmcb_hva = addr_gva2hva(vm, (uintptr_t)svm->vmcb);
40 svm->vmcb_gpa = addr_gva2gpa(vm, (uintptr_t)svm->vmcb);
41
42 svm->save_area = (void *)vm_vaddr_alloc(vm, getpagesize(),
43 0x10000, 0, 0);
44 svm->save_area_hva = addr_gva2hva(vm, (uintptr_t)svm->save_area);
45 svm->save_area_gpa = addr_gva2gpa(vm, (uintptr_t)svm->save_area);
46
47 *p_svm_gva = svm_gva;
48 return svm;
49 }
50
vmcb_set_seg(struct vmcb_seg * seg,u16 selector,u64 base,u32 limit,u32 attr)51 static void vmcb_set_seg(struct vmcb_seg *seg, u16 selector,
52 u64 base, u32 limit, u32 attr)
53 {
54 seg->selector = selector;
55 seg->attrib = attr;
56 seg->limit = limit;
57 seg->base = base;
58 }
59
60 /*
61 * Avoid using memset to clear the vmcb, since libc may not be
62 * available in L1 (and, even if it is, features that libc memset may
63 * want to use, like AVX, may not be enabled).
64 */
clear_vmcb(struct vmcb * vmcb)65 static void clear_vmcb(struct vmcb *vmcb)
66 {
67 int n = sizeof(*vmcb) / sizeof(u32);
68
69 asm volatile ("rep stosl" : "+c"(n), "+D"(vmcb) : "a"(0) : "memory");
70 }
71
generic_svm_setup(struct svm_test_data * svm,void * guest_rip,void * guest_rsp)72 void generic_svm_setup(struct svm_test_data *svm, void *guest_rip, void *guest_rsp)
73 {
74 struct vmcb *vmcb = svm->vmcb;
75 uint64_t vmcb_gpa = svm->vmcb_gpa;
76 struct vmcb_save_area *save = &vmcb->save;
77 struct vmcb_control_area *ctrl = &vmcb->control;
78 u32 data_seg_attr = 3 | SVM_SELECTOR_S_MASK | SVM_SELECTOR_P_MASK
79 | SVM_SELECTOR_DB_MASK | SVM_SELECTOR_G_MASK;
80 u32 code_seg_attr = 9 | SVM_SELECTOR_S_MASK | SVM_SELECTOR_P_MASK
81 | SVM_SELECTOR_L_MASK | SVM_SELECTOR_G_MASK;
82 uint64_t efer;
83
84 efer = rdmsr(MSR_EFER);
85 wrmsr(MSR_EFER, efer | EFER_SVME);
86 wrmsr(MSR_VM_HSAVE_PA, svm->save_area_gpa);
87
88 clear_vmcb(vmcb);
89 asm volatile ("vmsave %0\n\t" : : "a" (vmcb_gpa) : "memory");
90 vmcb_set_seg(&save->es, get_es(), 0, -1U, data_seg_attr);
91 vmcb_set_seg(&save->cs, get_cs(), 0, -1U, code_seg_attr);
92 vmcb_set_seg(&save->ss, get_ss(), 0, -1U, data_seg_attr);
93 vmcb_set_seg(&save->ds, get_ds(), 0, -1U, data_seg_attr);
94 vmcb_set_seg(&save->gdtr, 0, get_gdt().address, get_gdt().size, 0);
95 vmcb_set_seg(&save->idtr, 0, get_idt().address, get_idt().size, 0);
96
97 ctrl->asid = 1;
98 save->cpl = 0;
99 save->efer = rdmsr(MSR_EFER);
100 asm volatile ("mov %%cr4, %0" : "=r"(save->cr4) : : "memory");
101 asm volatile ("mov %%cr3, %0" : "=r"(save->cr3) : : "memory");
102 asm volatile ("mov %%cr0, %0" : "=r"(save->cr0) : : "memory");
103 asm volatile ("mov %%dr7, %0" : "=r"(save->dr7) : : "memory");
104 asm volatile ("mov %%dr6, %0" : "=r"(save->dr6) : : "memory");
105 asm volatile ("mov %%cr2, %0" : "=r"(save->cr2) : : "memory");
106 save->g_pat = rdmsr(MSR_IA32_CR_PAT);
107 save->dbgctl = rdmsr(MSR_IA32_DEBUGCTLMSR);
108 ctrl->intercept = (1ULL << INTERCEPT_VMRUN) |
109 (1ULL << INTERCEPT_VMMCALL);
110
111 vmcb->save.rip = (u64)guest_rip;
112 vmcb->save.rsp = (u64)guest_rsp;
113 guest_regs.rdi = (u64)svm;
114 }
115
116 /*
117 * save/restore 64-bit general registers except rax, rip, rsp
118 * which are directly handed through the VMCB guest processor state
119 */
120 #define SAVE_GPR_C \
121 "xchg %%rbx, guest_regs+0x20\n\t" \
122 "xchg %%rcx, guest_regs+0x10\n\t" \
123 "xchg %%rdx, guest_regs+0x18\n\t" \
124 "xchg %%rbp, guest_regs+0x30\n\t" \
125 "xchg %%rsi, guest_regs+0x38\n\t" \
126 "xchg %%rdi, guest_regs+0x40\n\t" \
127 "xchg %%r8, guest_regs+0x48\n\t" \
128 "xchg %%r9, guest_regs+0x50\n\t" \
129 "xchg %%r10, guest_regs+0x58\n\t" \
130 "xchg %%r11, guest_regs+0x60\n\t" \
131 "xchg %%r12, guest_regs+0x68\n\t" \
132 "xchg %%r13, guest_regs+0x70\n\t" \
133 "xchg %%r14, guest_regs+0x78\n\t" \
134 "xchg %%r15, guest_regs+0x80\n\t"
135
136 #define LOAD_GPR_C SAVE_GPR_C
137
138 /*
139 * selftests do not use interrupts so we dropped clgi/sti/cli/stgi
140 * for now. registers involved in LOAD/SAVE_GPR_C are eventually
141 * unmodified so they do not need to be in the clobber list.
142 */
run_guest(struct vmcb * vmcb,uint64_t vmcb_gpa)143 void run_guest(struct vmcb *vmcb, uint64_t vmcb_gpa)
144 {
145 asm volatile (
146 "vmload %[vmcb_gpa]\n\t"
147 "mov rflags, %%r15\n\t" // rflags
148 "mov %%r15, 0x170(%[vmcb])\n\t"
149 "mov guest_regs, %%r15\n\t" // rax
150 "mov %%r15, 0x1f8(%[vmcb])\n\t"
151 LOAD_GPR_C
152 "vmrun %[vmcb_gpa]\n\t"
153 SAVE_GPR_C
154 "mov 0x170(%[vmcb]), %%r15\n\t" // rflags
155 "mov %%r15, rflags\n\t"
156 "mov 0x1f8(%[vmcb]), %%r15\n\t" // rax
157 "mov %%r15, guest_regs\n\t"
158 "vmsave %[vmcb_gpa]\n\t"
159 : : [vmcb] "r" (vmcb), [vmcb_gpa] "a" (vmcb_gpa)
160 : "r15", "memory");
161 }
162
nested_svm_supported(void)163 bool nested_svm_supported(void)
164 {
165 struct kvm_cpuid_entry2 *entry =
166 kvm_get_supported_cpuid_entry(0x80000001);
167
168 return entry->ecx & CPUID_SVM;
169 }
170
nested_svm_check_supported(void)171 void nested_svm_check_supported(void)
172 {
173 if (!nested_svm_supported()) {
174 print_skip("nested SVM not enabled");
175 exit(KSFT_SKIP);
176 }
177 }
178