1 // SPDX-License-Identifier: GPL-2.0-only
3 #include <linux/psp-sev.h>
10 #include "test_util.h"
12 #include "processor.h"
14 #include "kselftest.h"
15 #include "../lib/kvm_util_internal.h"
17 #define SEV_POLICY_ES 0b100
19 #define NR_MIGRATE_TEST_VCPUS 4
20 #define NR_MIGRATE_TEST_VMS 3
21 #define NR_LOCK_TESTING_THREADS 3
22 #define NR_LOCK_TESTING_ITERATIONS 10000
24 static int __sev_ioctl(int vm_fd, int cmd_id, void *data, __u32 *fw_error)
26 struct kvm_sev_cmd cmd = {
28 .data = (uint64_t)data,
29 .sev_fd = open_sev_dev_path_or_exit(),
33 ret = ioctl(vm_fd, KVM_MEMORY_ENCRYPT_OP, &cmd);
34 *fw_error = cmd.error;
38 static void sev_ioctl(int vm_fd, int cmd_id, void *data)
43 ret = __sev_ioctl(vm_fd, cmd_id, data, &fw_error);
44 TEST_ASSERT(ret == 0 && fw_error == SEV_RET_SUCCESS,
45 "%d failed: return code: %d, errno: %d, fw error: %d",
46 cmd_id, ret, errno, fw_error);
49 static struct kvm_vm *sev_vm_create(bool es)
52 struct kvm_sev_launch_start start = { 0 };
55 vm = vm_create(VM_MODE_DEFAULT, 0, O_RDWR);
56 sev_ioctl(vm->fd, es ? KVM_SEV_ES_INIT : KVM_SEV_INIT, NULL);
57 for (i = 0; i < NR_MIGRATE_TEST_VCPUS; ++i)
60 start.policy |= SEV_POLICY_ES;
61 sev_ioctl(vm->fd, KVM_SEV_LAUNCH_START, &start);
63 sev_ioctl(vm->fd, KVM_SEV_LAUNCH_UPDATE_VMSA, NULL);
67 static struct kvm_vm *aux_vm_create(bool with_vcpus)
72 vm = vm_create(VM_MODE_DEFAULT, 0, O_RDWR);
76 for (i = 0; i < NR_MIGRATE_TEST_VCPUS; ++i)
82 static int __sev_migrate_from(int dst_fd, int src_fd)
84 struct kvm_enable_cap cap = {
85 .cap = KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM,
89 return ioctl(dst_fd, KVM_ENABLE_CAP, &cap);
93 static void sev_migrate_from(int dst_fd, int src_fd)
97 ret = __sev_migrate_from(dst_fd, src_fd);
98 TEST_ASSERT(!ret, "Migration failed, ret: %d, errno: %d\n", ret, errno);
101 static void test_sev_migrate_from(bool es)
103 struct kvm_vm *src_vm;
104 struct kvm_vm *dst_vms[NR_MIGRATE_TEST_VMS];
107 src_vm = sev_vm_create(es);
108 for (i = 0; i < NR_MIGRATE_TEST_VMS; ++i)
109 dst_vms[i] = aux_vm_create(true);
111 /* Initial migration from the src to the first dst. */
112 sev_migrate_from(dst_vms[0]->fd, src_vm->fd);
114 for (i = 1; i < NR_MIGRATE_TEST_VMS; i++)
115 sev_migrate_from(dst_vms[i]->fd, dst_vms[i - 1]->fd);
117 /* Migrate the guest back to the original VM. */
118 ret = __sev_migrate_from(src_vm->fd, dst_vms[NR_MIGRATE_TEST_VMS - 1]->fd);
119 TEST_ASSERT(ret == -1 && errno == EIO,
120 "VM that was migrated from should be dead. ret %d, errno: %d\n", ret,
124 for (i = 0; i < NR_MIGRATE_TEST_VMS; ++i)
125 kvm_vm_free(dst_vms[i]);
128 struct locking_thread_input {
130 int source_fds[NR_LOCK_TESTING_THREADS];
133 static void *locking_test_thread(void *arg)
136 struct locking_thread_input *input = (struct locking_thread_input *)arg;
138 for (i = 0; i < NR_LOCK_TESTING_ITERATIONS; ++i) {
139 j = i % NR_LOCK_TESTING_THREADS;
140 __sev_migrate_from(input->vm->fd, input->source_fds[j]);
146 static void test_sev_migrate_locking(void)
148 struct locking_thread_input input[NR_LOCK_TESTING_THREADS];
149 pthread_t pt[NR_LOCK_TESTING_THREADS];
152 for (i = 0; i < NR_LOCK_TESTING_THREADS; ++i) {
153 input[i].vm = sev_vm_create(/* es= */ false);
154 input[0].source_fds[i] = input[i].vm->fd;
156 for (i = 1; i < NR_LOCK_TESTING_THREADS; ++i)
157 memcpy(input[i].source_fds, input[0].source_fds,
158 sizeof(input[i].source_fds));
160 for (i = 0; i < NR_LOCK_TESTING_THREADS; ++i)
161 pthread_create(&pt[i], NULL, locking_test_thread, &input[i]);
163 for (i = 0; i < NR_LOCK_TESTING_THREADS; ++i)
164 pthread_join(pt[i], NULL);
165 for (i = 0; i < NR_LOCK_TESTING_THREADS; ++i)
166 kvm_vm_free(input[i].vm);
169 static void test_sev_migrate_parameters(void)
171 struct kvm_vm *sev_vm, *sev_es_vm, *vm_no_vcpu, *vm_no_sev,
175 sev_vm = sev_vm_create(/* es= */ false);
176 sev_es_vm = sev_vm_create(/* es= */ true);
177 vm_no_vcpu = vm_create(VM_MODE_DEFAULT, 0, O_RDWR);
178 vm_no_sev = aux_vm_create(true);
179 sev_es_vm_no_vmsa = vm_create(VM_MODE_DEFAULT, 0, O_RDWR);
180 sev_ioctl(sev_es_vm_no_vmsa->fd, KVM_SEV_ES_INIT, NULL);
181 vm_vcpu_add(sev_es_vm_no_vmsa, 1);
183 ret = __sev_migrate_from(sev_vm->fd, sev_es_vm->fd);
185 ret == -1 && errno == EINVAL,
186 "Should not be able migrate to SEV enabled VM. ret: %d, errno: %d\n",
189 ret = __sev_migrate_from(sev_es_vm->fd, sev_vm->fd);
191 ret == -1 && errno == EINVAL,
192 "Should not be able migrate to SEV-ES enabled VM. ret: %d, errno: %d\n",
195 ret = __sev_migrate_from(vm_no_vcpu->fd, sev_es_vm->fd);
197 ret == -1 && errno == EINVAL,
198 "SEV-ES migrations require same number of vCPUS. ret: %d, errno: %d\n",
201 ret = __sev_migrate_from(vm_no_vcpu->fd, sev_es_vm_no_vmsa->fd);
203 ret == -1 && errno == EINVAL,
204 "SEV-ES migrations require UPDATE_VMSA. ret %d, errno: %d\n",
207 ret = __sev_migrate_from(vm_no_vcpu->fd, vm_no_sev->fd);
208 TEST_ASSERT(ret == -1 && errno == EINVAL,
209 "Migrations require SEV enabled. ret %d, errno: %d\n", ret,
213 kvm_vm_free(sev_es_vm);
214 kvm_vm_free(sev_es_vm_no_vmsa);
215 kvm_vm_free(vm_no_vcpu);
216 kvm_vm_free(vm_no_sev);
219 static int __sev_mirror_create(int dst_fd, int src_fd)
221 struct kvm_enable_cap cap = {
222 .cap = KVM_CAP_VM_COPY_ENC_CONTEXT_FROM,
226 return ioctl(dst_fd, KVM_ENABLE_CAP, &cap);
230 static void sev_mirror_create(int dst_fd, int src_fd)
234 ret = __sev_mirror_create(dst_fd, src_fd);
235 TEST_ASSERT(!ret, "Copying context failed, ret: %d, errno: %d\n", ret, errno);
238 static void verify_mirror_allowed_cmds(int vm_fd)
240 struct kvm_sev_guest_status status;
242 for (int cmd_id = KVM_SEV_INIT; cmd_id < KVM_SEV_NR_MAX; ++cmd_id) {
247 * These commands are allowed for mirror VMs, all others are
251 case KVM_SEV_LAUNCH_UPDATE_VMSA:
252 case KVM_SEV_GUEST_STATUS:
253 case KVM_SEV_DBG_DECRYPT:
254 case KVM_SEV_DBG_ENCRYPT:
261 * These commands should be disallowed before the data
262 * parameter is examined so NULL is OK here.
264 ret = __sev_ioctl(vm_fd, cmd_id, NULL, &fw_error);
266 ret == -1 && errno == EINVAL,
267 "Should not be able call command: %d. ret: %d, errno: %d\n",
271 sev_ioctl(vm_fd, KVM_SEV_GUEST_STATUS, &status);
274 static void test_sev_mirror(bool es)
276 struct kvm_vm *src_vm, *dst_vm;
279 src_vm = sev_vm_create(es);
280 dst_vm = aux_vm_create(false);
282 sev_mirror_create(dst_vm->fd, src_vm->fd);
284 /* Check that we can complete creation of the mirror VM. */
285 for (i = 0; i < NR_MIGRATE_TEST_VCPUS; ++i)
286 vm_vcpu_add(dst_vm, i);
289 sev_ioctl(dst_vm->fd, KVM_SEV_LAUNCH_UPDATE_VMSA, NULL);
291 verify_mirror_allowed_cmds(dst_vm->fd);
297 static void test_sev_mirror_parameters(void)
299 struct kvm_vm *sev_vm, *sev_es_vm, *vm_no_vcpu, *vm_with_vcpu;
302 sev_vm = sev_vm_create(/* es= */ false);
303 sev_es_vm = sev_vm_create(/* es= */ true);
304 vm_with_vcpu = aux_vm_create(true);
305 vm_no_vcpu = aux_vm_create(false);
307 ret = __sev_mirror_create(sev_vm->fd, sev_vm->fd);
309 ret == -1 && errno == EINVAL,
310 "Should not be able copy context to self. ret: %d, errno: %d\n",
313 ret = __sev_mirror_create(sev_vm->fd, sev_es_vm->fd);
315 ret == -1 && errno == EINVAL,
316 "Should not be able copy context to SEV enabled VM. ret: %d, errno: %d\n",
319 ret = __sev_mirror_create(sev_es_vm->fd, sev_vm->fd);
321 ret == -1 && errno == EINVAL,
322 "Should not be able copy context to SEV-ES enabled VM. ret: %d, errno: %d\n",
325 ret = __sev_mirror_create(vm_no_vcpu->fd, vm_with_vcpu->fd);
326 TEST_ASSERT(ret == -1 && errno == EINVAL,
327 "Copy context requires SEV enabled. ret %d, errno: %d\n", ret,
330 ret = __sev_mirror_create(vm_with_vcpu->fd, sev_vm->fd);
332 ret == -1 && errno == EINVAL,
333 "SEV copy context requires no vCPUS on the destination. ret: %d, errno: %d\n",
337 kvm_vm_free(sev_es_vm);
338 kvm_vm_free(vm_with_vcpu);
339 kvm_vm_free(vm_no_vcpu);
342 static void test_sev_move_copy(void)
344 struct kvm_vm *dst_vm, *sev_vm, *mirror_vm, *dst_mirror_vm;
347 sev_vm = sev_vm_create(/* es= */ false);
348 dst_vm = aux_vm_create(true);
349 mirror_vm = aux_vm_create(false);
350 dst_mirror_vm = aux_vm_create(false);
352 sev_mirror_create(mirror_vm->fd, sev_vm->fd);
353 ret = __sev_migrate_from(dst_vm->fd, sev_vm->fd);
354 TEST_ASSERT(ret == -1 && errno == EBUSY,
355 "Cannot migrate VM that has mirrors. ret %d, errno: %d\n", ret,
358 /* The mirror itself can be migrated. */
359 sev_migrate_from(dst_mirror_vm->fd, mirror_vm->fd);
360 ret = __sev_migrate_from(dst_vm->fd, sev_vm->fd);
361 TEST_ASSERT(ret == -1 && errno == EBUSY,
362 "Cannot migrate VM that has mirrors. ret %d, errno: %d\n", ret,
366 * mirror_vm is not a mirror anymore, dst_mirror_vm is. Thus,
367 * the owner can be copied as soon as dst_mirror_vm is gone.
369 kvm_vm_free(dst_mirror_vm);
370 sev_migrate_from(dst_vm->fd, sev_vm->fd);
372 kvm_vm_free(mirror_vm);
377 int main(int argc, char *argv[])
379 if (kvm_check_cap(KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM)) {
380 test_sev_migrate_from(/* es= */ false);
381 test_sev_migrate_from(/* es= */ true);
382 test_sev_migrate_locking();
383 test_sev_migrate_parameters();
384 if (kvm_check_cap(KVM_CAP_VM_COPY_ENC_CONTEXT_FROM))
385 test_sev_move_copy();
387 if (kvm_check_cap(KVM_CAP_VM_COPY_ENC_CONTEXT_FROM)) {
388 test_sev_mirror(/* es= */ false);
389 test_sev_mirror(/* es= */ true);
390 test_sev_mirror_parameters();