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

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * svm_vmcall_test
   4  *
   5  * Copyright © 2021 Amazon.com, Inc. or its affiliates.
   6  *
   7  * Xen shared_info / pvclock testing
   8  */
   9
  10 #include "test_util.h"
  11 #include "kvm_util.h"
  12 #include "processor.h"
  13
  14 #include <stdint.h>
  15 #include <time.h>
  16
  17 #define VCPU_ID         5
  18
  19 #define SHINFO_REGION_GPA       0xc0000000ULL
  20 #define SHINFO_REGION_SLOT      10
  21 #define PAGE_SIZE               4096
  22
  23 #define PVTIME_ADDR     (SHINFO_REGION_GPA + PAGE_SIZE)
  24
  25 static struct kvm_vm *vm;
  26
  27 #define XEN_HYPERCALL_MSR       0x40000000
  28
  29 struct pvclock_vcpu_time_info {
  30         u32   version;
  31         u32   pad0;
  32         u64   tsc_timestamp;
  33         u64   system_time;
  34         u32   tsc_to_system_mul;
  35         s8    tsc_shift;
  36         u8    flags;
  37         u8    pad[2];
  38 } __attribute__((__packed__)); /* 32 bytes */
  39
  40 struct pvclock_wall_clock {
  41         u32   version;
  42         u32   sec;
  43         u32   nsec;
  44 } __attribute__((__packed__));
  45
  46 static void guest_code(void)
  47 {
  48         GUEST_DONE();
  49 }
  50
  51 static int cmp_timespec(struct timespec *a, struct timespec *b)
  52 {
  53         if (a->tv_sec > b->tv_sec)
  54                 return 1;
  55         else if (a->tv_sec < b->tv_sec)
  56                 return -1;
  57         else if (a->tv_nsec > b->tv_nsec)
  58                 return 1;
  59         else if (a->tv_nsec < b->tv_nsec)
  60                 return -1;
  61         else
  62                 return 0;
  63 }
  64
  65 int main(int argc, char *argv[])
  66 {
  67         struct timespec min_ts, max_ts, vm_ts;
  68
  69         if (!(kvm_check_cap(KVM_CAP_XEN_HVM) &
  70               KVM_XEN_HVM_CONFIG_SHARED_INFO) ) {
  71                 print_skip("KVM_XEN_HVM_CONFIG_SHARED_INFO not available");
  72                 exit(KSFT_SKIP);
  73         }
  74
  75         clock_gettime(CLOCK_REALTIME, &min_ts);
  76
  77         vm = vm_create_default(VCPU_ID, 0, (void *) guest_code);
  78         vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
  79
  80         /* Map a region for the shared_info page */
  81         vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
  82                                     SHINFO_REGION_GPA, SHINFO_REGION_SLOT,
  83                                     2 * getpagesize(), 0);
  84         virt_map(vm, SHINFO_REGION_GPA, SHINFO_REGION_GPA, 2, 0);
  85
  86         struct kvm_xen_hvm_config hvmc = {
  87                 .flags = KVM_XEN_HVM_CONFIG_INTERCEPT_HCALL,
  88                 .msr = XEN_HYPERCALL_MSR,
  89         };
  90         vm_ioctl(vm, KVM_XEN_HVM_CONFIG, &hvmc);
  91
  92         struct kvm_xen_hvm_attr lm = {
  93                 .type = KVM_XEN_ATTR_TYPE_LONG_MODE,
  94                 .u.long_mode = 1,
  95         };
  96         vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &lm);
  97
  98         struct kvm_xen_hvm_attr ha = {
  99                 .type = KVM_XEN_ATTR_TYPE_SHARED_INFO,
 100                 .u.shared_info.gfn = SHINFO_REGION_GPA / PAGE_SIZE,
 101         };
 102         vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &ha);
 103
 104         struct kvm_xen_vcpu_attr vi = {
 105                 .type = KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO,
 106                 .u.gpa = SHINFO_REGION_GPA + 40,
 107         };
 108         vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_SET_ATTR, &vi);
 109
 110         struct kvm_xen_vcpu_attr pvclock = {
 111                 .type = KVM_XEN_VCPU_ATTR_TYPE_VCPU_TIME_INFO,
 112                 .u.gpa = PVTIME_ADDR,
 113         };
 114         vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_SET_ATTR, &pvclock);
 115
 116         for (;;) {
 117                 volatile struct kvm_run *run = vcpu_state(vm, VCPU_ID);
 118                 struct ucall uc;
 119
 120                 vcpu_run(vm, VCPU_ID);
 121
 122                 TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
 123                             "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
 124                             run->exit_reason,
 125                             exit_reason_str(run->exit_reason));
 126
 127                 switch (get_ucall(vm, VCPU_ID, &uc)) {
 128                 case UCALL_ABORT:
 129                         TEST_FAIL("%s", (const char *)uc.args[0]);
 130                         /* NOT REACHED */
 131                 case UCALL_SYNC:
 132                         break;
 133                 case UCALL_DONE:
 134                         goto done;
 135                 default:
 136                         TEST_FAIL("Unknown ucall 0x%lx.", uc.cmd);
 137                 }
 138         }
 139
 140  done:
 141         clock_gettime(CLOCK_REALTIME, &max_ts);
 142
 143         /*
 144          * Just a *really* basic check that things are being put in the
 145          * right place. The actual calculations are much the same for
 146          * Xen as they are for the KVM variants, so no need to check.
 147          */
 148         struct pvclock_wall_clock *wc;
 149         struct pvclock_vcpu_time_info *ti, *ti2;
 150
 151         wc = addr_gva2hva(vm, SHINFO_REGION_GPA + 0xc00);
 152         ti = addr_gva2hva(vm, SHINFO_REGION_GPA + 0x40 + 0x20);
 153         ti2 = addr_gva2hva(vm, PVTIME_ADDR);
 154
 155         vm_ts.tv_sec = wc->sec;
 156         vm_ts.tv_nsec = wc->nsec;
 157         TEST_ASSERT(wc->version && !(wc->version & 1),
 158                     "Bad wallclock version %x", wc->version);
 159         TEST_ASSERT(cmp_timespec(&min_ts, &vm_ts) <= 0, "VM time too old");
 160         TEST_ASSERT(cmp_timespec(&max_ts, &vm_ts) >= 0, "VM time too new");
 161
 162         TEST_ASSERT(ti->version && !(ti->version & 1),
 163                     "Bad time_info version %x", ti->version);
 164         TEST_ASSERT(ti2->version && !(ti2->version & 1),
 165                     "Bad time_info version %x", ti->version);
 166
 167         kvm_vm_free(vm);
 168         return 0;
 169 }