1
2
3
4
5
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
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(READ_ONCE(st->flags) == 0);
35 GUEST_ASSERT(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(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 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
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
85static 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
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
113struct st_time {
114 uint32_t rev;
115 uint32_t attr;
116 uint64_t st_time;
117};
118
119static 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
134static 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
140static 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
168static 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
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
206static 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
218static 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
234static 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
255int 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
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
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
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
290 for (i = 0; i < NR_VCPUS; ++i) {
291
292 run_vcpu(vm, i);
293
294
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
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
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
