tools/testing/selftests/kvm/steal_time.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * steal/stolen time test
   4  *
   5  * Copyright (C) 2020, Red Hat, Inc.
   6  */
   7 #define _GNU_SOURCE
   8 #include <stdio.h>
   9 #include <time.h>
  10 #include <sched.h>
  11 #include <pthread.h>
  12 #include <linux/kernel.h>
  13 #include <asm/kvm.h>
  14 #include <asm/kvm_para.h>
  15
  16 #include "test_util.h"
  17 #include "kvm_util.h"
  18 #include "processor.h"
  19
  20 #define NR_VCPUS                4
  21 #define ST_GPA_BASE             (1 << 30)
  22
  23 static void *st_gva[NR_VCPUS];
  24 static uint64_t guest_stolen_time[NR_VCPUS];
  25
  26 #if defined(__x86_64__)
  27
  28 /* steal_time must have 64-byte alignment */
  29 #define STEAL_TIME_SIZE         ((sizeof(struct kvm_steal_time) + 63) & ~63)
  30
  31 static void check_status(struct kvm_steal_time *st)
  32 {
  33         GUEST_ASSERT(!(READ_ONCE(st->version) & 1));
  34         GUEST_ASSERT(READ_ONCE(st->flags) == 0);
  35         GUEST_ASSERT(READ_ONCE(st->preempted) == 0);
  36 }
  37
  38 static void guest_code(int cpu)
  39 {
  40         struct kvm_steal_time *st = st_gva[cpu];
  41         uint32_t version;
  42
  43         GUEST_ASSERT(rdmsr(MSR_KVM_STEAL_TIME) == ((uint64_t)st_gva[cpu] | KVM_MSR_ENABLED));
  44
  45         memset(st, 0, sizeof(*st));
  46         GUEST_SYNC(0);
  47
  48         check_status(st);
  49         WRITE_ONCE(guest_stolen_time[cpu], st->steal);
  50         version = READ_ONCE(st->version);
  51         check_status(st);
  52         GUEST_SYNC(1);
  53
  54         check_status(st);
  55         GUEST_ASSERT(version < READ_ONCE(st->version));
  56         WRITE_ONCE(guest_stolen_time[cpu], st->steal);
  57         check_status(st);
  58         GUEST_DONE();
  59 }
  60
  61 static void steal_time_init(struct kvm_vm *vm)
  62 {
  63         int i;
  64
  65         if (!(kvm_get_supported_cpuid_entry(KVM_CPUID_FEATURES)->eax &
  66               KVM_FEATURE_STEAL_TIME)) {
  67                 print_skip("steal-time not supported");
  68                 exit(KSFT_SKIP);
  69         }
  70
  71         for (i = 0; i < NR_VCPUS; ++i) {
  72                 int ret;
  73
  74                 /* ST_GPA_BASE is identity mapped */
  75                 st_gva[i] = (void *)(ST_GPA_BASE + i * STEAL_TIME_SIZE);
  76                 sync_global_to_guest(vm, st_gva[i]);
  77
  78                 ret = _vcpu_set_msr(vm, i, MSR_KVM_STEAL_TIME, (ulong)st_gva[i] | KVM_STEAL_RESERVED_MASK);
  79                 TEST_ASSERT(ret == 0, "Bad GPA didn't fail");
  80
  81                 vcpu_set_msr(vm, i, MSR_KVM_STEAL_TIME, (ulong)st_gva[i] | KVM_MSR_ENABLED);
  82         }
  83 }
  84
  85 static void steal_time_dump(struct kvm_vm *vm, uint32_t vcpuid)
  86 {
  87         struct kvm_steal_time *st = addr_gva2hva(vm, (ulong)st_gva[vcpuid]);
  88         int i;
  89
  90         pr_info("VCPU%d:\n", vcpuid);
  91         pr_info("    steal:     %lld\n", st->steal);
  92         pr_info("    version:   %d\n", st->version);
  93         pr_info("    flags:     %d\n", st->flags);
  94         pr_info("    preempted: %d\n", st->preempted);
  95         pr_info("    u8_pad:    ");
  96         for (i = 0; i < 3; ++i)
  97                 pr_info("%d", st->u8_pad[i]);
  98         pr_info("\n    pad:       ");
  99         for (i = 0; i < 11; ++i)
 100                 pr_info("%d", st->pad[i]);
 101         pr_info("\n");
 102 }
 103
 104 #elif defined(__aarch64__)
 105
 106 /* PV_TIME_ST must have 64-byte alignment */
 107 #define STEAL_TIME_SIZE         ((sizeof(struct st_time) + 63) & ~63)
 108
 109 #define SMCCC_ARCH_FEATURES     0x80000001
 110 #define PV_TIME_FEATURES        0xc5000020
 111 #define PV_TIME_ST              0xc5000021
 112
 113 struct st_time {
 114         uint32_t rev;
 115         uint32_t attr;
 116         uint64_t st_time;
 117 };
 118
 119 static int64_t smccc(uint32_t func, uint32_t arg)
 120 {
 121         unsigned long ret;
 122
 123         asm volatile(
 124                 "mov    x0, %1\n"
 125                 "mov    x1, %2\n"
 126                 "hvc    #0\n"
 127                 "mov    %0, x0\n"
 128         : "=r" (ret) : "r" (func), "r" (arg) :
 129           "x0", "x1", "x2", "x3");
 130
 131         return ret;
 132 }
 133
 134 static void check_status(struct st_time *st)
 135 {
 136         GUEST_ASSERT(READ_ONCE(st->rev) == 0);
 137         GUEST_ASSERT(READ_ONCE(st->attr) == 0);
 138 }
 139
 140 static void guest_code(int cpu)
 141 {
 142         struct st_time *st;
 143         int64_t status;
 144
 145         status = smccc(SMCCC_ARCH_FEATURES, PV_TIME_FEATURES);
 146         GUEST_ASSERT(status == 0);
 147         status = smccc(PV_TIME_FEATURES, PV_TIME_FEATURES);
 148         GUEST_ASSERT(status == 0);
 149         status = smccc(PV_TIME_FEATURES, PV_TIME_ST);
 150         GUEST_ASSERT(status == 0);
 151
 152         status = smccc(PV_TIME_ST, 0);
 153         GUEST_ASSERT(status != -1);
 154         GUEST_ASSERT(status == (ulong)st_gva[cpu]);
 155
 156         st = (struct st_time *)status;
 157         GUEST_SYNC(0);
 158
 159         check_status(st);
 160         WRITE_ONCE(guest_stolen_time[cpu], st->st_time);
 161         GUEST_SYNC(1);
 162
 163         check_status(st);
 164         WRITE_ONCE(guest_stolen_time[cpu], st->st_time);
 165         GUEST_DONE();
 166 }
 167
 168 static void steal_time_init(struct kvm_vm *vm)
 169 {
 170         struct kvm_device_attr dev = {
 171                 .group = KVM_ARM_VCPU_PVTIME_CTRL,
 172                 .attr = KVM_ARM_VCPU_PVTIME_IPA,
 173         };
 174         int i, ret;
 175
 176         ret = _vcpu_ioctl(vm, 0, KVM_HAS_DEVICE_ATTR, &dev);
 177         if (ret != 0 && errno == ENXIO) {
 178                 print_skip("steal-time not supported");
 179                 exit(KSFT_SKIP);
 180         }
 181
 182         for (i = 0; i < NR_VCPUS; ++i) {
 183                 uint64_t st_ipa;
 184
 185                 vcpu_ioctl(vm, i, KVM_HAS_DEVICE_ATTR, &dev);
 186
 187                 dev.addr = (uint64_t)&st_ipa;
 188
 189                 /* ST_GPA_BASE is identity mapped */
 190                 st_gva[i] = (void *)(ST_GPA_BASE + i * STEAL_TIME_SIZE);
 191                 sync_global_to_guest(vm, st_gva[i]);
 192
 193                 st_ipa = (ulong)st_gva[i] | 1;
 194                 ret = _vcpu_ioctl(vm, i, KVM_SET_DEVICE_ATTR, &dev);
 195                 TEST_ASSERT(ret == -1 && errno == EINVAL, "Bad IPA didn't report EINVAL");
 196
 197                 st_ipa = (ulong)st_gva[i];
 198                 vcpu_ioctl(vm, i, KVM_SET_DEVICE_ATTR, &dev);
 199
 200                 ret = _vcpu_ioctl(vm, i, KVM_SET_DEVICE_ATTR, &dev);
 201                 TEST_ASSERT(ret == -1 && errno == EEXIST, "Set IPA twice without EEXIST");
 202
 203         }
 204 }
 205
 206 static void steal_time_dump(struct kvm_vm *vm, uint32_t vcpuid)
 207 {
 208         struct st_time *st = addr_gva2hva(vm, (ulong)st_gva[vcpuid]);
 209
 210         pr_info("VCPU%d:\n", vcpuid);
 211         pr_info("    rev:     %d\n", st->rev);
 212         pr_info("    attr:    %d\n", st->attr);
 213         pr_info("    st_time: %ld\n", st->st_time);
 214 }
 215
 216 #endif
 217
 218 static void *do_steal_time(void *arg)
 219 {
 220         struct timespec ts, stop;
 221
 222         clock_gettime(CLOCK_MONOTONIC, &ts);
 223         stop = timespec_add_ns(ts, MIN_RUN_DELAY_NS);
 224
 225         while (1) {
 226                 clock_gettime(CLOCK_MONOTONIC, &ts);
 227                 if (timespec_to_ns(timespec_sub(ts, stop)) >= 0)
 228                         break;
 229         }
 230
 231         return NULL;
 232 }
 233
 234 static void run_vcpu(struct kvm_vm *vm, uint32_t vcpuid)
 235 {
 236         struct ucall uc;
 237
 238         vcpu_args_set(vm, vcpuid, 1, vcpuid);
 239
 240         vcpu_ioctl(vm, vcpuid, KVM_RUN, NULL);
 241
 242         switch (get_ucall(vm, vcpuid, &uc)) {
 243         case UCALL_SYNC:
 244         case UCALL_DONE:
 245                 break;
 246         case UCALL_ABORT:
 247                 TEST_ASSERT(false, "%s at %s:%ld", (const char *)uc.args[0],
 248                             __FILE__, uc.args[1]);
 249         default:
 250                 TEST_ASSERT(false, "Unexpected exit: %s",
 251                             exit_reason_str(vcpu_state(vm, vcpuid)->exit_reason));
 252         }
 253 }
 254
 255 int main(int ac, char **av)
 256 {
 257         struct kvm_vm *vm;
 258         pthread_attr_t attr;
 259         pthread_t thread;
 260         cpu_set_t cpuset;
 261         unsigned int gpages;
 262         long stolen_time;
 263         long run_delay;
 264         bool verbose;
 265         int i;
 266
 267         verbose = ac > 1 && (!strncmp(av[1], "-v", 3) || !strncmp(av[1], "--verbose", 10));
 268
 269         /* Set CPU affinity so we can force preemption of the VCPU */
 270         CPU_ZERO(&cpuset);
 271         CPU_SET(0, &cpuset);
 272         pthread_attr_init(&attr);
 273         pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset);
 274         pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
 275
 276         /* Create a one VCPU guest and an identity mapped memslot for the steal time structure */
 277         vm = vm_create_default(0, 0, guest_code);
 278         gpages = vm_calc_num_guest_pages(VM_MODE_DEFAULT, STEAL_TIME_SIZE * NR_VCPUS);
 279         vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, ST_GPA_BASE, 1, gpages, 0);
 280         virt_map(vm, ST_GPA_BASE, ST_GPA_BASE, gpages);
 281         ucall_init(vm, NULL);
 282
 283         /* Add the rest of the VCPUs */
 284         for (i = 1; i < NR_VCPUS; ++i)
 285                 vm_vcpu_add_default(vm, i, guest_code);
 286
 287         steal_time_init(vm);
 288
 289         /* Run test on each VCPU */
 290         for (i = 0; i < NR_VCPUS; ++i) {
 291                 /* First VCPU run initializes steal-time */
 292                 run_vcpu(vm, i);
 293
 294                 /* Second VCPU run, expect guest stolen time to be <= run_delay */
 295                 run_vcpu(vm, i);
 296                 sync_global_from_guest(vm, guest_stolen_time[i]);
 297                 stolen_time = guest_stolen_time[i];
 298                 run_delay = get_run_delay();
 299                 TEST_ASSERT(stolen_time <= run_delay,
 300                             "Expected stolen time <= %ld, got %ld",
 301                             run_delay, stolen_time);
 302
 303                 /* Steal time from the VCPU. The steal time thread has the same CPU affinity as the VCPUs. */
 304                 run_delay = get_run_delay();
 305                 pthread_create(&thread, &attr, do_steal_time, NULL);
 306                 do
 307                         sched_yield();
 308                 while (get_run_delay() - run_delay < MIN_RUN_DELAY_NS);
 309                 pthread_join(thread, NULL);
 310                 run_delay = get_run_delay() - run_delay;
 311                 TEST_ASSERT(run_delay >= MIN_RUN_DELAY_NS,
 312                             "Expected run_delay >= %ld, got %ld",
 313                             MIN_RUN_DELAY_NS, run_delay);
 314
 315                 /* Run VCPU again to confirm stolen time is consistent with run_delay */
 316                 run_vcpu(vm, i);
 317                 sync_global_from_guest(vm, guest_stolen_time[i]);
 318                 stolen_time = guest_stolen_time[i] - stolen_time;
 319                 TEST_ASSERT(stolen_time >= run_delay,
 320                             "Expected stolen time >= %ld, got %ld",
 321                             run_delay, stolen_time);
 322
 323                 if (verbose) {
 324                         pr_info("VCPU%d: total-stolen-time=%ld test-stolen-time=%ld", i,
 325                                 guest_stolen_time[i], stolen_time);
 326                         if (stolen_time == run_delay)
 327                                 pr_info(" (BONUS: guest test-stolen-time even exactly matches test-run_delay)");
 328                         pr_info("\n");
 329                         steal_time_dump(vm, i);
 330                 }
 331         }
 332
 333         return 0;
 334 }