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#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
 27static void *st_gva[NR_VCPUS];
 28static 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
 35static 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
 42static 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
 65static bool is_steal_time_supported(struct kvm_vcpu *vcpu)
 66{
 67	return kvm_cpu_has(X86_FEATURE_KVM_STEAL_TIME);
 68}
 69
 70static 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
 85static 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
111struct st_time {
112	uint32_t rev;
113	uint32_t attr;
114	uint64_t st_time;
115};
116
117static int64_t smccc(uint32_t func, uint64_t arg)
118{
119	struct arm_smccc_res res;
120
121	do_smccc(func, arg, 0, 0, 0, 0, 0, 0, &res);
122	return res.a0;
123}
124
125static 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
131static 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
159static 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
169static 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
198static 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
213static vm_paddr_t st_gpa[NR_VCPUS];
214
215struct 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
223static 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
236static 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
243static 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
269static 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
279static 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
288static 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
306static 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
322static 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
340int 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}