1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * steal/stolen time test
4 *
5 * Copyright (C) 2020, Red Hat, Inc.
6 */
7 #include <stdio.h>
8 #include <time.h>
9 #include <sched.h>
10 #include <pthread.h>
11 #include <linux/kernel.h>
12 #include <asm/kvm.h>
13 #ifdef __riscv
14 #include "sbi.h"
15 #else
16 #include <asm/kvm_para.h>
17 #endif
18
19 #include "test_util.h"
20 #include "kvm_util.h"
21 #include "processor.h"
22 #include "ucall_common.h"
23
24 #define NR_VCPUS 4
25 #define ST_GPA_BASE (1 << 30)
26
27 static void *st_gva[NR_VCPUS];
28 static uint64_t guest_stolen_time[NR_VCPUS];
29
30 #if defined(__x86_64__)
31
32 /* steal_time must have 64-byte alignment */
33 #define STEAL_TIME_SIZE ((sizeof(struct kvm_steal_time) + 63) & ~63)
34
check_status(struct kvm_steal_time * st)35 static void check_status(struct kvm_steal_time *st)
36 {
37 GUEST_ASSERT(!(READ_ONCE(st->version) & 1));
38 GUEST_ASSERT_EQ(READ_ONCE(st->flags), 0);
39 GUEST_ASSERT_EQ(READ_ONCE(st->preempted), 0);
40 }
41
guest_code(int cpu)42 static void guest_code(int cpu)
43 {
44 struct kvm_steal_time *st = st_gva[cpu];
45 uint32_t version;
46
47 GUEST_ASSERT_EQ(rdmsr(MSR_KVM_STEAL_TIME), ((uint64_t)st_gva[cpu] | KVM_MSR_ENABLED));
48
49 memset(st, 0, sizeof(*st));
50 GUEST_SYNC(0);
51
52 check_status(st);
53 WRITE_ONCE(guest_stolen_time[cpu], st->steal);
54 version = READ_ONCE(st->version);
55 check_status(st);
56 GUEST_SYNC(1);
57
58 check_status(st);
59 GUEST_ASSERT(version < READ_ONCE(st->version));
60 WRITE_ONCE(guest_stolen_time[cpu], st->steal);
61 check_status(st);
62 GUEST_DONE();
63 }
64
is_steal_time_supported(struct kvm_vcpu * vcpu)65 static bool is_steal_time_supported(struct kvm_vcpu *vcpu)
66 {
67 return kvm_cpu_has(X86_FEATURE_KVM_STEAL_TIME);
68 }
69
steal_time_init(struct kvm_vcpu * vcpu,uint32_t i)70 static void steal_time_init(struct kvm_vcpu *vcpu, uint32_t i)
71 {
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(vcpu->vm, st_gva[i]);
77
78 ret = _vcpu_set_msr(vcpu, MSR_KVM_STEAL_TIME,
79 (ulong)st_gva[i] | KVM_STEAL_RESERVED_MASK);
80 TEST_ASSERT(ret == 0, "Bad GPA didn't fail");
81
82 vcpu_set_msr(vcpu, MSR_KVM_STEAL_TIME, (ulong)st_gva[i] | KVM_MSR_ENABLED);
83 }
84
steal_time_dump(struct kvm_vm * vm,uint32_t vcpu_idx)85 static void steal_time_dump(struct kvm_vm *vm, uint32_t vcpu_idx)
86 {
87 struct kvm_steal_time *st = addr_gva2hva(vm, (ulong)st_gva[vcpu_idx]);
88
89 ksft_print_msg("VCPU%d:\n", vcpu_idx);
90 ksft_print_msg(" steal: %lld\n", st->steal);
91 ksft_print_msg(" version: %d\n", st->version);
92 ksft_print_msg(" flags: %d\n", st->flags);
93 ksft_print_msg(" preempted: %d\n", st->preempted);
94 ksft_print_msg(" u8_pad: %d %d %d\n",
95 st->u8_pad[0], st->u8_pad[1], st->u8_pad[2]);
96 ksft_print_msg(" pad: %d %d %d %d %d %d %d %d %d %d %d\n",
97 st->pad[0], st->pad[1], st->pad[2], st->pad[3],
98 st->pad[4], st->pad[5], st->pad[6], st->pad[7],
99 st->pad[8], st->pad[9], st->pad[10]);
100 }
101
102 #elif defined(__aarch64__)
103
104 /* PV_TIME_ST must have 64-byte alignment */
105 #define STEAL_TIME_SIZE ((sizeof(struct st_time) + 63) & ~63)
106
107 #define SMCCC_ARCH_FEATURES 0x80000001
108 #define PV_TIME_FEATURES 0xc5000020
109 #define PV_TIME_ST 0xc5000021
110
111 struct st_time {
112 uint32_t rev;
113 uint32_t attr;
114 uint64_t st_time;
115 };
116
smccc(uint32_t func,uint64_t arg)117 static int64_t smccc(uint32_t func, uint64_t arg)
118 {
119 struct arm_smccc_res res;
120
121 smccc_hvc(func, arg, 0, 0, 0, 0, 0, 0, &res);
122 return res.a0;
123 }
124
check_status(struct st_time * st)125 static void check_status(struct st_time *st)
126 {
127 GUEST_ASSERT_EQ(READ_ONCE(st->rev), 0);
128 GUEST_ASSERT_EQ(READ_ONCE(st->attr), 0);
129 }
130
guest_code(int cpu)131 static void guest_code(int cpu)
132 {
133 struct st_time *st;
134 int64_t status;
135
136 status = smccc(SMCCC_ARCH_FEATURES, PV_TIME_FEATURES);
137 GUEST_ASSERT_EQ(status, 0);
138 status = smccc(PV_TIME_FEATURES, PV_TIME_FEATURES);
139 GUEST_ASSERT_EQ(status, 0);
140 status = smccc(PV_TIME_FEATURES, PV_TIME_ST);
141 GUEST_ASSERT_EQ(status, 0);
142
143 status = smccc(PV_TIME_ST, 0);
144 GUEST_ASSERT_NE(status, -1);
145 GUEST_ASSERT_EQ(status, (ulong)st_gva[cpu]);
146
147 st = (struct st_time *)status;
148 GUEST_SYNC(0);
149
150 check_status(st);
151 WRITE_ONCE(guest_stolen_time[cpu], st->st_time);
152 GUEST_SYNC(1);
153
154 check_status(st);
155 WRITE_ONCE(guest_stolen_time[cpu], st->st_time);
156 GUEST_DONE();
157 }
158
is_steal_time_supported(struct kvm_vcpu * vcpu)159 static bool is_steal_time_supported(struct kvm_vcpu *vcpu)
160 {
161 struct kvm_device_attr dev = {
162 .group = KVM_ARM_VCPU_PVTIME_CTRL,
163 .attr = KVM_ARM_VCPU_PVTIME_IPA,
164 };
165
166 return !__vcpu_ioctl(vcpu, KVM_HAS_DEVICE_ATTR, &dev);
167 }
168
steal_time_init(struct kvm_vcpu * vcpu,uint32_t i)169 static void steal_time_init(struct kvm_vcpu *vcpu, uint32_t i)
170 {
171 struct kvm_vm *vm = vcpu->vm;
172 uint64_t st_ipa;
173 int ret;
174
175 struct kvm_device_attr dev = {
176 .group = KVM_ARM_VCPU_PVTIME_CTRL,
177 .attr = KVM_ARM_VCPU_PVTIME_IPA,
178 .addr = (uint64_t)&st_ipa,
179 };
180
181 vcpu_ioctl(vcpu, KVM_HAS_DEVICE_ATTR, &dev);
182
183 /* ST_GPA_BASE is identity mapped */
184 st_gva[i] = (void *)(ST_GPA_BASE + i * STEAL_TIME_SIZE);
185 sync_global_to_guest(vm, st_gva[i]);
186
187 st_ipa = (ulong)st_gva[i] | 1;
188 ret = __vcpu_ioctl(vcpu, KVM_SET_DEVICE_ATTR, &dev);
189 TEST_ASSERT(ret == -1 && errno == EINVAL, "Bad IPA didn't report EINVAL");
190
191 st_ipa = (ulong)st_gva[i];
192 vcpu_ioctl(vcpu, KVM_SET_DEVICE_ATTR, &dev);
193
194 ret = __vcpu_ioctl(vcpu, KVM_SET_DEVICE_ATTR, &dev);
195 TEST_ASSERT(ret == -1 && errno == EEXIST, "Set IPA twice without EEXIST");
196 }
197
steal_time_dump(struct kvm_vm * vm,uint32_t vcpu_idx)198 static void steal_time_dump(struct kvm_vm *vm, uint32_t vcpu_idx)
199 {
200 struct st_time *st = addr_gva2hva(vm, (ulong)st_gva[vcpu_idx]);
201
202 ksft_print_msg("VCPU%d:\n", vcpu_idx);
203 ksft_print_msg(" rev: %d\n", st->rev);
204 ksft_print_msg(" attr: %d\n", st->attr);
205 ksft_print_msg(" st_time: %ld\n", st->st_time);
206 }
207
208 #elif defined(__riscv)
209
210 /* SBI STA shmem must have 64-byte alignment */
211 #define STEAL_TIME_SIZE ((sizeof(struct sta_struct) + 63) & ~63)
212
213 static vm_paddr_t st_gpa[NR_VCPUS];
214
215 struct sta_struct {
216 uint32_t sequence;
217 uint32_t flags;
218 uint64_t steal;
219 uint8_t preempted;
220 uint8_t pad[47];
221 } __packed;
222
sta_set_shmem(vm_paddr_t gpa,unsigned long flags)223 static void sta_set_shmem(vm_paddr_t gpa, unsigned long flags)
224 {
225 unsigned long lo = (unsigned long)gpa;
226 #if __riscv_xlen == 32
227 unsigned long hi = (unsigned long)(gpa >> 32);
228 #else
229 unsigned long hi = gpa == -1 ? -1 : 0;
230 #endif
231 struct sbiret ret = sbi_ecall(SBI_EXT_STA, 0, lo, hi, flags, 0, 0, 0);
232
233 GUEST_ASSERT(ret.value == 0 && ret.error == 0);
234 }
235
check_status(struct sta_struct * st)236 static void check_status(struct sta_struct *st)
237 {
238 GUEST_ASSERT(!(READ_ONCE(st->sequence) & 1));
239 GUEST_ASSERT(READ_ONCE(st->flags) == 0);
240 GUEST_ASSERT(READ_ONCE(st->preempted) == 0);
241 }
242
guest_code(int cpu)243 static void guest_code(int cpu)
244 {
245 struct sta_struct *st = st_gva[cpu];
246 uint32_t sequence;
247 long out_val = 0;
248 bool probe;
249
250 probe = guest_sbi_probe_extension(SBI_EXT_STA, &out_val);
251 GUEST_ASSERT(probe && out_val == 1);
252
253 sta_set_shmem(st_gpa[cpu], 0);
254 GUEST_SYNC(0);
255
256 check_status(st);
257 WRITE_ONCE(guest_stolen_time[cpu], st->steal);
258 sequence = READ_ONCE(st->sequence);
259 check_status(st);
260 GUEST_SYNC(1);
261
262 check_status(st);
263 GUEST_ASSERT(sequence < READ_ONCE(st->sequence));
264 WRITE_ONCE(guest_stolen_time[cpu], st->steal);
265 check_status(st);
266 GUEST_DONE();
267 }
268
is_steal_time_supported(struct kvm_vcpu * vcpu)269 static bool is_steal_time_supported(struct kvm_vcpu *vcpu)
270 {
271 uint64_t id = RISCV_SBI_EXT_REG(KVM_RISCV_SBI_EXT_STA);
272 unsigned long enabled = vcpu_get_reg(vcpu, id);
273
274 TEST_ASSERT(enabled == 0 || enabled == 1, "Expected boolean result");
275
276 return enabled;
277 }
278
steal_time_init(struct kvm_vcpu * vcpu,uint32_t i)279 static void steal_time_init(struct kvm_vcpu *vcpu, uint32_t i)
280 {
281 /* ST_GPA_BASE is identity mapped */
282 st_gva[i] = (void *)(ST_GPA_BASE + i * STEAL_TIME_SIZE);
283 st_gpa[i] = addr_gva2gpa(vcpu->vm, (vm_vaddr_t)st_gva[i]);
284 sync_global_to_guest(vcpu->vm, st_gva[i]);
285 sync_global_to_guest(vcpu->vm, st_gpa[i]);
286 }
287
steal_time_dump(struct kvm_vm * vm,uint32_t vcpu_idx)288 static void steal_time_dump(struct kvm_vm *vm, uint32_t vcpu_idx)
289 {
290 struct sta_struct *st = addr_gva2hva(vm, (ulong)st_gva[vcpu_idx]);
291 int i;
292
293 pr_info("VCPU%d:\n", vcpu_idx);
294 pr_info(" sequence: %d\n", st->sequence);
295 pr_info(" flags: %d\n", st->flags);
296 pr_info(" steal: %"PRIu64"\n", st->steal);
297 pr_info(" preempted: %d\n", st->preempted);
298 pr_info(" pad: ");
299 for (i = 0; i < 47; ++i)
300 pr_info("%d", st->pad[i]);
301 pr_info("\n");
302 }
303
304 #endif
305
do_steal_time(void * arg)306 static void *do_steal_time(void *arg)
307 {
308 struct timespec ts, stop;
309
310 clock_gettime(CLOCK_MONOTONIC, &ts);
311 stop = timespec_add_ns(ts, MIN_RUN_DELAY_NS);
312
313 while (1) {
314 clock_gettime(CLOCK_MONOTONIC, &ts);
315 if (timespec_to_ns(timespec_sub(ts, stop)) >= 0)
316 break;
317 }
318
319 return NULL;
320 }
321
run_vcpu(struct kvm_vcpu * vcpu)322 static void run_vcpu(struct kvm_vcpu *vcpu)
323 {
324 struct ucall uc;
325
326 vcpu_run(vcpu);
327
328 switch (get_ucall(vcpu, &uc)) {
329 case UCALL_SYNC:
330 case UCALL_DONE:
331 break;
332 case UCALL_ABORT:
333 REPORT_GUEST_ASSERT(uc);
334 default:
335 TEST_ASSERT(false, "Unexpected exit: %s",
336 exit_reason_str(vcpu->run->exit_reason));
337 }
338 }
339
main(int ac,char ** av)340 int main(int ac, char **av)
341 {
342 struct kvm_vcpu *vcpus[NR_VCPUS];
343 struct kvm_vm *vm;
344 pthread_attr_t attr;
345 pthread_t thread;
346 cpu_set_t cpuset;
347 unsigned int gpages;
348 long stolen_time;
349 long run_delay;
350 bool verbose;
351 int i;
352
353 verbose = ac > 1 && (!strncmp(av[1], "-v", 3) || !strncmp(av[1], "--verbose", 10));
354
355 /* Set CPU affinity so we can force preemption of the VCPU */
356 CPU_ZERO(&cpuset);
357 CPU_SET(0, &cpuset);
358 pthread_attr_init(&attr);
359 pthread_attr_setaffinity_np(&attr, sizeof(cpu_set_t), &cpuset);
360 pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &cpuset);
361
362 /* Create a VM and an identity mapped memslot for the steal time structure */
363 vm = vm_create_with_vcpus(NR_VCPUS, guest_code, vcpus);
364 gpages = vm_calc_num_guest_pages(VM_MODE_DEFAULT, STEAL_TIME_SIZE * NR_VCPUS);
365 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS, ST_GPA_BASE, 1, gpages, 0);
366 virt_map(vm, ST_GPA_BASE, ST_GPA_BASE, gpages);
367
368 ksft_print_header();
369 TEST_REQUIRE(is_steal_time_supported(vcpus[0]));
370 ksft_set_plan(NR_VCPUS);
371
372 /* Run test on each VCPU */
373 for (i = 0; i < NR_VCPUS; ++i) {
374 steal_time_init(vcpus[i], i);
375
376 vcpu_args_set(vcpus[i], 1, i);
377
378 /* First VCPU run initializes steal-time */
379 run_vcpu(vcpus[i]);
380
381 /* Second VCPU run, expect guest stolen time to be <= run_delay */
382 run_vcpu(vcpus[i]);
383 sync_global_from_guest(vm, guest_stolen_time[i]);
384 stolen_time = guest_stolen_time[i];
385 run_delay = get_run_delay();
386 TEST_ASSERT(stolen_time <= run_delay,
387 "Expected stolen time <= %ld, got %ld",
388 run_delay, stolen_time);
389
390 /* Steal time from the VCPU. The steal time thread has the same CPU affinity as the VCPUs. */
391 run_delay = get_run_delay();
392 pthread_create(&thread, &attr, do_steal_time, NULL);
393 do
394 sched_yield();
395 while (get_run_delay() - run_delay < MIN_RUN_DELAY_NS);
396 pthread_join(thread, NULL);
397 run_delay = get_run_delay() - run_delay;
398 TEST_ASSERT(run_delay >= MIN_RUN_DELAY_NS,
399 "Expected run_delay >= %ld, got %ld",
400 MIN_RUN_DELAY_NS, run_delay);
401
402 /* Run VCPU again to confirm stolen time is consistent with run_delay */
403 run_vcpu(vcpus[i]);
404 sync_global_from_guest(vm, guest_stolen_time[i]);
405 stolen_time = guest_stolen_time[i] - stolen_time;
406 TEST_ASSERT(stolen_time >= run_delay,
407 "Expected stolen time >= %ld, got %ld",
408 run_delay, stolen_time);
409
410 if (verbose) {
411 ksft_print_msg("VCPU%d: total-stolen-time=%ld test-stolen-time=%ld%s\n",
412 i, guest_stolen_time[i], stolen_time,
413 stolen_time == run_delay ?
414 " (BONUS: guest test-stolen-time even exactly matches test-run_delay)" : "");
415 steal_time_dump(vm, i);
416 }
417 ksft_test_result_pass("vcpu%d\n", i);
418 }
419
420 /* Print results and exit() accordingly */
421 ksft_finished();
422 }
423