1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2020, Google LLC. 4 * 5 * Tests for KVM paravirtual feature disablement 6 */ 7 #include <asm/kvm_para.h> 8 #include <linux/kvm_para.h> 9 #include <linux/stringify.h> 10 #include <stdint.h> 11 12 #include "kvm_test_harness.h" 13 #include "apic.h" 14 #include "test_util.h" 15 #include "kvm_util.h" 16 #include "processor.h" 17 18 /* VMCALL and VMMCALL are both 3-byte opcodes. */ 19 #define HYPERCALL_INSN_SIZE 3 20 21 static bool quirk_disabled; 22 23 static void guest_ud_handler(struct ex_regs *regs) 24 { 25 regs->rax = -EFAULT; 26 regs->rip += HYPERCALL_INSN_SIZE; 27 } 28 29 static const uint8_t vmx_vmcall[HYPERCALL_INSN_SIZE] = { 0x0f, 0x01, 0xc1 }; 30 static const uint8_t svm_vmmcall[HYPERCALL_INSN_SIZE] = { 0x0f, 0x01, 0xd9 }; 31 32 extern uint8_t hypercall_insn[HYPERCALL_INSN_SIZE]; 33 static uint64_t do_sched_yield(uint8_t apic_id) 34 { 35 uint64_t ret; 36 37 asm volatile("hypercall_insn:\n\t" 38 ".byte 0xcc,0xcc,0xcc\n\t" 39 : "=a"(ret) 40 : "a"((uint64_t)KVM_HC_SCHED_YIELD), "b"((uint64_t)apic_id) 41 : "memory"); 42 43 return ret; 44 } 45 46 static void guest_main(void) 47 { 48 const uint8_t *native_hypercall_insn; 49 const uint8_t *other_hypercall_insn; 50 uint64_t ret; 51 52 if (host_cpu_is_intel) { 53 native_hypercall_insn = vmx_vmcall; 54 other_hypercall_insn = svm_vmmcall; 55 } else if (host_cpu_is_amd) { 56 native_hypercall_insn = svm_vmmcall; 57 other_hypercall_insn = vmx_vmcall; 58 } else { 59 GUEST_ASSERT(0); 60 /* unreachable */ 61 return; 62 } 63 64 memcpy(hypercall_insn, other_hypercall_insn, HYPERCALL_INSN_SIZE); 65 66 ret = do_sched_yield(GET_APIC_ID_FIELD(xapic_read_reg(APIC_ID))); 67 68 /* 69 * If the quirk is disabled, verify that guest_ud_handler() "returned" 70 * -EFAULT and that KVM did NOT patch the hypercall. If the quirk is 71 * enabled, verify that the hypercall succeeded and that KVM patched in 72 * the "right" hypercall. 73 */ 74 if (quirk_disabled) { 75 GUEST_ASSERT(ret == (uint64_t)-EFAULT); 76 GUEST_ASSERT(!memcmp(other_hypercall_insn, hypercall_insn, 77 HYPERCALL_INSN_SIZE)); 78 } else { 79 GUEST_ASSERT(!ret); 80 GUEST_ASSERT(!memcmp(native_hypercall_insn, hypercall_insn, 81 HYPERCALL_INSN_SIZE)); 82 } 83 84 GUEST_DONE(); 85 } 86 87 KVM_ONE_VCPU_TEST_SUITE(fix_hypercall); 88 89 static void enter_guest(struct kvm_vcpu *vcpu) 90 { 91 struct kvm_run *run = vcpu->run; 92 struct ucall uc; 93 94 vcpu_run(vcpu); 95 switch (get_ucall(vcpu, &uc)) { 96 case UCALL_SYNC: 97 pr_info("%s: %016lx\n", (const char *)uc.args[2], uc.args[3]); 98 break; 99 case UCALL_DONE: 100 return; 101 case UCALL_ABORT: 102 REPORT_GUEST_ASSERT(uc); 103 default: 104 TEST_FAIL("Unhandled ucall: %ld\nexit_reason: %u (%s)", 105 uc.cmd, run->exit_reason, exit_reason_str(run->exit_reason)); 106 } 107 } 108 109 static void test_fix_hypercall(struct kvm_vcpu *vcpu, bool disable_quirk) 110 { 111 struct kvm_vm *vm = vcpu->vm; 112 113 vm_install_exception_handler(vcpu->vm, UD_VECTOR, guest_ud_handler); 114 115 if (disable_quirk) 116 vm_enable_cap(vm, KVM_CAP_DISABLE_QUIRKS2, 117 KVM_X86_QUIRK_FIX_HYPERCALL_INSN); 118 119 quirk_disabled = disable_quirk; 120 sync_global_to_guest(vm, quirk_disabled); 121 122 virt_pg_map(vm, APIC_DEFAULT_GPA, APIC_DEFAULT_GPA); 123 124 enter_guest(vcpu); 125 } 126 127 KVM_ONE_VCPU_TEST(fix_hypercall, enable_quirk, guest_main) 128 { 129 test_fix_hypercall(vcpu, false); 130 } 131 132 KVM_ONE_VCPU_TEST(fix_hypercall, disable_quirk, guest_main) 133 { 134 test_fix_hypercall(vcpu, true); 135 } 136 137 int main(int argc, char *argv[]) 138 { 139 TEST_REQUIRE(kvm_check_cap(KVM_CAP_DISABLE_QUIRKS2) & KVM_X86_QUIRK_FIX_HYPERCALL_INSN); 140 141 return test_harness_run(argc, argv); 142 } 143