path: root/tools/testing/selftests/kvm/x86/svm_nested_efer_test.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Tests for KVM's handling of EFER bits whose behavior is tied to nested SVM.
 *
 * Copyright (C) 2026, Google LLC.
 */
#include "test_util.h"
#include "kvm_util.h"
#include "processor.h"
#include "svm_util.h"
#include "kselftest.h"

static bool l2_ran;

static void l2_clear_efer_svme(void)
{
	u64 efer = rdmsr(MSR_EFER);

	/* generic_svm_setup() initializes EFER_SVME set for L2 */
	GUEST_ASSERT(efer & EFER_SVME);
	wrmsr(MSR_EFER, efer & ~EFER_SVME);

	/* Unreachable, L1 should be shutdown */
	GUEST_ASSERT(0);
}

static void l1_clear_efer_svme(struct svm_test_data *svm)
{
	generic_svm_setup(svm, l2_clear_efer_svme);
	run_guest(svm->vmcb, svm->vmcb_gpa);

	/* Unreachable, L1 should be shutdown */
	GUEST_ASSERT(0);
}

static void l2_lmsle(void)
{
	GUEST_ASSERT(rdmsr(MSR_EFER) & EFER_LMSLE);
	l2_ran = true;
	vmmcall();
}

static void l1_lmsle(struct svm_test_data *svm)
{
	bool lmsle_mbz = this_cpu_has(X86_FEATURE_EFER_LMSLE_MBZ);
	struct vmcb *vmcb = svm->vmcb;
	u64 efer = rdmsr(MSR_EFER);

	/*
	 * Selftests' vCPUs are created with EFER.LMSLE clear; the sub-tests
	 * below need to start from a clean slate.
	 */
	GUEST_ASSERT(!(efer & EFER_LMSLE));
	GUEST_ASSERT(!l2_ran);

	/*
	 * Per the APM, if EFER_LMSLE_MBZ is enumerated in CPUID, "64-bit mode
	 * segment limit checking is not supported and attempting to set
	 * EFER.LMSLE = 1 causes a #GP exception".
	 */
	if (lmsle_mbz) {
		GUEST_ASSERT_EQ(wrmsr_safe(MSR_EFER, efer | EFER_LMSLE), GP_VECTOR);
		GUEST_ASSERT(!(rdmsr(MSR_EFER) & EFER_LMSLE));
	} else {
		GUEST_ASSERT_EQ(wrmsr_safe(MSR_EFER, efer | EFER_LMSLE), 0);
		GUEST_ASSERT(rdmsr(MSR_EFER) & EFER_LMSLE);

		/*
		 * Restore EFER so that generic_svm_setup() doesn't propagate
		 * EFER.LMSLE into vmcb12 on its own, i.e. so that the VMRUN
		 * sub-test actually tests what it thinks it's testing.
		 */
		wrmsr(MSR_EFER, efer);
	}

	/*
	 * VMRUN's consistency checks reject "any MBZ bit of EFER", i.e. a
	 * vmcb12 with EFER.LMSLE set must generate VMEXIT_INVALID when the
	 * defeature is enumerated.
	 */
	generic_svm_setup(svm, l2_lmsle);
	vmcb->save.efer |= EFER_LMSLE;
	run_guest(vmcb, svm->vmcb_gpa);

	if (lmsle_mbz) {
		GUEST_ASSERT_EQ(vmcb->control.exit_code, SVM_EXIT_ERR);
		GUEST_ASSERT(!l2_ran);
	} else {
		GUEST_ASSERT_EQ(vmcb->control.exit_code, SVM_EXIT_VMMCALL);
		GUEST_ASSERT(l2_ran);
		GUEST_ASSERT(vmcb->save.efer & EFER_LMSLE);
	}

	GUEST_DONE();
}

static struct kvm_vcpu *create_l1_vcpu(struct kvm_vm **vm, void *l1_guest_code)
{
	struct kvm_vcpu *vcpu;
	gva_t svm_gva;

	*vm = vm_create_with_one_vcpu(&vcpu, l1_guest_code);

	vcpu_alloc_svm(*vm, &svm_gva);
	vcpu_args_set(vcpu, 1, svm_gva);

	return vcpu;
}

static void test_enumeration(void)
{
	bool lmsle_mbz;

	/*
	 * EFER_LMSLE_MBZ, CPUID.80000008H:EBX[bit 20], is a "defeature" bit,
	 * i.e. is set when the CPU does *not* support long mode segment
	 * limits.  KVM enumerates the defeature if and only if KVM refuses to
	 * set EFER.LMSLE, i.e. if the CPU doesn't support LMSLE, or if KVM
	 * doesn't support nested SVM.  Derive the expectation from raw CPUID
	 * and kvm_amd's "nested" module param rather than from
	 * kvm_cpu_has(X86_FEATURE_SVM), so that the assertion doesn't simply
	 * compare KVM's enumeration to itself.
	 */
	lmsle_mbz = this_cpu_has(X86_FEATURE_EFER_LMSLE_MBZ) ||
		    !this_cpu_has(X86_FEATURE_SVM) ||
		    !kvm_is_nested_virtualization_enabled();

	TEST_ASSERT_EQ(kvm_cpu_has(X86_FEATURE_EFER_LMSLE_MBZ), lmsle_mbz);

	ksft_test_result_pass("KVM enumerates EFER_LMSLE_MBZ=%d\n", lmsle_mbz);
}

static void test_clear_efer_svme(void)
{
	struct kvm_vcpu *vcpu;
	struct kvm_vm *vm;

	vcpu = create_l1_vcpu(&vm, l1_clear_efer_svme);

	vcpu_run(vcpu);
	TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_SHUTDOWN);

	kvm_vm_free(vm);
	ksft_test_result_pass("L2 clearing EFER.SVME shuts down L1\n");
}

static void test_lmsle(bool lmsle_mbz)
{
	struct kvm_vcpu *vcpu;
	struct kvm_vm *vm;
	struct ucall uc;

	vcpu = create_l1_vcpu(&vm, l1_lmsle);

	vcpu_set_or_clear_cpuid_feature(vcpu, X86_FEATURE_EFER_LMSLE_MBZ,
					lmsle_mbz);

	vcpu_run(vcpu);
	TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);

	switch (get_ucall(vcpu, &uc)) {
	case UCALL_ABORT:
		REPORT_GUEST_ASSERT(uc);
	case UCALL_DONE:
		break;
	default:
		TEST_FAIL("Unexpected ucall: %lu", uc.cmd);
	}

	kvm_vm_free(vm);
	ksft_test_result_pass("Guest EFER_LMSLE_MBZ=%d\n", lmsle_mbz);
}

static void test_host_initiated_lmsle(void)
{
	struct kvm_vcpu *vcpu;
	struct kvm_vm *vm;
	u64 efer;

	vm = vm_create_with_one_vcpu(&vcpu, NULL);
	vcpu_set_cpuid_feature(vcpu, X86_FEATURE_EFER_LMSLE_MBZ);

	/*
	 * EFER_LMSLE_MBZ is a guest CPUID consistency check, not a host
	 * capability, i.e. must not be enforced against host-initiated writes,
	 * so that userspace can set MSRs before it sets guest CPUID.
	 */
	efer = vcpu_get_msr(vcpu, MSR_EFER);
	TEST_ASSERT(!(efer & EFER_LMSLE), "EFER.LMSLE unexpectedly set");

	vcpu_set_msr(vcpu, MSR_EFER, efer | EFER_LMSLE);
	TEST_ASSERT_EQ(vcpu_get_msr(vcpu, MSR_EFER), efer | EFER_LMSLE);

	kvm_vm_free(vm);
	ksft_test_result_pass("Host-initiated EFER.LMSLE=1 is allowed\n");
}

static void test_sregs_lmsle(void)
{
	struct kvm_vcpu *vcpu;
	struct kvm_sregs sregs;
	struct kvm_vm *vm;
	int rc;

	vm = vm_create_with_one_vcpu(&vcpu, NULL);
	vcpu_set_cpuid_feature(vcpu, X86_FEATURE_EFER_LMSLE_MBZ);

	/*
	 * Unlike KVM_SET_MSRS, KVM_SET_SREGS runs the full set of guest CPUID
	 * checks, i.e. rejects EFER.LMSLE even though it's host-initiated.
	 */
	vcpu_sregs_get(vcpu, &sregs);
	TEST_ASSERT(!(sregs.efer & EFER_LMSLE), "EFER.LMSLE unexpectedly set");

	sregs.efer |= EFER_LMSLE;
	rc = _vcpu_sregs_set(vcpu, &sregs);
	TEST_ASSERT(rc, "KVM allowed EFER.LMSLE with EFER_LMSLE_MBZ set");

	kvm_vm_free(vm);
	ksft_test_result_pass("KVM_SET_SREGS rejects EFER.LMSLE=1\n");
}

int main(int argc, char *argv[])
{
	bool has_nested_svm, has_lmsle;

	ksft_print_header();
	ksft_set_plan(6);

	test_enumeration();

	/*
	 * The sub-tests below need to actually run a nested guest, and the
	 * EFER.LMSLE sub-tests additionally need KVM to allow EFER.LMSLE.
	 * It's KVM's view of the world, not raw CPUID, that dictates whether
	 * EFER.LMSLE is allowed, i.e. whether the defeature is emulated.
	 */
	has_nested_svm = kvm_cpu_has(X86_FEATURE_SVM);
	has_lmsle = has_nested_svm &&
		    !kvm_cpu_has(X86_FEATURE_EFER_LMSLE_MBZ);

	if (!has_nested_svm)
		ksft_print_msg("Nested SVM unsupported\n");
	else if (!has_lmsle)
		ksft_print_msg("KVM doesn't support EFER.LMSLE\n");

	if (has_nested_svm) {
		test_clear_efer_svme();
		test_lmsle(true);
	} else {
		ksft_test_result_skip("L2 clearing EFER.SVME shuts down L1\n");
		ksft_test_result_skip("Guest EFER_LMSLE_MBZ=1\n");
	}

	if (has_lmsle) {
		test_lmsle(false);
		test_host_initiated_lmsle();
		test_sregs_lmsle();
	} else {
		ksft_test_result_skip("Guest EFER_LMSLE_MBZ=0\n");
		ksft_test_result_skip("Host-initiated EFER.LMSLE=1 is allowed\n");
		ksft_test_result_skip("KVM_SET_SREGS rejects EFER.LMSLE=1\n");
	}

	ksft_finished();
}