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

   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 #define VCPU_ID 0
  16
  17 /* CPUIDs known to differ */
  18 struct {
  19         u32 function;
  20         u32 index;
  21 } mangled_cpuids[] = {
  22         {.function = 0xd, .index = 0},
  23 };
  24
  25 static void test_guest_cpuids(struct kvm_cpuid2 *guest_cpuid)
  26 {
  27         int i;
  28         u32 eax, ebx, ecx, edx;
  29
  30         for (i = 0; i < guest_cpuid->nent; i++) {
  31                 eax = guest_cpuid->entries[i].function;
  32                 ecx = guest_cpuid->entries[i].index;
  33
  34                 cpuid(&eax, &ebx, &ecx, &edx);
  35
  36                 GUEST_ASSERT(eax == guest_cpuid->entries[i].eax &&
  37                              ebx == guest_cpuid->entries[i].ebx &&
  38                              ecx == guest_cpuid->entries[i].ecx &&
  39                              edx == guest_cpuid->entries[i].edx);
  40         }
  41
  42 }
  43
  44 static void test_cpuid_40000000(struct kvm_cpuid2 *guest_cpuid)
  45 {
  46         u32 eax = 0x40000000, ebx, ecx = 0, edx;
  47
  48         cpuid(&eax, &ebx, &ecx, &edx);
  49
  50         GUEST_ASSERT(eax == 0x40000001);
  51 }
  52
  53 static void guest_main(struct kvm_cpuid2 *guest_cpuid)
  54 {
  55         GUEST_SYNC(1);
  56
  57         test_guest_cpuids(guest_cpuid);
  58
  59         GUEST_SYNC(2);
  60
  61         test_cpuid_40000000(guest_cpuid);
  62
  63         GUEST_DONE();
  64 }
  65
  66 static bool is_cpuid_mangled(struct kvm_cpuid_entry2 *entrie)
  67 {
  68         int i;
  69
  70         for (i = 0; i < sizeof(mangled_cpuids); i++) {
  71                 if (mangled_cpuids[i].function == entrie->function &&
  72                     mangled_cpuids[i].index == entrie->index)
  73                         return true;
  74         }
  75
  76         return false;
  77 }
  78
  79 static void check_cpuid(struct kvm_cpuid2 *cpuid, struct kvm_cpuid_entry2 *entrie)
  80 {
  81         int i;
  82
  83         for (i = 0; i < cpuid->nent; i++) {
  84                 if (cpuid->entries[i].function == entrie->function &&
  85                     cpuid->entries[i].index == entrie->index) {
  86                         if (is_cpuid_mangled(entrie))
  87                                 return;
  88
  89                         TEST_ASSERT(cpuid->entries[i].eax == entrie->eax &&
  90                                     cpuid->entries[i].ebx == entrie->ebx &&
  91                                     cpuid->entries[i].ecx == entrie->ecx &&
  92                                     cpuid->entries[i].edx == entrie->edx,
  93                                     "CPUID 0x%x.%x differ: 0x%x:0x%x:0x%x:0x%x vs 0x%x:0x%x:0x%x:0x%x",
  94                                     entrie->function, entrie->index,
  95                                     cpuid->entries[i].eax, cpuid->entries[i].ebx,
  96                                     cpuid->entries[i].ecx, cpuid->entries[i].edx,
  97                                     entrie->eax, entrie->ebx, entrie->ecx, entrie->edx);
  98                         return;
  99                 }
 100         }
 101
 102         TEST_ASSERT(false, "CPUID 0x%x.%x not found", entrie->function, entrie->index);
 103 }
 104
 105 static void compare_cpuids(struct kvm_cpuid2 *cpuid1, struct kvm_cpuid2 *cpuid2)
 106 {
 107         int i;
 108
 109         for (i = 0; i < cpuid1->nent; i++)
 110                 check_cpuid(cpuid2, &cpuid1->entries[i]);
 111
 112         for (i = 0; i < cpuid2->nent; i++)
 113                 check_cpuid(cpuid1, &cpuid2->entries[i]);
 114 }
 115
 116 static void run_vcpu(struct kvm_vm *vm, uint32_t vcpuid, int stage)
 117 {
 118         struct ucall uc;
 119
 120         _vcpu_run(vm, vcpuid);
 121
 122         switch (get_ucall(vm, vcpuid, &uc)) {
 123         case UCALL_SYNC:
 124                 TEST_ASSERT(!strcmp((const char *)uc.args[0], "hello") &&
 125                             uc.args[1] == stage + 1,
 126                             "Stage %d: Unexpected register values vmexit, got %lx",
 127                             stage + 1, (ulong)uc.args[1]);
 128                 return;
 129         case UCALL_DONE:
 130                 return;
 131         case UCALL_ABORT:
 132                 TEST_ASSERT(false, "%s at %s:%ld\n\tvalues: %#lx, %#lx", (const char *)uc.args[0],
 133                             __FILE__, uc.args[1], uc.args[2], uc.args[3]);
 134         default:
 135                 TEST_ASSERT(false, "Unexpected exit: %s",
 136                             exit_reason_str(vcpu_state(vm, vcpuid)->exit_reason));
 137         }
 138 }
 139
 140 struct kvm_cpuid2 *vcpu_alloc_cpuid(struct kvm_vm *vm, vm_vaddr_t *p_gva, struct kvm_cpuid2 *cpuid)
 141 {
 142         int size = sizeof(*cpuid) + cpuid->nent * sizeof(cpuid->entries[0]);
 143         vm_vaddr_t gva = vm_vaddr_alloc(vm, size,
 144                                         getpagesize(), 0, 0);
 145         struct kvm_cpuid2 *guest_cpuids = addr_gva2hva(vm, gva);
 146
 147         memcpy(guest_cpuids, cpuid, size);
 148
 149         *p_gva = gva;
 150         return guest_cpuids;
 151 }
 152
 153 int main(void)
 154 {
 155         struct kvm_cpuid2 *supp_cpuid, *cpuid2;
 156         vm_vaddr_t cpuid_gva;
 157         struct kvm_vm *vm;
 158         int stage;
 159
 160         vm = vm_create_default(VCPU_ID, 0, guest_main);
 161
 162         supp_cpuid = kvm_get_supported_cpuid();
 163         cpuid2 = vcpu_get_cpuid(vm, VCPU_ID);
 164
 165         compare_cpuids(supp_cpuid, cpuid2);
 166
 167         vcpu_alloc_cpuid(vm, &cpuid_gva, cpuid2);
 168
 169         vcpu_args_set(vm, VCPU_ID, 1, cpuid_gva);
 170
 171         for (stage = 0; stage < 3; stage++)
 172                 run_vcpu(vm, VCPU_ID, stage);
 173
 174         kvm_vm_free(vm);
 175 }