1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <fcntl.h>
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <string.h>
6 #include <sys/ioctl.h>
7 #include <math.h>
8
9 #include "test_util.h"
10 #include "kvm_util.h"
11 #include "processor.h"
12 #include "svm_util.h"
13 #include "linux/psp-sev.h"
14 #include "sev.h"
15
16
17 #define XFEATURE_MASK_X87_AVX (XFEATURE_MASK_FP | XFEATURE_MASK_SSE | XFEATURE_MASK_YMM)
18
guest_sev_es_code(void)19 static void guest_sev_es_code(void)
20 {
21 /* TODO: Check CPUID after GHCB-based hypercall support is added. */
22 GUEST_ASSERT(rdmsr(MSR_AMD64_SEV) & MSR_AMD64_SEV_ENABLED);
23 GUEST_ASSERT(rdmsr(MSR_AMD64_SEV) & MSR_AMD64_SEV_ES_ENABLED);
24
25 /*
26 * TODO: Add GHCB and ucall support for SEV-ES guests. For now, simply
27 * force "termination" to signal "done" via the GHCB MSR protocol.
28 */
29 wrmsr(MSR_AMD64_SEV_ES_GHCB, GHCB_MSR_TERM_REQ);
30 __asm__ __volatile__("rep; vmmcall");
31 }
32
guest_sev_code(void)33 static void guest_sev_code(void)
34 {
35 GUEST_ASSERT(this_cpu_has(X86_FEATURE_SEV));
36 GUEST_ASSERT(rdmsr(MSR_AMD64_SEV) & MSR_AMD64_SEV_ENABLED);
37
38 GUEST_DONE();
39 }
40
41 /* Stash state passed via VMSA before any compiled code runs. */
42 extern void guest_code_xsave(void);
43 asm("guest_code_xsave:\n"
44 "mov $" __stringify(XFEATURE_MASK_X87_AVX) ", %eax\n"
45 "xor %edx, %edx\n"
46 "xsave (%rdi)\n"
47 "jmp guest_sev_es_code");
48
compare_xsave(u8 * from_host,u8 * from_guest)49 static void compare_xsave(u8 *from_host, u8 *from_guest)
50 {
51 int i;
52 bool bad = false;
53 for (i = 0; i < 4095; i++) {
54 if (from_host[i] != from_guest[i]) {
55 printf("mismatch at %u | %02hhx %02hhx\n",
56 i, from_host[i], from_guest[i]);
57 bad = true;
58 }
59 }
60
61 if (bad)
62 abort();
63 }
64
test_sync_vmsa(uint32_t policy)65 static void test_sync_vmsa(uint32_t policy)
66 {
67 struct kvm_vcpu *vcpu;
68 struct kvm_vm *vm;
69 vm_vaddr_t gva;
70 void *hva;
71
72 double x87val = M_PI;
73 struct kvm_xsave __attribute__((aligned(64))) xsave = { 0 };
74
75 vm = vm_sev_create_with_one_vcpu(KVM_X86_SEV_ES_VM, guest_code_xsave, &vcpu);
76 gva = vm_vaddr_alloc_shared(vm, PAGE_SIZE, KVM_UTIL_MIN_VADDR,
77 MEM_REGION_TEST_DATA);
78 hva = addr_gva2hva(vm, gva);
79
80 vcpu_args_set(vcpu, 1, gva);
81
82 asm("fninit\n"
83 "vpcmpeqb %%ymm4, %%ymm4, %%ymm4\n"
84 "fldl %3\n"
85 "xsave (%2)\n"
86 "fstp %%st\n"
87 : "=m"(xsave)
88 : "A"(XFEATURE_MASK_X87_AVX), "r"(&xsave), "m" (x87val)
89 : "ymm4", "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)");
90 vcpu_xsave_set(vcpu, &xsave);
91
92 vm_sev_launch(vm, SEV_POLICY_ES | policy, NULL);
93
94 /* This page is shared, so make it decrypted. */
95 memset(hva, 0, 4096);
96
97 vcpu_run(vcpu);
98
99 TEST_ASSERT(vcpu->run->exit_reason == KVM_EXIT_SYSTEM_EVENT,
100 "Wanted SYSTEM_EVENT, got %s",
101 exit_reason_str(vcpu->run->exit_reason));
102 TEST_ASSERT_EQ(vcpu->run->system_event.type, KVM_SYSTEM_EVENT_SEV_TERM);
103 TEST_ASSERT_EQ(vcpu->run->system_event.ndata, 1);
104 TEST_ASSERT_EQ(vcpu->run->system_event.data[0], GHCB_MSR_TERM_REQ);
105
106 compare_xsave((u8 *)&xsave, (u8 *)hva);
107
108 kvm_vm_free(vm);
109 }
110
test_sev(void * guest_code,uint64_t policy)111 static void test_sev(void *guest_code, uint64_t policy)
112 {
113 struct kvm_vcpu *vcpu;
114 struct kvm_vm *vm;
115 struct ucall uc;
116
117 uint32_t type = policy & SEV_POLICY_ES ? KVM_X86_SEV_ES_VM : KVM_X86_SEV_VM;
118
119 vm = vm_sev_create_with_one_vcpu(type, guest_code, &vcpu);
120
121 /* TODO: Validate the measurement is as expected. */
122 vm_sev_launch(vm, policy, NULL);
123
124 for (;;) {
125 vcpu_run(vcpu);
126
127 if (policy & SEV_POLICY_ES) {
128 TEST_ASSERT(vcpu->run->exit_reason == KVM_EXIT_SYSTEM_EVENT,
129 "Wanted SYSTEM_EVENT, got %s",
130 exit_reason_str(vcpu->run->exit_reason));
131 TEST_ASSERT_EQ(vcpu->run->system_event.type, KVM_SYSTEM_EVENT_SEV_TERM);
132 TEST_ASSERT_EQ(vcpu->run->system_event.ndata, 1);
133 TEST_ASSERT_EQ(vcpu->run->system_event.data[0], GHCB_MSR_TERM_REQ);
134 break;
135 }
136
137 switch (get_ucall(vcpu, &uc)) {
138 case UCALL_SYNC:
139 continue;
140 case UCALL_DONE:
141 return;
142 case UCALL_ABORT:
143 REPORT_GUEST_ASSERT(uc);
144 default:
145 TEST_FAIL("Unexpected exit: %s",
146 exit_reason_str(vcpu->run->exit_reason));
147 }
148 }
149
150 kvm_vm_free(vm);
151 }
152
guest_shutdown_code(void)153 static void guest_shutdown_code(void)
154 {
155 struct desc_ptr idt;
156
157 /* Clobber the IDT so that #UD is guaranteed to trigger SHUTDOWN. */
158 memset(&idt, 0, sizeof(idt));
159 set_idt(&idt);
160
161 __asm__ __volatile__("ud2");
162 }
163
test_sev_es_shutdown(void)164 static void test_sev_es_shutdown(void)
165 {
166 struct kvm_vcpu *vcpu;
167 struct kvm_vm *vm;
168
169 uint32_t type = KVM_X86_SEV_ES_VM;
170
171 vm = vm_sev_create_with_one_vcpu(type, guest_shutdown_code, &vcpu);
172
173 vm_sev_launch(vm, SEV_POLICY_ES, NULL);
174
175 vcpu_run(vcpu);
176 TEST_ASSERT(vcpu->run->exit_reason == KVM_EXIT_SHUTDOWN,
177 "Wanted SHUTDOWN, got %s",
178 exit_reason_str(vcpu->run->exit_reason));
179
180 kvm_vm_free(vm);
181 }
182
main(int argc,char * argv[])183 int main(int argc, char *argv[])
184 {
185 const u64 xf_mask = XFEATURE_MASK_X87_AVX;
186
187 TEST_REQUIRE(kvm_cpu_has(X86_FEATURE_SEV));
188
189 test_sev(guest_sev_code, SEV_POLICY_NO_DBG);
190 test_sev(guest_sev_code, 0);
191
192 if (kvm_cpu_has(X86_FEATURE_SEV_ES)) {
193 test_sev(guest_sev_es_code, SEV_POLICY_ES | SEV_POLICY_NO_DBG);
194 test_sev(guest_sev_es_code, SEV_POLICY_ES);
195
196 test_sev_es_shutdown();
197
198 if (kvm_has_cap(KVM_CAP_XCRS) &&
199 (xgetbv(0) & kvm_cpu_supported_xcr0() & xf_mask) == xf_mask) {
200 test_sync_vmsa(0);
201 test_sync_vmsa(SEV_POLICY_NO_DBG);
202 }
203 }
204
205 return 0;
206 }
207