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
23static void *st_gva[NR_VCPUS];
24static 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
31static void check_status(struct kvm_steal_time *st)
32{
33	GUEST_ASSERT(!(READ_ONCE(st->version) & 1));
34	GUEST_ASSERT_EQ(READ_ONCE(st->flags), 0);
35	GUEST_ASSERT_EQ(READ_ONCE(st->preempted), 0);
36}
37
38static void guest_code(int cpu)
39{
40	struct kvm_steal_time *st = st_gva[cpu];
41	uint32_t version;
42
43	GUEST_ASSERT_EQ(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
61static bool is_steal_time_supported(struct kvm_vcpu *vcpu)
62{
63	return kvm_cpu_has(X86_FEATURE_KVM_STEAL_TIME);
64}
65
66static 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
81static 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
109struct st_time {
110	uint32_t rev;
111	uint32_t attr;
112	uint64_t st_time;
113};
114
115static 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
123static void check_status(struct st_time *st)
124{
125	GUEST_ASSERT_EQ(READ_ONCE(st->rev), 0);
126	GUEST_ASSERT_EQ(READ_ONCE(st->attr), 0);
127}
128
129static 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_EQ(status, 0);
136	status = smccc(PV_TIME_FEATURES, PV_TIME_FEATURES);
137	GUEST_ASSERT_EQ(status, 0);
138	status = smccc(PV_TIME_FEATURES, PV_TIME_ST);
139	GUEST_ASSERT_EQ(status, 0);
140
141	status = smccc(PV_TIME_ST, 0);
142	GUEST_ASSERT_NE(status, -1);
143	GUEST_ASSERT_EQ(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
157static 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
167static 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
196static 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
208static 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
224static 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
242int 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