hc
2024-01-05 071106ecf68c401173c58808b1cf5f68cc50d390
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
// SPDX-License-Identifier: GPL-2.0
/*
 * CR4 and CPUID sync test
 *
 * Copyright 2018, Red Hat, Inc. and/or its affiliates.
 *
 * Author:
 *   Wei Huang <wei@redhat.com>
 */
 
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
 
#include "test_util.h"
 
#include "kvm_util.h"
#include "processor.h"
 
#define X86_FEATURE_XSAVE    (1<<26)
#define X86_FEATURE_OSXSAVE    (1<<27)
#define VCPU_ID            1
 
static inline bool cr4_cpuid_is_sync(void)
{
   int func, subfunc;
   uint32_t eax, ebx, ecx, edx;
   uint64_t cr4;
 
   func = 0x1;
   subfunc = 0x0;
   __asm__ __volatile__("cpuid"
                : "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
                : "a"(func), "c"(subfunc));
 
   cr4 = get_cr4();
 
   return (!!(ecx & X86_FEATURE_OSXSAVE)) == (!!(cr4 & X86_CR4_OSXSAVE));
}
 
static void guest_code(void)
{
   uint64_t cr4;
 
   /* turn on CR4.OSXSAVE */
   cr4 = get_cr4();
   cr4 |= X86_CR4_OSXSAVE;
   set_cr4(cr4);
 
   /* verify CR4.OSXSAVE == CPUID.OSXSAVE */
   GUEST_ASSERT(cr4_cpuid_is_sync());
 
   /* notify hypervisor to change CR4 */
   GUEST_SYNC(0);
 
   /* check again */
   GUEST_ASSERT(cr4_cpuid_is_sync());
 
   GUEST_DONE();
}
 
int main(int argc, char *argv[])
{
   struct kvm_run *run;
   struct kvm_vm *vm;
   struct kvm_sregs sregs;
   struct kvm_cpuid_entry2 *entry;
   struct ucall uc;
   int rc;
 
   entry = kvm_get_supported_cpuid_entry(1);
   if (!(entry->ecx & X86_FEATURE_XSAVE)) {
       print_skip("XSAVE feature not supported");
       return 0;
   }
 
   /* Tell stdout not to buffer its content */
   setbuf(stdout, NULL);
 
   /* Create VM */
   vm = vm_create_default(VCPU_ID, 0, guest_code);
   vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
   run = vcpu_state(vm, VCPU_ID);
 
   while (1) {
       rc = _vcpu_run(vm, VCPU_ID);
 
       TEST_ASSERT(rc == 0, "vcpu_run failed: %d\n", rc);
       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(vm, VCPU_ID, &uc)) {
       case UCALL_SYNC:
           /* emulate hypervisor clearing CR4.OSXSAVE */
           vcpu_sregs_get(vm, VCPU_ID, &sregs);
           sregs.cr4 &= ~X86_CR4_OSXSAVE;
           vcpu_sregs_set(vm, VCPU_ID, &sregs);
           break;
       case UCALL_ABORT:
           TEST_FAIL("Guest CR4 bit (OSXSAVE) unsynchronized with CPUID bit.");
           break;
       case UCALL_DONE:
           goto done;
       default:
           TEST_FAIL("Unknown ucall %lu", uc.cmd);
       }
   }
 
   kvm_vm_free(vm);
 
done:
   return 0;
}