Commit 2325d4dd authored by Sean Christopherson's avatar Sean Christopherson Committed by Paolo Bonzini
Browse files

KVM: selftests: Add MONITOR/MWAIT quirk test 



Add a test to verify the "MONITOR/MWAIT never fault" quirk, and as a
bonus, also verify the related "MISC_ENABLES ignores ENABLE_MWAIT" quirk.

If the "never fault" quirk is enabled, MONITOR/MWAIT should always be
emulated as NOPs, even if they're reported as disabled in guest CPUID.
Use the MISC_ENABLES quirk to coerce KVM into toggling the MWAIT CPUID
enable, as KVM now disallows manually toggling CPUID bits after running
the vCPU.

Signed-off-by: default avatarSean Christopherson <seanjc@google.com>
Message-Id: <20220608224516.3788274-6-seanjc@google.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent cc5851c6

tools/testing/selftests/kvm/.gitignore

+1 −0
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
/x86_64/max_vcpuid_cap_test

/x86_64/mmio_warning_test

/x86_64/mmu_role_test

/x86_64/monitor_mwait_test

/x86_64/platform_info_test

/x86_64/pmu_event_filter_test

/x86_64/set_boot_cpu_id

tools/testing/selftests/kvm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -84,6 +84,7 @@ TEST_GEN_PROGS_x86_64 += x86_64/kvm_clock_test 
TEST_GEN_PROGS_x86_64 += x86_64/kvm_pv_test

TEST_GEN_PROGS_x86_64 += x86_64/mmio_warning_test

TEST_GEN_PROGS_x86_64 += x86_64/mmu_role_test

TEST_GEN_PROGS_x86_64 += x86_64/monitor_mwait_test

TEST_GEN_PROGS_x86_64 += x86_64/platform_info_test

TEST_GEN_PROGS_x86_64 += x86_64/pmu_event_filter_test

TEST_GEN_PROGS_x86_64 += x86_64/set_boot_cpu_id

tools/testing/selftests/kvm/x86_64/monitor_mwait_test

deleted100755 → 0
−1.42 MiB

File deleted.

View file

tools/testing/selftests/kvm/x86_64/monitor_mwait_test.c

0 → 100644
+137 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>



#include "kvm_util.h"

#include "processor.h"



#define X86_FEATURE_MWAIT (1u << 3)



enum monitor_mwait_testcases {

	MWAIT_QUIRK_DISABLED = BIT(0),

	MISC_ENABLES_QUIRK_DISABLED = BIT(1),

	MWAIT_DISABLED = BIT(2),

};



static void guest_monitor_wait(int testcase)

{

	/*

	 * If both MWAIT and its quirk are disabled, MONITOR/MWAIT should #UD,

	 * in all other scenarios KVM should emulate them as nops.

	 */

	bool fault_wanted = (testcase & MWAIT_QUIRK_DISABLED) &&

			    (testcase & MWAIT_DISABLED);

	u8 vector;



	GUEST_SYNC(testcase);



	vector = kvm_asm_safe("monitor");

	if (fault_wanted)

		GUEST_ASSERT_2(vector == UD_VECTOR, testcase, vector);

	else

		GUEST_ASSERT_2(!vector, testcase, vector);



	vector = kvm_asm_safe("monitor");

	if (fault_wanted)

		GUEST_ASSERT_2(vector == UD_VECTOR, testcase, vector);

	else

		GUEST_ASSERT_2(!vector, testcase, vector);

}



static void guest_code(void)

{

	guest_monitor_wait(MWAIT_DISABLED);



	guest_monitor_wait(MWAIT_QUIRK_DISABLED | MWAIT_DISABLED);



	guest_monitor_wait(MISC_ENABLES_QUIRK_DISABLED | MWAIT_DISABLED);

	guest_monitor_wait(MISC_ENABLES_QUIRK_DISABLED);



	guest_monitor_wait(MISC_ENABLES_QUIRK_DISABLED | MWAIT_QUIRK_DISABLED | MWAIT_DISABLED);

	guest_monitor_wait(MISC_ENABLES_QUIRK_DISABLED | MWAIT_QUIRK_DISABLED);



	GUEST_DONE();

}



int main(int argc, char *argv[])

{

	uint64_t disabled_quirks;

	struct kvm_cpuid2 *cpuid;

	struct kvm_cpuid_entry2 *entry;

	struct kvm_vcpu *vcpu;

	struct kvm_run *run;

	struct kvm_vm *vm;

	struct ucall uc;

	int testcase;



	TEST_REQUIRE(kvm_has_cap(KVM_CAP_DISABLE_QUIRKS2));



	cpuid = kvm_get_supported_cpuid();



	entry = kvm_get_supported_cpuid_index(1, 0);

	entry->ecx &= ~X86_FEATURE_MWAIT;

	set_cpuid(cpuid, entry);



	vm = vm_create_with_one_vcpu(&vcpu, guest_code);

	vcpu_set_cpuid(vcpu, cpuid);



	run = vcpu->run;



	vm_init_descriptor_tables(vm);

	vcpu_init_descriptor_tables(vcpu);



	while (1) {

		vcpu_run(vcpu);



		TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,

			    "Unexpected exit reason: %u (%s),\n",

			    run->exit_reason,

			    exit_reason_str(run->exit_reason));



		switch (get_ucall(vcpu, &uc)) {

		case UCALL_SYNC:

			testcase = uc.args[1];

			break;

		case UCALL_ABORT:

			TEST_FAIL("%s at %s:%ld, testcase = %lx, vector = %ld",

				  (const char *)uc.args[0], __FILE__,

				  uc.args[1], uc.args[2], uc.args[3]);

			goto done;

		case UCALL_DONE:

			goto done;

		default:

			TEST_FAIL("Unknown ucall %lu", uc.cmd);

			goto done;

		}



		disabled_quirks = 0;

		if (testcase & MWAIT_QUIRK_DISABLED)

			disabled_quirks |= KVM_X86_QUIRK_MWAIT_NEVER_FAULTS;

		if (testcase & MISC_ENABLES_QUIRK_DISABLED)

			disabled_quirks |= KVM_X86_QUIRK_MISC_ENABLE_NO_MWAIT;

		vm_enable_cap(vm, KVM_CAP_DISABLE_QUIRKS2, disabled_quirks);



		/*

		 * If the MISC_ENABLES quirk (KVM neglects to update CPUID to

		 * enable/disable MWAIT) is disabled, toggle the ENABLE_MWAIT

		 * bit in MISC_ENABLES accordingly.  If the quirk is enabled,

		 * the only valid configuration is MWAIT disabled, as CPUID

		 * can't be manually changed after running the vCPU.

		 */

		if (!(testcase & MISC_ENABLES_QUIRK_DISABLED)) {

			TEST_ASSERT(testcase & MWAIT_DISABLED,

				    "Can't toggle CPUID features after running vCPU");

			continue;

		}



		vcpu_set_msr(vcpu, MSR_IA32_MISC_ENABLE,

			     (testcase & MWAIT_DISABLED) ? 0 : MSR_IA32_MISC_ENABLE_MWAIT);

	}



done:

	kvm_vm_free(vm);

	return 0;

}