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 bool is_steal_time_supported(struct kvm_vcpu *vcpu) 62 { 63 return kvm_cpu_has(X86_FEATURE_KVM_STEAL_TIME); 64 } 65 66 static void steal_time_init(struct kvm_vcpu *vcpu, uint32_t i) 67 { 68 int ret; 69 70 /* ST_GPA_BASE is identity mapped */ 71 st_gva[i] = (void *)(ST_GPA_BASE + i * STEAL_TIME_SIZE); 72 sync_global_to_guest(vcpu->vm, st_gva[i]); 73 74 ret = _vcpu_set_msr(vcpu, MSR_KVM_STEAL_TIME, 75 (ulong)st_gva[i] | KVM_STEAL_RESERVED_MASK); 76 TEST_ASSERT(ret == 0, "Bad GPA didn't fail"); 77 78 vcpu_set_msr(vcpu, MSR_KVM_STEAL_TIME, (ulong)st_gva[i] | KVM_MSR_ENABLED); 79 } 80 81 static void steal_time_dump(struct kvm_vm *vm, uint32_t vcpu_idx) 82 { 83 struct kvm_steal_time *st = addr_gva2hva(vm, (ulong)st_gva[vcpu_idx]); 84 int i; 85 86 pr_info("VCPU%d:\n", vcpu_idx); 87 pr_info(" steal: %lld\n", st->steal); 88 pr_info(" version: %d\n", st->version); 89 pr_info(" flags: %d\n", st->flags); 90 pr_info(" preempted: %d\n", st->preempted); 91 pr_info(" u8_pad: "); 92 for (i = 0; i < 3; ++i) 93 pr_info("%d", st->u8_pad[i]); 94 pr_info("\n pad: "); 95 for (i = 0; i < 11; ++i) 96 pr_info("%d", st->pad[i]); 97 pr_info("\n"); 98 } 99 100 #elif defined(__aarch64__) 101 102 /* PV_TIME_ST must have 64-byte alignment */ 103 #define STEAL_TIME_SIZE ((sizeof(struct st_time) + 63) & ~63) 104 105 #define SMCCC_ARCH_FEATURES 0x80000001 106 #define PV_TIME_FEATURES 0xc5000020 107 #define PV_TIME_ST 0xc5000021 108 109 struct st_time { 110 uint32_t rev; 111 uint32_t attr; 112 uint64_t st_time; 113 }; 114 115 static int64_t smccc(uint32_t func, uint64_t arg) 116 { 117 struct arm_smccc_res res; 118 119 smccc_hvc(func, arg, 0, 0, 0, 0, 0, 0, &res); 120 return res.a0; 121 } 122 123 static void check_status(struct st_time *st) 124 { 125 GUEST_ASSERT(READ_ONCE(st->rev) == 0); 126 GUEST_ASSERT(READ_ONCE(st->attr) == 0); 127 } 128 129 static void guest_code(int cpu) 130 { 131 struct st_time *st; 132 int64_t status; 133 134 status = smccc(SMCCC_ARCH_FEATURES, PV_TIME_FEATURES); 135 GUEST_ASSERT(status == 0); 136 status = smccc(PV_TIME_FEATURES, PV_TIME_FEATURES); 137 GUEST_ASSERT(status == 0); 138 status = smccc(PV_TIME_FEATURES, PV_TIME_ST); 139 GUEST_ASSERT(status == 0); 140 141 status = smccc(PV_TIME_ST, 0); 142 GUEST_ASSERT(status != -1); 143 GUEST_ASSERT(status == (ulong)st_gva[cpu]); 144 145 st = (struct st_time *)status; 146 GUEST_SYNC(0); 147 148 check_status(st); 149 WRITE_ONCE(guest_stolen_time[cpu], st->st_time); 150 GUEST_SYNC(1); 151 152 check_status(st); 153 WRITE_ONCE(guest_stolen_time[cpu], st->st_time); 154 GUEST_DONE(); 155 } 156 157 static bool is_steal_time_supported(struct kvm_vcpu *vcpu) 158 { 159 struct kvm_device_attr dev = { 160 .group = KVM_ARM_VCPU_PVTIME_CTRL, 161 .attr = KVM_ARM_VCPU_PVTIME_IPA, 162 }; 163 164 return !__vcpu_ioctl(vcpu, KVM_HAS_DEVICE_ATTR, &dev); 165 } 166 167 static void steal_time_init(struct kvm_vcpu *vcpu, uint32_t i) 168 { 169 struct kvm_vm *vm = vcpu->vm; 170 uint64_t st_ipa; 171 int ret; 172 173 struct kvm_device_attr dev = { 174 .group = KVM_ARM_VCPU_PVTIME_CTRL, 175 .attr = KVM_ARM_VCPU_PVTIME_IPA, 176 .addr = (uint64_t)&st_ipa, 177 }; 178 179 vcpu_ioctl(vcpu, KVM_HAS_DEVICE_ATTR, &dev); 180 181 /* ST_GPA_BASE is identity mapped */ 182 st_gva[i] = (void *)(ST_GPA_BASE + i * STEAL_TIME_SIZE); 183 sync_global_to_guest(vm, st_gva[i]); 184 185 st_ipa = (ulong)st_gva[i] | 1; 186 ret = __vcpu_ioctl(vcpu, KVM_SET_DEVICE_ATTR, &dev); 187 TEST_ASSERT(ret == -1 && errno == EINVAL, "Bad IPA didn't report EINVAL"); 188 189 st_ipa = (ulong)st_gva[i]; 190 vcpu_ioctl(vcpu, KVM_SET_DEVICE_ATTR, &dev); 191 192 ret = __vcpu_ioctl(vcpu, KVM_SET_DEVICE_ATTR, &dev); 193 TEST_ASSERT(ret == -1 && errno == EEXIST, "Set IPA twice without EEXIST"); 194 } 195 196 static void steal_time_dump(struct kvm_vm *vm, uint32_t vcpu_idx) 197 { 198 struct st_time *st = addr_gva2hva(vm, (ulong)st_gva[vcpu_idx]); 199 200 pr_info("VCPU%d:\n", vcpu_idx); 201 pr_info(" rev: %d\n", st->rev); 202 pr_info(" attr: %d\n", st->attr); 203 pr_info(" st_time: %ld\n", st->st_time); 204 } 205 206 #endif 207 208 static void *do_steal_time(void *arg) 209 { 210 struct timespec ts, stop; 211 212 clock_gettime(CLOCK_MONOTONIC, &ts); 213 stop = timespec_add_ns(ts, MIN_RUN_DELAY_NS); 214 215 while (1) { 216 clock_gettime(CLOCK_MONOTONIC, &ts); 217 if (timespec_to_ns(timespec_sub(ts, stop)) >= 0) 218 break; 219 } 220 221 return NULL; 222 } 223 224 static void run_vcpu(struct kvm_vcpu *vcpu) 225 { 226 struct ucall uc; 227 228 vcpu_run(vcpu); 229 230 switch (get_ucall(vcpu, &uc)) { 231 case UCALL_SYNC: 232 case UCALL_DONE: 233 break; 234 case UCALL_ABORT: 235 REPORT_GUEST_ASSERT(uc); 236 default: 237 TEST_ASSERT(false, "Unexpected exit: %s", 238 exit_reason_str(vcpu->run->exit_reason)); 239 } 240 } 241 242 int main(int ac, char **av) 243 { 244 struct kvm_vcpu *vcpus[NR_VCPUS]; 245 struct kvm_vm *vm; 246 pthread_attr_t attr; 247 pthread_t thread; 248 cpu_set_t cpuset; 249 unsigned int gpages; 250 long stolen_time; 251 long run_delay; 252 bool verbose; 253 int i; 254 255 verbose = ac > 1 && (!strncmp(av[1], "-v", 3) || !strncmp(av[1], "--verbose", 10)); 256 257 /* Set CPU affinity so we can force preemption of the VCPU */ 258 CPU_ZERO(&cpuset); 259 CPU_SET(0, &cpuset); 260 pthread_attr_init(&attr); 261 pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset); 262 pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset); 263 264 /* Create a VM and an identity mapped memslot for the steal time structure */ 265 vm = vm_create_with_vcpus(NR_VCPUS, guest_code, vcpus); 266 gpages = vm_calc_num_guest_pages(VM_MODE_DEFAULT, STEAL_TIME_SIZE * NR_VCPUS); 267 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, ST_GPA_BASE, 1, gpages, 0); 268 virt_map(vm, ST_GPA_BASE, ST_GPA_BASE, gpages); 269 270 TEST_REQUIRE(is_steal_time_supported(vcpus[0])); 271 272 /* Run test on each VCPU */ 273 for (i = 0; i < NR_VCPUS; ++i) { 274 steal_time_init(vcpus[i], i); 275 276 vcpu_args_set(vcpus[i], 1, i); 277 278 /* First VCPU run initializes steal-time */ 279 run_vcpu(vcpus[i]); 280 281 /* Second VCPU run, expect guest stolen time to be <= run_delay */ 282 run_vcpu(vcpus[i]); 283 sync_global_from_guest(vm, guest_stolen_time[i]); 284 stolen_time = guest_stolen_time[i]; 285 run_delay = get_run_delay(); 286 TEST_ASSERT(stolen_time <= run_delay, 287 "Expected stolen time <= %ld, got %ld", 288 run_delay, stolen_time); 289 290 /* Steal time from the VCPU. The steal time thread has the same CPU affinity as the VCPUs. */ 291 run_delay = get_run_delay(); 292 pthread_create(&thread, &attr, do_steal_time, NULL); 293 do 294 sched_yield(); 295 while (get_run_delay() - run_delay < MIN_RUN_DELAY_NS); 296 pthread_join(thread, NULL); 297 run_delay = get_run_delay() - run_delay; 298 TEST_ASSERT(run_delay >= MIN_RUN_DELAY_NS, 299 "Expected run_delay >= %ld, got %ld", 300 MIN_RUN_DELAY_NS, run_delay); 301 302 /* Run VCPU again to confirm stolen time is consistent with run_delay */ 303 run_vcpu(vcpus[i]); 304 sync_global_from_guest(vm, guest_stolen_time[i]); 305 stolen_time = guest_stolen_time[i] - stolen_time; 306 TEST_ASSERT(stolen_time >= run_delay, 307 "Expected stolen time >= %ld, got %ld", 308 run_delay, stolen_time); 309 310 if (verbose) { 311 pr_info("VCPU%d: total-stolen-time=%ld test-stolen-time=%ld", i, 312 guest_stolen_time[i], stolen_time); 313 if (stolen_time == run_delay) 314 pr_info(" (BONUS: guest test-stolen-time even exactly matches test-run_delay)"); 315 pr_info("\n"); 316 steal_time_dump(vm, i); 317 } 318 } 319 320 return 0; 321 } 322