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 struct cpuid_mask {
16 union {
17 struct {
18 u32 eax;
19 u32 ebx;
20 u32 ecx;
21 u32 edx;
22 };
23 u32 regs[4];
24 };
25 };
26
test_guest_cpuids(struct kvm_cpuid2 * guest_cpuid)27 static void test_guest_cpuids(struct kvm_cpuid2 *guest_cpuid)
28 {
29 int i;
30 u32 eax, ebx, ecx, edx;
31
32 for (i = 0; i < guest_cpuid->nent; i++) {
33 __cpuid(guest_cpuid->entries[i].function,
34 guest_cpuid->entries[i].index,
35 &eax, &ebx, &ecx, &edx);
36
37 GUEST_ASSERT_EQ(eax, guest_cpuid->entries[i].eax);
38 GUEST_ASSERT_EQ(ebx, guest_cpuid->entries[i].ebx);
39 GUEST_ASSERT_EQ(ecx, guest_cpuid->entries[i].ecx);
40 GUEST_ASSERT_EQ(edx, guest_cpuid->entries[i].edx);
41 }
42
43 }
44
guest_main(struct kvm_cpuid2 * guest_cpuid)45 static void guest_main(struct kvm_cpuid2 *guest_cpuid)
46 {
47 GUEST_SYNC(1);
48
49 test_guest_cpuids(guest_cpuid);
50
51 GUEST_SYNC(2);
52
53 GUEST_ASSERT_EQ(this_cpu_property(X86_PROPERTY_MAX_KVM_LEAF), 0x40000001);
54
55 GUEST_DONE();
56 }
57
get_const_cpuid_mask(const struct kvm_cpuid_entry2 * entry)58 static struct cpuid_mask get_const_cpuid_mask(const struct kvm_cpuid_entry2 *entry)
59 {
60 struct cpuid_mask mask;
61
62 memset(&mask, 0xff, sizeof(mask));
63
64 switch (entry->function) {
65 case 0x1:
66 mask.regs[X86_FEATURE_OSXSAVE.reg] &= ~BIT(X86_FEATURE_OSXSAVE.bit);
67 break;
68 case 0x7:
69 mask.regs[X86_FEATURE_OSPKE.reg] &= ~BIT(X86_FEATURE_OSPKE.bit);
70 break;
71 case 0xd:
72 /*
73 * CPUID.0xD.{0,1}.EBX enumerate XSAVE size based on the current
74 * XCR0 and IA32_XSS MSR values.
75 */
76 if (entry->index < 2)
77 mask.ebx = 0;
78 break;
79 }
80 return mask;
81 }
82
compare_cpuids(const struct kvm_cpuid2 * cpuid1,const struct kvm_cpuid2 * cpuid2)83 static void compare_cpuids(const struct kvm_cpuid2 *cpuid1,
84 const struct kvm_cpuid2 *cpuid2)
85 {
86 const struct kvm_cpuid_entry2 *e1, *e2;
87 int i;
88
89 TEST_ASSERT(cpuid1->nent == cpuid2->nent,
90 "CPUID nent mismatch: %d vs. %d", cpuid1->nent, cpuid2->nent);
91
92 for (i = 0; i < cpuid1->nent; i++) {
93 struct cpuid_mask mask;
94
95 e1 = &cpuid1->entries[i];
96 e2 = &cpuid2->entries[i];
97
98 TEST_ASSERT(e1->function == e2->function &&
99 e1->index == e2->index && e1->flags == e2->flags,
100 "CPUID entries[%d] mismtach: 0x%x.%d.%x vs. 0x%x.%d.%x",
101 i, e1->function, e1->index, e1->flags,
102 e2->function, e2->index, e2->flags);
103
104 /* Mask off dynamic bits, e.g. OSXSAVE, when comparing entries. */
105 mask = get_const_cpuid_mask(e1);
106
107 TEST_ASSERT((e1->eax & mask.eax) == (e2->eax & mask.eax) &&
108 (e1->ebx & mask.ebx) == (e2->ebx & mask.ebx) &&
109 (e1->ecx & mask.ecx) == (e2->ecx & mask.ecx) &&
110 (e1->edx & mask.edx) == (e2->edx & mask.edx),
111 "CPUID 0x%x.%x differ: 0x%x:0x%x:0x%x:0x%x vs 0x%x:0x%x:0x%x:0x%x",
112 e1->function, e1->index,
113 e1->eax & mask.eax, e1->ebx & mask.ebx,
114 e1->ecx & mask.ecx, e1->edx & mask.edx,
115 e2->eax & mask.eax, e2->ebx & mask.ebx,
116 e2->ecx & mask.ecx, e2->edx & mask.edx);
117 }
118 }
119
run_vcpu(struct kvm_vcpu * vcpu,int stage)120 static void run_vcpu(struct kvm_vcpu *vcpu, int stage)
121 {
122 struct ucall uc;
123
124 vcpu_run(vcpu);
125
126 switch (get_ucall(vcpu, &uc)) {
127 case UCALL_SYNC:
128 TEST_ASSERT(!strcmp((const char *)uc.args[0], "hello") &&
129 uc.args[1] == stage + 1,
130 "Stage %d: Unexpected register values vmexit, got %lx",
131 stage + 1, (ulong)uc.args[1]);
132 return;
133 case UCALL_DONE:
134 return;
135 case UCALL_ABORT:
136 REPORT_GUEST_ASSERT(uc);
137 default:
138 TEST_ASSERT(false, "Unexpected exit: %s",
139 exit_reason_str(vcpu->run->exit_reason));
140 }
141 }
142
vcpu_alloc_cpuid(struct kvm_vm * vm,vm_vaddr_t * p_gva,struct kvm_cpuid2 * cpuid)143 struct kvm_cpuid2 *vcpu_alloc_cpuid(struct kvm_vm *vm, vm_vaddr_t *p_gva, struct kvm_cpuid2 *cpuid)
144 {
145 int size = sizeof(*cpuid) + cpuid->nent * sizeof(cpuid->entries[0]);
146 vm_vaddr_t gva = vm_vaddr_alloc(vm, size, KVM_UTIL_MIN_VADDR);
147 struct kvm_cpuid2 *guest_cpuids = addr_gva2hva(vm, gva);
148
149 memcpy(guest_cpuids, cpuid, size);
150
151 *p_gva = gva;
152 return guest_cpuids;
153 }
154
set_cpuid_after_run(struct kvm_vcpu * vcpu)155 static void set_cpuid_after_run(struct kvm_vcpu *vcpu)
156 {
157 struct kvm_cpuid_entry2 *ent;
158 int rc;
159 u32 eax, ebx, x;
160
161 /* Setting unmodified CPUID is allowed */
162 rc = __vcpu_set_cpuid(vcpu);
163 TEST_ASSERT(!rc, "Setting unmodified CPUID after KVM_RUN failed: %d", rc);
164
165 /* Changing CPU features is forbidden */
166 ent = vcpu_get_cpuid_entry(vcpu, 0x7);
167 ebx = ent->ebx;
168 ent->ebx--;
169 rc = __vcpu_set_cpuid(vcpu);
170 TEST_ASSERT(rc, "Changing CPU features should fail");
171 ent->ebx = ebx;
172
173 /* Changing MAXPHYADDR is forbidden */
174 ent = vcpu_get_cpuid_entry(vcpu, 0x80000008);
175 eax = ent->eax;
176 x = eax & 0xff;
177 ent->eax = (eax & ~0xffu) | (x - 1);
178 rc = __vcpu_set_cpuid(vcpu);
179 TEST_ASSERT(rc, "Changing MAXPHYADDR should fail");
180 ent->eax = eax;
181 }
182
test_get_cpuid2(struct kvm_vcpu * vcpu)183 static void test_get_cpuid2(struct kvm_vcpu *vcpu)
184 {
185 struct kvm_cpuid2 *cpuid = allocate_kvm_cpuid2(vcpu->cpuid->nent + 1);
186 int i, r;
187
188 vcpu_ioctl(vcpu, KVM_GET_CPUID2, cpuid);
189 TEST_ASSERT(cpuid->nent == vcpu->cpuid->nent,
190 "KVM didn't update nent on success, wanted %u, got %u",
191 vcpu->cpuid->nent, cpuid->nent);
192
193 for (i = 0; i < vcpu->cpuid->nent; i++) {
194 cpuid->nent = i;
195 r = __vcpu_ioctl(vcpu, KVM_GET_CPUID2, cpuid);
196 TEST_ASSERT(r && errno == E2BIG, KVM_IOCTL_ERROR(KVM_GET_CPUID2, r));
197 TEST_ASSERT(cpuid->nent == i, "KVM modified nent on failure");
198 }
199 free(cpuid);
200 }
201
main(void)202 int main(void)
203 {
204 struct kvm_vcpu *vcpu;
205 vm_vaddr_t cpuid_gva;
206 struct kvm_vm *vm;
207 int stage;
208
209 vm = vm_create_with_one_vcpu(&vcpu, guest_main);
210
211 compare_cpuids(kvm_get_supported_cpuid(), vcpu->cpuid);
212
213 vcpu_alloc_cpuid(vm, &cpuid_gva, vcpu->cpuid);
214
215 vcpu_args_set(vcpu, 1, cpuid_gva);
216
217 for (stage = 0; stage < 3; stage++)
218 run_vcpu(vcpu, stage);
219
220 set_cpuid_after_run(vcpu);
221
222 test_get_cpuid2(vcpu);
223
224 kvm_vm_free(vm);
225 }
226