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: Sean Christopherson <seanjc@google.com>
Message-Id: <20220608224516.3788274-6-seanjc@google.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/tools/testing/selftests/kvm/.gitignore b/tools/testing/selftests/kvm/.gitignore
index dd5c88c1105980589358ef52edc0af5d69021cf0..f3c2f074b948b0621c22e969b38f50226aea00fd 100644 (file)
--- a/tools/testing/selftests/kvm/.gitignore
+++ b/tools/testing/selftests/kvm/.gitignore
@@ -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

diff --git a/tools/testing/selftests/kvm/Makefile b/tools/testing/selftests/kvm/Makefile
index b52c130f7b2f4f6219a76d9244374e148c13add2..ad1634e5659f10c9f51b6259f5c4f04d563348dd 100644 (file)
--- a/tools/testing/selftests/kvm/Makefile
+++ b/tools/testing/selftests/kvm/Makefile
@@ -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

diff --git a/tools/testing/selftests/kvm/x86_64/monitor_mwait_test b/tools/testing/selftests/kvm/x86_64/monitor_mwait_test
deleted file mode 100755 (executable)
index 598b597..0000000
Binary files a/tools/testing/selftests/kvm/x86_64/monitor_mwait_test and /dev/null differ

diff --git a/tools/testing/selftests/kvm/x86_64/monitor_mwait_test.c b/tools/testing/selftests/kvm/x86_64/monitor_mwait_test.c
new file mode 100644 (file)
index 0000000..49f2ed1
--- /dev/null
+++ b/tools/testing/selftests/kvm/x86_64/monitor_mwait_test.c
@@ -0,0 +1,137 @@
+// 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;
+}