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, uint64_t arg)
120 {
121 	unsigned long ret;
122 
123 	asm volatile(
124 		"mov	w0, %w1\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 }
335