1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2021, Red Hat Inc. 4 * 5 * Generic tests for KVM CPUID set/get ioctls 6 */ 7 #include <asm/kvm_para.h> 8 #include <linux/kvm_para.h> 9 #include <stdint.h> 10 11 #include "test_util.h" 12 #include "kvm_util.h" 13 #include "processor.h" 14 15 /* CPUIDs known to differ */ 16 struct { 17 u32 function; 18 u32 index; 19 } mangled_cpuids[] = { 20 /* 21 * These entries depend on the vCPU's XCR0 register and IA32_XSS MSR, 22 * which are not controlled for by this test. 23 */ 24 {.function = 0xd, .index = 0}, 25 {.function = 0xd, .index = 1}, 26 }; 27 28 static void test_guest_cpuids(struct kvm_cpuid2 *guest_cpuid) 29 { 30 int i; 31 u32 eax, ebx, ecx, edx; 32 33 for (i = 0; i < guest_cpuid->nent; i++) { 34 __cpuid(guest_cpuid->entries[i].function, 35 guest_cpuid->entries[i].index, 36 &eax, &ebx, &ecx, &edx); 37 38 GUEST_ASSERT_EQ(eax, guest_cpuid->entries[i].eax); 39 GUEST_ASSERT_EQ(ebx, guest_cpuid->entries[i].ebx); 40 GUEST_ASSERT_EQ(ecx, guest_cpuid->entries[i].ecx); 41 GUEST_ASSERT_EQ(edx, guest_cpuid->entries[i].edx); 42 } 43 44 } 45 46 static void guest_main(struct kvm_cpuid2 *guest_cpuid) 47 { 48 GUEST_SYNC(1); 49 50 test_guest_cpuids(guest_cpuid); 51 52 GUEST_SYNC(2); 53 54 GUEST_ASSERT_EQ(this_cpu_property(X86_PROPERTY_MAX_KVM_LEAF), 0x40000001); 55 56 GUEST_DONE(); 57 } 58 59 static bool is_cpuid_mangled(const struct kvm_cpuid_entry2 *entrie) 60 { 61 int i; 62 63 for (i = 0; i < sizeof(mangled_cpuids); i++) { 64 if (mangled_cpuids[i].function == entrie->function && 65 mangled_cpuids[i].index == entrie->index) 66 return true; 67 } 68 69 return false; 70 } 71 72 static void compare_cpuids(const struct kvm_cpuid2 *cpuid1, 73 const struct kvm_cpuid2 *cpuid2) 74 { 75 const struct kvm_cpuid_entry2 *e1, *e2; 76 int i; 77 78 TEST_ASSERT(cpuid1->nent == cpuid2->nent, 79 "CPUID nent mismatch: %d vs. %d", cpuid1->nent, cpuid2->nent); 80 81 for (i = 0; i < cpuid1->nent; i++) { 82 e1 = &cpuid1->entries[i]; 83 e2 = &cpuid2->entries[i]; 84 85 TEST_ASSERT(e1->function == e2->function && 86 e1->index == e2->index && e1->flags == e2->flags, 87 "CPUID entries[%d] mismtach: 0x%x.%d.%x vs. 0x%x.%d.%x\n", 88 i, e1->function, e1->index, e1->flags, 89 e2->function, e2->index, e2->flags); 90 91 if (is_cpuid_mangled(e1)) 92 continue; 93 94 TEST_ASSERT(e1->eax == e2->eax && e1->ebx == e2->ebx && 95 e1->ecx == e2->ecx && e1->edx == e2->edx, 96 "CPUID 0x%x.%x differ: 0x%x:0x%x:0x%x:0x%x vs 0x%x:0x%x:0x%x:0x%x", 97 e1->function, e1->index, 98 e1->eax, e1->ebx, e1->ecx, e1->edx, 99 e2->eax, e2->ebx, e2->ecx, e2->edx); 100 } 101 } 102 103 static void run_vcpu(struct kvm_vcpu *vcpu, int stage) 104 { 105 struct ucall uc; 106 107 vcpu_run(vcpu); 108 109 switch (get_ucall(vcpu, &uc)) { 110 case UCALL_SYNC: 111 TEST_ASSERT(!strcmp((const char *)uc.args[0], "hello") && 112 uc.args[1] == stage + 1, 113 "Stage %d: Unexpected register values vmexit, got %lx", 114 stage + 1, (ulong)uc.args[1]); 115 return; 116 case UCALL_DONE: 117 return; 118 case UCALL_ABORT: 119 REPORT_GUEST_ASSERT(uc); 120 default: 121 TEST_ASSERT(false, "Unexpected exit: %s", 122 exit_reason_str(vcpu->run->exit_reason)); 123 } 124 } 125 126 struct kvm_cpuid2 *vcpu_alloc_cpuid(struct kvm_vm *vm, vm_vaddr_t *p_gva, struct kvm_cpuid2 *cpuid) 127 { 128 int size = sizeof(*cpuid) + cpuid->nent * sizeof(cpuid->entries[0]); 129 vm_vaddr_t gva = vm_vaddr_alloc(vm, size, KVM_UTIL_MIN_VADDR); 130 struct kvm_cpuid2 *guest_cpuids = addr_gva2hva(vm, gva); 131 132 memcpy(guest_cpuids, cpuid, size); 133 134 *p_gva = gva; 135 return guest_cpuids; 136 } 137 138 static void set_cpuid_after_run(struct kvm_vcpu *vcpu) 139 { 140 struct kvm_cpuid_entry2 *ent; 141 int rc; 142 u32 eax, ebx, x; 143 144 /* Setting unmodified CPUID is allowed */ 145 rc = __vcpu_set_cpuid(vcpu); 146 TEST_ASSERT(!rc, "Setting unmodified CPUID after KVM_RUN failed: %d", rc); 147 148 /* Changing CPU features is forbidden */ 149 ent = vcpu_get_cpuid_entry(vcpu, 0x7); 150 ebx = ent->ebx; 151 ent->ebx--; 152 rc = __vcpu_set_cpuid(vcpu); 153 TEST_ASSERT(rc, "Changing CPU features should fail"); 154 ent->ebx = ebx; 155 156 /* Changing MAXPHYADDR is forbidden */ 157 ent = vcpu_get_cpuid_entry(vcpu, 0x80000008); 158 eax = ent->eax; 159 x = eax & 0xff; 160 ent->eax = (eax & ~0xffu) | (x - 1); 161 rc = __vcpu_set_cpuid(vcpu); 162 TEST_ASSERT(rc, "Changing MAXPHYADDR should fail"); 163 ent->eax = eax; 164 } 165 166 static void test_get_cpuid2(struct kvm_vcpu *vcpu) 167 { 168 struct kvm_cpuid2 *cpuid = allocate_kvm_cpuid2(vcpu->cpuid->nent + 1); 169 int i, r; 170 171 vcpu_ioctl(vcpu, KVM_GET_CPUID2, cpuid); 172 TEST_ASSERT(cpuid->nent == vcpu->cpuid->nent, 173 "KVM didn't update nent on success, wanted %u, got %u\n", 174 vcpu->cpuid->nent, cpuid->nent); 175 176 for (i = 0; i < vcpu->cpuid->nent; i++) { 177 cpuid->nent = i; 178 r = __vcpu_ioctl(vcpu, KVM_GET_CPUID2, cpuid); 179 TEST_ASSERT(r && errno == E2BIG, KVM_IOCTL_ERROR(KVM_GET_CPUID2, r)); 180 TEST_ASSERT(cpuid->nent == i, "KVM modified nent on failure"); 181 } 182 free(cpuid); 183 } 184 185 int main(void) 186 { 187 struct kvm_vcpu *vcpu; 188 vm_vaddr_t cpuid_gva; 189 struct kvm_vm *vm; 190 int stage; 191 192 vm = vm_create_with_one_vcpu(&vcpu, guest_main); 193 194 compare_cpuids(kvm_get_supported_cpuid(), vcpu->cpuid); 195 196 vcpu_alloc_cpuid(vm, &cpuid_gva, vcpu->cpuid); 197 198 vcpu_args_set(vcpu, 1, cpuid_gva); 199 200 for (stage = 0; stage < 3; stage++) 201 run_vcpu(vcpu, stage); 202 203 set_cpuid_after_run(vcpu); 204 205 test_get_cpuid2(vcpu); 206 207 kvm_vm_free(vm); 208 } 209