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 #include <sched.h>
  17 #include <sys/syscall.h>
  18
  19 #define VCPU_ID         5
  20
  21 #define SHINFO_REGION_GVA       0xc0000000ULL
  22 #define SHINFO_REGION_GPA       0xc0000000ULL
  23 #define SHINFO_REGION_SLOT      10
  24 #define PAGE_SIZE               4096
  25
  26 #define PVTIME_ADDR     (SHINFO_REGION_GPA + PAGE_SIZE)
  27 #define RUNSTATE_ADDR   (SHINFO_REGION_GPA + PAGE_SIZE + 0x20)
  28
  29 #define RUNSTATE_VADDR  (SHINFO_REGION_GVA + PAGE_SIZE + 0x20)
  30
  31 static struct kvm_vm *vm;
  32
  33 #define XEN_HYPERCALL_MSR       0x40000000
  34
  35 #define MIN_STEAL_TIME          50000
  36
  37 struct pvclock_vcpu_time_info {
  38         u32   version;
  39         u32   pad0;
  40         u64   tsc_timestamp;
  41         u64   system_time;
  42         u32   tsc_to_system_mul;
  43         s8    tsc_shift;
  44         u8    flags;
  45         u8    pad[2];
  46 } __attribute__((__packed__)); /* 32 bytes */
  47
  48 struct pvclock_wall_clock {
  49         u32   version;
  50         u32   sec;
  51         u32   nsec;
  52 } __attribute__((__packed__));
  53
  54 struct vcpu_runstate_info {
  55     uint32_t state;
  56     uint64_t state_entry_time;
  57     uint64_t time[4];
  58 };
  59
  60 #define RUNSTATE_running  0
  61 #define RUNSTATE_runnable 1
  62 #define RUNSTATE_blocked  2
  63 #define RUNSTATE_offline  3
  64
  65 static void guest_code(void)
  66 {
  67         struct vcpu_runstate_info *rs = (void *)RUNSTATE_VADDR;
  68
  69         /* Test having the host set runstates manually */
  70         GUEST_SYNC(RUNSTATE_runnable);
  71         GUEST_ASSERT(rs->time[RUNSTATE_runnable] != 0);
  72         GUEST_ASSERT(rs->state == 0);
  73
  74         GUEST_SYNC(RUNSTATE_blocked);
  75         GUEST_ASSERT(rs->time[RUNSTATE_blocked] != 0);
  76         GUEST_ASSERT(rs->state == 0);
  77
  78         GUEST_SYNC(RUNSTATE_offline);
  79         GUEST_ASSERT(rs->time[RUNSTATE_offline] != 0);
  80         GUEST_ASSERT(rs->state == 0);
  81
  82         /* Test runstate time adjust */
  83         GUEST_SYNC(4);
  84         GUEST_ASSERT(rs->time[RUNSTATE_blocked] == 0x5a);
  85         GUEST_ASSERT(rs->time[RUNSTATE_offline] == 0x6b6b);
  86
  87         /* Test runstate time set */
  88         GUEST_SYNC(5);
  89         GUEST_ASSERT(rs->state_entry_time >= 0x8000);
  90         GUEST_ASSERT(rs->time[RUNSTATE_runnable] == 0);
  91         GUEST_ASSERT(rs->time[RUNSTATE_blocked] == 0x6b6b);
  92         GUEST_ASSERT(rs->time[RUNSTATE_offline] == 0x5a);
  93
  94         /* sched_yield() should result in some 'runnable' time */
  95         GUEST_SYNC(6);
  96         GUEST_ASSERT(rs->time[RUNSTATE_runnable] >= MIN_STEAL_TIME);
  97
  98         GUEST_DONE();
  99 }
 100
 101 static long get_run_delay(void)
 102 {
 103         char path[64];
 104         long val[2];
 105         FILE *fp;
 106
 107         sprintf(path, "/proc/%ld/schedstat", syscall(SYS_gettid));
 108         fp = fopen(path, "r");
 109         fscanf(fp, "%ld %ld ", &val[0], &val[1]);
 110         fclose(fp);
 111
 112         return val[1];
 113 }
 114
 115 static int cmp_timespec(struct timespec *a, struct timespec *b)
 116 {
 117         if (a->tv_sec > b->tv_sec)
 118                 return 1;
 119         else if (a->tv_sec < b->tv_sec)
 120                 return -1;
 121         else if (a->tv_nsec > b->tv_nsec)
 122                 return 1;
 123         else if (a->tv_nsec < b->tv_nsec)
 124                 return -1;
 125         else
 126                 return 0;
 127 }
 128
 129 int main(int argc, char *argv[])
 130 {
 131         struct timespec min_ts, max_ts, vm_ts;
 132
 133         int xen_caps = kvm_check_cap(KVM_CAP_XEN_HVM);
 134         if (!(xen_caps & KVM_XEN_HVM_CONFIG_SHARED_INFO) ) {
 135                 print_skip("KVM_XEN_HVM_CONFIG_SHARED_INFO not available");
 136                 exit(KSFT_SKIP);
 137         }
 138
 139         bool do_runstate_tests = !!(xen_caps & KVM_XEN_HVM_CONFIG_RUNSTATE);
 140
 141         clock_gettime(CLOCK_REALTIME, &min_ts);
 142
 143         vm = vm_create_default(VCPU_ID, 0, (void *) guest_code);
 144         vcpu_set_cpuid(vm, VCPU_ID, kvm_get_supported_cpuid());
 145
 146         /* Map a region for the shared_info page */
 147         vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
 148                                     SHINFO_REGION_GPA, SHINFO_REGION_SLOT, 2, 0);
 149         virt_map(vm, SHINFO_REGION_GVA, SHINFO_REGION_GPA, 2);
 150
 151         struct kvm_xen_hvm_config hvmc = {
 152                 .flags = KVM_XEN_HVM_CONFIG_INTERCEPT_HCALL,
 153                 .msr = XEN_HYPERCALL_MSR,
 154         };
 155         vm_ioctl(vm, KVM_XEN_HVM_CONFIG, &hvmc);
 156
 157         struct kvm_xen_hvm_attr lm = {
 158                 .type = KVM_XEN_ATTR_TYPE_LONG_MODE,
 159                 .u.long_mode = 1,
 160         };
 161         vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &lm);
 162
 163         struct kvm_xen_hvm_attr ha = {
 164                 .type = KVM_XEN_ATTR_TYPE_SHARED_INFO,
 165                 .u.shared_info.gfn = SHINFO_REGION_GPA / PAGE_SIZE,
 166         };
 167         vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &ha);
 168
 169         struct kvm_xen_vcpu_attr vi = {
 170                 .type = KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO,
 171                 .u.gpa = SHINFO_REGION_GPA + 0x40,
 172         };
 173         vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_SET_ATTR, &vi);
 174
 175         struct kvm_xen_vcpu_attr pvclock = {
 176                 .type = KVM_XEN_VCPU_ATTR_TYPE_VCPU_TIME_INFO,
 177                 .u.gpa = PVTIME_ADDR,
 178         };
 179         vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_SET_ATTR, &pvclock);
 180
 181         if (do_runstate_tests) {
 182                 struct kvm_xen_vcpu_attr st = {
 183                         .type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADDR,
 184                         .u.gpa = RUNSTATE_ADDR,
 185                 };
 186                 vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_SET_ATTR, &st);
 187         }
 188
 189         struct vcpu_runstate_info *rs = addr_gpa2hva(vm, RUNSTATE_ADDR);
 190         rs->state = 0x5a;
 191
 192         for (;;) {
 193                 volatile struct kvm_run *run = vcpu_state(vm, VCPU_ID);
 194                 struct ucall uc;
 195
 196                 vcpu_run(vm, VCPU_ID);
 197
 198                 TEST_ASSERT(run->exit_reason == KVM_EXIT_IO,
 199                             "Got exit_reason other than KVM_EXIT_IO: %u (%s)\n",
 200                             run->exit_reason,
 201                             exit_reason_str(run->exit_reason));
 202
 203                 switch (get_ucall(vm, VCPU_ID, &uc)) {
 204                 case UCALL_ABORT:
 205                         TEST_FAIL("%s", (const char *)uc.args[0]);
 206                         /* NOT REACHED */
 207                 case UCALL_SYNC: {
 208                         struct kvm_xen_vcpu_attr rst;
 209                         long rundelay;
 210
 211                         /* If no runstate support, bail out early */
 212                         if (!do_runstate_tests)
 213                                 goto done;
 214
 215                         TEST_ASSERT(rs->state_entry_time == rs->time[0] +
 216                                     rs->time[1] + rs->time[2] + rs->time[3],
 217                                     "runstate times don't add up");
 218
 219                         switch (uc.args[1]) {
 220                         case RUNSTATE_running...RUNSTATE_offline:
 221                                 rst.type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_CURRENT;
 222                                 rst.u.runstate.state = uc.args[1];
 223                                 vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_SET_ATTR, &rst);
 224                                 break;
 225                         case 4:
 226                                 rst.type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADJUST;
 227                                 memset(&rst.u, 0, sizeof(rst.u));
 228                                 rst.u.runstate.state = (uint64_t)-1;
 229                                 rst.u.runstate.time_blocked =
 230                                         0x5a - rs->time[RUNSTATE_blocked];
 231                                 rst.u.runstate.time_offline =
 232                                         0x6b6b - rs->time[RUNSTATE_offline];
 233                                 rst.u.runstate.time_runnable = -rst.u.runstate.time_blocked -
 234                                         rst.u.runstate.time_offline;
 235                                 vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_SET_ATTR, &rst);
 236                                 break;
 237
 238                         case 5:
 239                                 rst.type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_DATA;
 240                                 memset(&rst.u, 0, sizeof(rst.u));
 241                                 rst.u.runstate.state = RUNSTATE_running;
 242                                 rst.u.runstate.state_entry_time = 0x6b6b + 0x5a;
 243                                 rst.u.runstate.time_blocked = 0x6b6b;
 244                                 rst.u.runstate.time_offline = 0x5a;
 245                                 vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_SET_ATTR, &rst);
 246                                 break;
 247                         case 6:
 248                                 /* Yield until scheduler delay exceeds target */
 249                                 rundelay = get_run_delay() + MIN_STEAL_TIME;
 250                                 do {
 251                                         sched_yield();
 252                                 } while (get_run_delay() < rundelay);
 253                                 break;
 254                         }
 255                         break;
 256                 }
 257                 case UCALL_DONE:
 258                         goto done;
 259                 default:
 260                         TEST_FAIL("Unknown ucall 0x%lx.", uc.cmd);
 261                 }
 262         }
 263
 264  done:
 265         clock_gettime(CLOCK_REALTIME, &max_ts);
 266
 267         /*
 268          * Just a *really* basic check that things are being put in the
 269          * right place. The actual calculations are much the same for
 270          * Xen as they are for the KVM variants, so no need to check.
 271          */
 272         struct pvclock_wall_clock *wc;
 273         struct pvclock_vcpu_time_info *ti, *ti2;
 274
 275         wc = addr_gpa2hva(vm, SHINFO_REGION_GPA + 0xc00);
 276         ti = addr_gpa2hva(vm, SHINFO_REGION_GPA + 0x40 + 0x20);
 277         ti2 = addr_gpa2hva(vm, PVTIME_ADDR);
 278
 279         vm_ts.tv_sec = wc->sec;
 280         vm_ts.tv_nsec = wc->nsec;
 281         TEST_ASSERT(wc->version && !(wc->version & 1),
 282                     "Bad wallclock version %x", wc->version);
 283         TEST_ASSERT(cmp_timespec(&min_ts, &vm_ts) <= 0, "VM time too old");
 284         TEST_ASSERT(cmp_timespec(&max_ts, &vm_ts) >= 0, "VM time too new");
 285
 286         TEST_ASSERT(ti->version && !(ti->version & 1),
 287                     "Bad time_info version %x", ti->version);
 288         TEST_ASSERT(ti2->version && !(ti2->version & 1),
 289                     "Bad time_info version %x", ti->version);
 290
 291         if (do_runstate_tests) {
 292                 /*
 293                  * Fetch runstate and check sanity. Strictly speaking in the
 294                  * general case we might not expect the numbers to be identical
 295                  * but in this case we know we aren't running the vCPU any more.
 296                  */
 297                 struct kvm_xen_vcpu_attr rst = {
 298                         .type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_DATA,
 299                 };
 300                 vcpu_ioctl(vm, VCPU_ID, KVM_XEN_VCPU_GET_ATTR, &rst);
 301
 302                 TEST_ASSERT(rs->state == rst.u.runstate.state, "Runstate mismatch");
 303                 TEST_ASSERT(rs->state_entry_time == rst.u.runstate.state_entry_time,
 304                             "State entry time mismatch");
 305                 TEST_ASSERT(rs->time[RUNSTATE_running] == rst.u.runstate.time_running,
 306                             "Running time mismatch");
 307                 TEST_ASSERT(rs->time[RUNSTATE_runnable] == rst.u.runstate.time_runnable,
 308                             "Runnable time mismatch");
 309                 TEST_ASSERT(rs->time[RUNSTATE_blocked] == rst.u.runstate.time_blocked,
 310                             "Blocked time mismatch");
 311                 TEST_ASSERT(rs->time[RUNSTATE_offline] == rst.u.runstate.time_offline,
 312                             "Offline time mismatch");
 313
 314                 TEST_ASSERT(rs->state_entry_time == rs->time[0] +
 315                             rs->time[1] + rs->time[2] + rs->time[3],
 316                             "runstate times don't add up");
 317         }
 318         kvm_vm_free(vm);
 319         return 0;
 320 }