KVM: selftests: Decouple SEV policy from VM type

In preparation for SNP, cleanup the smoke test to decouple deriving type
from policy.  This will allow reusing the existing interfaces for SNP.

No functional change intended.

Signed-off-by: Pratik R. Sampat <prsampat@amd.com>
Link: https://lore.kernel.org/r/20250305230000.231025-10-prsampat@amd.com
[sean: massage shortlog+changelog]
Signed-off-by: Sean Christopherson <seanjc@google.com>

diff --git a/tools/testing/selftests/kvm/x86/sev_smoke_test.c b/tools/testing/selftests/kvm/x86/sev_smoke_test.c
index b3de38272a37bf38d71d4e09241fd1d832f4161f..d9388e99a4f9660e1f1c640460d76b3b16e87ba7 100644 (file)
--- a/tools/testing/selftests/kvm/x86/sev_smoke_test.c
+++ b/tools/testing/selftests/kvm/x86/sev_smoke_test.c
@@ -62,7 +62,7 @@ static void compare_xsave(u8 *from_host, u8 *from_guest)
                abort();
 }
 
-static void test_sync_vmsa(uint32_t policy)
+static void test_sync_vmsa(uint32_t type, uint64_t policy)
 {
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
@@ -72,7 +72,7 @@ static void test_sync_vmsa(uint32_t policy)
        double x87val = M_PI;
        struct kvm_xsave __attribute__((aligned(64))) xsave = { 0 };
 
-       vm = vm_sev_create_with_one_vcpu(KVM_X86_SEV_ES_VM, guest_code_xsave, &vcpu);
+       vm = vm_sev_create_with_one_vcpu(type, guest_code_xsave, &vcpu);
        gva = vm_vaddr_alloc_shared(vm, PAGE_SIZE, KVM_UTIL_MIN_VADDR,
                                    MEM_REGION_TEST_DATA);
        hva = addr_gva2hva(vm, gva);
@@ -89,7 +89,7 @@ static void test_sync_vmsa(uint32_t policy)
            : "ymm4", "st", "st(1)", "st(2)", "st(3)", "st(4)", "st(5)", "st(6)", "st(7)");
        vcpu_xsave_set(vcpu, &xsave);
 
-       vm_sev_launch(vm, SEV_POLICY_ES | policy, NULL);
+       vm_sev_launch(vm, policy, NULL);
 
        /* This page is shared, so make it decrypted.  */
        memset(hva, 0, 4096);
@@ -108,14 +108,12 @@ static void test_sync_vmsa(uint32_t policy)
        kvm_vm_free(vm);
 }
 
-static void test_sev(void *guest_code, uint64_t policy)
+static void test_sev(void *guest_code, uint32_t type, uint64_t policy)
 {
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
        struct ucall uc;
 
-       uint32_t type = policy & SEV_POLICY_ES ? KVM_X86_SEV_ES_VM : KVM_X86_SEV_VM;
-
        vm = vm_sev_create_with_one_vcpu(type, guest_code, &vcpu);
 
        /* TODO: Validate the measurement is as expected. */
@@ -161,16 +159,14 @@ static void guest_shutdown_code(void)
        __asm__ __volatile__("ud2");
 }
 
-static void test_sev_es_shutdown(void)
+static void test_sev_shutdown(uint32_t type, uint64_t policy)
 {
        struct kvm_vcpu *vcpu;
        struct kvm_vm *vm;
 
-       uint32_t type = KVM_X86_SEV_ES_VM;
-
        vm = vm_sev_create_with_one_vcpu(type, guest_shutdown_code, &vcpu);
 
-       vm_sev_launch(vm, SEV_POLICY_ES, NULL);
+       vm_sev_launch(vm, policy, NULL);
 
        vcpu_run(vcpu);
        TEST_ASSERT(vcpu->run->exit_reason == KVM_EXIT_SHUTDOWN,
@@ -180,27 +176,33 @@ static void test_sev_es_shutdown(void)
        kvm_vm_free(vm);
 }
 
-int main(int argc, char *argv[])
+static void test_sev_smoke(void *guest, uint32_t type, uint64_t policy)
 {
        const u64 xf_mask = XFEATURE_MASK_X87_AVX;
 
-       TEST_REQUIRE(kvm_cpu_has(X86_FEATURE_SEV));
-
-       test_sev(guest_sev_code, SEV_POLICY_NO_DBG);
-       test_sev(guest_sev_code, 0);
+       test_sev(guest, type, policy | SEV_POLICY_NO_DBG);
+       test_sev(guest, type, policy);
 
-       if (kvm_cpu_has(X86_FEATURE_SEV_ES)) {
-               test_sev(guest_sev_es_code, SEV_POLICY_ES | SEV_POLICY_NO_DBG);
-               test_sev(guest_sev_es_code, SEV_POLICY_ES);
+       if (type == KVM_X86_SEV_VM)
+               return;
 
-               test_sev_es_shutdown();
+       test_sev_shutdown(type, policy);
 
-               if (kvm_has_cap(KVM_CAP_XCRS) &&
-                   (xgetbv(0) & kvm_cpu_supported_xcr0() & xf_mask) == xf_mask) {
-                       test_sync_vmsa(0);
-                       test_sync_vmsa(SEV_POLICY_NO_DBG);
-               }
+       if (kvm_has_cap(KVM_CAP_XCRS) &&
+           (xgetbv(0) & kvm_cpu_supported_xcr0() & xf_mask) == xf_mask) {
+               test_sync_vmsa(type, policy);
+               test_sync_vmsa(type, policy | SEV_POLICY_NO_DBG);
        }
+}
+
+int main(int argc, char *argv[])
+{
+       TEST_REQUIRE(kvm_cpu_has(X86_FEATURE_SEV));
+
+       test_sev_smoke(guest_sev_code, KVM_X86_SEV_VM, 0);
+
+       if (kvm_cpu_has(X86_FEATURE_SEV_ES))
+               test_sev_smoke(guest_sev_es_code, KVM_X86_SEV_ES_VM, SEV_POLICY_ES);
 
        return 0;
 }