Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright © 2021 Amazon.com, Inc. or its affiliates.
4 */
5
6#include "test_util.h"
7#include "kvm_util.h"
8#include "processor.h"
9
10#include <stdint.h>
11#include <time.h>
12#include <sched.h>
13#include <signal.h>
14#include <pthread.h>
15
16#include <sys/eventfd.h>
17
18#define SHINFO_REGION_GVA 0xc0000000ULL
19#define SHINFO_REGION_GPA 0xc0000000ULL
20#define SHINFO_REGION_SLOT 10
21
22#define DUMMY_REGION_GPA (SHINFO_REGION_GPA + (3 * PAGE_SIZE))
23#define DUMMY_REGION_SLOT 11
24
25#define DUMMY_REGION_GPA_2 (SHINFO_REGION_GPA + (4 * PAGE_SIZE))
26#define DUMMY_REGION_SLOT_2 12
27
28#define SHINFO_ADDR (SHINFO_REGION_GPA)
29#define VCPU_INFO_ADDR (SHINFO_REGION_GPA + 0x40)
30#define PVTIME_ADDR (SHINFO_REGION_GPA + PAGE_SIZE)
31#define RUNSTATE_ADDR (SHINFO_REGION_GPA + PAGE_SIZE + PAGE_SIZE - 15)
32
33#define SHINFO_VADDR (SHINFO_REGION_GVA)
34#define VCPU_INFO_VADDR (SHINFO_REGION_GVA + 0x40)
35#define RUNSTATE_VADDR (SHINFO_REGION_GVA + PAGE_SIZE + PAGE_SIZE - 15)
36
37#define EVTCHN_VECTOR 0x10
38
39#define EVTCHN_TEST1 15
40#define EVTCHN_TEST2 66
41#define EVTCHN_TIMER 13
42
43enum {
44 TEST_INJECT_VECTOR = 0,
45 TEST_RUNSTATE_runnable,
46 TEST_RUNSTATE_blocked,
47 TEST_RUNSTATE_offline,
48 TEST_RUNSTATE_ADJUST,
49 TEST_RUNSTATE_DATA,
50 TEST_STEAL_TIME,
51 TEST_EVTCHN_MASKED,
52 TEST_EVTCHN_UNMASKED,
53 TEST_EVTCHN_SLOWPATH,
54 TEST_EVTCHN_SEND_IOCTL,
55 TEST_EVTCHN_HCALL,
56 TEST_EVTCHN_HCALL_SLOWPATH,
57 TEST_EVTCHN_HCALL_EVENTFD,
58 TEST_TIMER_SETUP,
59 TEST_TIMER_WAIT,
60 TEST_TIMER_RESTORE,
61 TEST_POLL_READY,
62 TEST_POLL_TIMEOUT,
63 TEST_POLL_MASKED,
64 TEST_POLL_WAKE,
65 SET_VCPU_INFO,
66 TEST_TIMER_PAST,
67 TEST_LOCKING_SEND_RACE,
68 TEST_LOCKING_POLL_RACE,
69 TEST_LOCKING_POLL_TIMEOUT,
70 TEST_DONE,
71
72 TEST_GUEST_SAW_IRQ,
73};
74
75#define XEN_HYPERCALL_MSR 0x40000000
76
77#define MIN_STEAL_TIME 50000
78
79#define SHINFO_RACE_TIMEOUT 2 /* seconds */
80
81#define __HYPERVISOR_set_timer_op 15
82#define __HYPERVISOR_sched_op 29
83#define __HYPERVISOR_event_channel_op 32
84
85#define SCHEDOP_poll 3
86
87#define EVTCHNOP_send 4
88
89#define EVTCHNSTAT_interdomain 2
90
91struct evtchn_send {
92 u32 port;
93};
94
95struct sched_poll {
96 u32 *ports;
97 unsigned int nr_ports;
98 u64 timeout;
99};
100
101struct pvclock_vcpu_time_info {
102 u32 version;
103 u32 pad0;
104 u64 tsc_timestamp;
105 u64 system_time;
106 u32 tsc_to_system_mul;
107 s8 tsc_shift;
108 u8 flags;
109 u8 pad[2];
110} __attribute__((__packed__)); /* 32 bytes */
111
112struct pvclock_wall_clock {
113 u32 version;
114 u32 sec;
115 u32 nsec;
116} __attribute__((__packed__));
117
118struct vcpu_runstate_info {
119 uint32_t state;
120 uint64_t state_entry_time;
121 uint64_t time[5]; /* Extra field for overrun check */
122};
123
124struct compat_vcpu_runstate_info {
125 uint32_t state;
126 uint64_t state_entry_time;
127 uint64_t time[5];
128} __attribute__((__packed__));;
129
130struct arch_vcpu_info {
131 unsigned long cr2;
132 unsigned long pad; /* sizeof(vcpu_info_t) == 64 */
133};
134
135struct vcpu_info {
136 uint8_t evtchn_upcall_pending;
137 uint8_t evtchn_upcall_mask;
138 unsigned long evtchn_pending_sel;
139 struct arch_vcpu_info arch;
140 struct pvclock_vcpu_time_info time;
141}; /* 64 bytes (x86) */
142
143struct shared_info {
144 struct vcpu_info vcpu_info[32];
145 unsigned long evtchn_pending[64];
146 unsigned long evtchn_mask[64];
147 struct pvclock_wall_clock wc;
148 uint32_t wc_sec_hi;
149 /* arch_shared_info here */
150};
151
152#define RUNSTATE_running 0
153#define RUNSTATE_runnable 1
154#define RUNSTATE_blocked 2
155#define RUNSTATE_offline 3
156
157static const char *runstate_names[] = {
158 "running",
159 "runnable",
160 "blocked",
161 "offline"
162};
163
164struct {
165 struct kvm_irq_routing info;
166 struct kvm_irq_routing_entry entries[2];
167} irq_routes;
168
169static volatile bool guest_saw_irq;
170
171static void evtchn_handler(struct ex_regs *regs)
172{
173 struct vcpu_info *vi = (void *)VCPU_INFO_VADDR;
174 vi->evtchn_upcall_pending = 0;
175 vi->evtchn_pending_sel = 0;
176 guest_saw_irq = true;
177
178 GUEST_SYNC(TEST_GUEST_SAW_IRQ);
179}
180
181static void guest_wait_for_irq(void)
182{
183 while (!guest_saw_irq)
184 __asm__ __volatile__ ("rep nop" : : : "memory");
185 guest_saw_irq = false;
186}
187
188static void guest_code(void)
189{
190 struct vcpu_runstate_info *rs = (void *)RUNSTATE_VADDR;
191 int i;
192
193 __asm__ __volatile__(
194 "sti\n"
195 "nop\n"
196 );
197
198 /* Trigger an interrupt injection */
199 GUEST_SYNC(TEST_INJECT_VECTOR);
200
201 guest_wait_for_irq();
202
203 /* Test having the host set runstates manually */
204 GUEST_SYNC(TEST_RUNSTATE_runnable);
205 GUEST_ASSERT(rs->time[RUNSTATE_runnable] != 0);
206 GUEST_ASSERT(rs->state == 0);
207
208 GUEST_SYNC(TEST_RUNSTATE_blocked);
209 GUEST_ASSERT(rs->time[RUNSTATE_blocked] != 0);
210 GUEST_ASSERT(rs->state == 0);
211
212 GUEST_SYNC(TEST_RUNSTATE_offline);
213 GUEST_ASSERT(rs->time[RUNSTATE_offline] != 0);
214 GUEST_ASSERT(rs->state == 0);
215
216 /* Test runstate time adjust */
217 GUEST_SYNC(TEST_RUNSTATE_ADJUST);
218 GUEST_ASSERT(rs->time[RUNSTATE_blocked] == 0x5a);
219 GUEST_ASSERT(rs->time[RUNSTATE_offline] == 0x6b6b);
220
221 /* Test runstate time set */
222 GUEST_SYNC(TEST_RUNSTATE_DATA);
223 GUEST_ASSERT(rs->state_entry_time >= 0x8000);
224 GUEST_ASSERT(rs->time[RUNSTATE_runnable] == 0);
225 GUEST_ASSERT(rs->time[RUNSTATE_blocked] == 0x6b6b);
226 GUEST_ASSERT(rs->time[RUNSTATE_offline] == 0x5a);
227
228 /* sched_yield() should result in some 'runnable' time */
229 GUEST_SYNC(TEST_STEAL_TIME);
230 GUEST_ASSERT(rs->time[RUNSTATE_runnable] >= MIN_STEAL_TIME);
231
232 /* Attempt to deliver a *masked* interrupt */
233 GUEST_SYNC(TEST_EVTCHN_MASKED);
234
235 /* Wait until we see the bit set */
236 struct shared_info *si = (void *)SHINFO_VADDR;
237 while (!si->evtchn_pending[0])
238 __asm__ __volatile__ ("rep nop" : : : "memory");
239
240 /* Now deliver an *unmasked* interrupt */
241 GUEST_SYNC(TEST_EVTCHN_UNMASKED);
242
243 guest_wait_for_irq();
244
245 /* Change memslots and deliver an interrupt */
246 GUEST_SYNC(TEST_EVTCHN_SLOWPATH);
247
248 guest_wait_for_irq();
249
250 /* Deliver event channel with KVM_XEN_HVM_EVTCHN_SEND */
251 GUEST_SYNC(TEST_EVTCHN_SEND_IOCTL);
252
253 guest_wait_for_irq();
254
255 GUEST_SYNC(TEST_EVTCHN_HCALL);
256
257 /* Our turn. Deliver event channel (to ourselves) with
258 * EVTCHNOP_send hypercall. */
259 struct evtchn_send s = { .port = 127 };
260 xen_hypercall(__HYPERVISOR_event_channel_op, EVTCHNOP_send, &s);
261
262 guest_wait_for_irq();
263
264 GUEST_SYNC(TEST_EVTCHN_HCALL_SLOWPATH);
265
266 /*
267 * Same again, but this time the host has messed with memslots so it
268 * should take the slow path in kvm_xen_set_evtchn().
269 */
270 xen_hypercall(__HYPERVISOR_event_channel_op, EVTCHNOP_send, &s);
271
272 guest_wait_for_irq();
273
274 GUEST_SYNC(TEST_EVTCHN_HCALL_EVENTFD);
275
276 /* Deliver "outbound" event channel to an eventfd which
277 * happens to be one of our own irqfds. */
278 s.port = 197;
279 xen_hypercall(__HYPERVISOR_event_channel_op, EVTCHNOP_send, &s);
280
281 guest_wait_for_irq();
282
283 GUEST_SYNC(TEST_TIMER_SETUP);
284
285 /* Set a timer 100ms in the future. */
286 xen_hypercall(__HYPERVISOR_set_timer_op,
287 rs->state_entry_time + 100000000, NULL);
288
289 GUEST_SYNC(TEST_TIMER_WAIT);
290
291 /* Now wait for the timer */
292 guest_wait_for_irq();
293
294 GUEST_SYNC(TEST_TIMER_RESTORE);
295
296 /* The host has 'restored' the timer. Just wait for it. */
297 guest_wait_for_irq();
298
299 GUEST_SYNC(TEST_POLL_READY);
300
301 /* Poll for an event channel port which is already set */
302 u32 ports[1] = { EVTCHN_TIMER };
303 struct sched_poll p = {
304 .ports = ports,
305 .nr_ports = 1,
306 .timeout = 0,
307 };
308
309 xen_hypercall(__HYPERVISOR_sched_op, SCHEDOP_poll, &p);
310
311 GUEST_SYNC(TEST_POLL_TIMEOUT);
312
313 /* Poll for an unset port and wait for the timeout. */
314 p.timeout = 100000000;
315 xen_hypercall(__HYPERVISOR_sched_op, SCHEDOP_poll, &p);
316
317 GUEST_SYNC(TEST_POLL_MASKED);
318
319 /* A timer will wake the masked port we're waiting on, while we poll */
320 p.timeout = 0;
321 xen_hypercall(__HYPERVISOR_sched_op, SCHEDOP_poll, &p);
322
323 GUEST_SYNC(TEST_POLL_WAKE);
324
325 /* Set the vcpu_info to point at exactly the place it already is to
326 * make sure the attribute is functional. */
327 GUEST_SYNC(SET_VCPU_INFO);
328
329 /* A timer wake an *unmasked* port which should wake us with an
330 * actual interrupt, while we're polling on a different port. */
331 ports[0]++;
332 p.timeout = 0;
333 xen_hypercall(__HYPERVISOR_sched_op, SCHEDOP_poll, &p);
334
335 guest_wait_for_irq();
336
337 GUEST_SYNC(TEST_TIMER_PAST);
338
339 /* Timer should have fired already */
340 guest_wait_for_irq();
341
342 GUEST_SYNC(TEST_LOCKING_SEND_RACE);
343 /* Racing host ioctls */
344
345 guest_wait_for_irq();
346
347 GUEST_SYNC(TEST_LOCKING_POLL_RACE);
348 /* Racing vmcall against host ioctl */
349
350 ports[0] = 0;
351
352 p = (struct sched_poll) {
353 .ports = ports,
354 .nr_ports = 1,
355 .timeout = 0
356 };
357
358wait_for_timer:
359 /*
360 * Poll for a timer wake event while the worker thread is mucking with
361 * the shared info. KVM XEN drops timer IRQs if the shared info is
362 * invalid when the timer expires. Arbitrarily poll 100 times before
363 * giving up and asking the VMM to re-arm the timer. 100 polls should
364 * consume enough time to beat on KVM without taking too long if the
365 * timer IRQ is dropped due to an invalid event channel.
366 */
367 for (i = 0; i < 100 && !guest_saw_irq; i++)
368 __xen_hypercall(__HYPERVISOR_sched_op, SCHEDOP_poll, &p);
369
370 /*
371 * Re-send the timer IRQ if it was (likely) dropped due to the timer
372 * expiring while the event channel was invalid.
373 */
374 if (!guest_saw_irq) {
375 GUEST_SYNC(TEST_LOCKING_POLL_TIMEOUT);
376 goto wait_for_timer;
377 }
378 guest_saw_irq = false;
379
380 GUEST_SYNC(TEST_DONE);
381}
382
383static int cmp_timespec(struct timespec *a, struct timespec *b)
384{
385 if (a->tv_sec > b->tv_sec)
386 return 1;
387 else if (a->tv_sec < b->tv_sec)
388 return -1;
389 else if (a->tv_nsec > b->tv_nsec)
390 return 1;
391 else if (a->tv_nsec < b->tv_nsec)
392 return -1;
393 else
394 return 0;
395}
396
397static struct shared_info *shinfo;
398static struct vcpu_info *vinfo;
399static struct kvm_vcpu *vcpu;
400
401static void handle_alrm(int sig)
402{
403 if (vinfo)
404 printf("evtchn_upcall_pending 0x%x\n", vinfo->evtchn_upcall_pending);
405 vcpu_dump(stdout, vcpu, 0);
406 TEST_FAIL("IRQ delivery timed out");
407}
408
409static void *juggle_shinfo_state(void *arg)
410{
411 struct kvm_vm *vm = (struct kvm_vm *)arg;
412
413 struct kvm_xen_hvm_attr cache_activate_gfn = {
414 .type = KVM_XEN_ATTR_TYPE_SHARED_INFO,
415 .u.shared_info.gfn = SHINFO_REGION_GPA / PAGE_SIZE
416 };
417
418 struct kvm_xen_hvm_attr cache_deactivate_gfn = {
419 .type = KVM_XEN_ATTR_TYPE_SHARED_INFO,
420 .u.shared_info.gfn = KVM_XEN_INVALID_GFN
421 };
422
423 struct kvm_xen_hvm_attr cache_activate_hva = {
424 .type = KVM_XEN_ATTR_TYPE_SHARED_INFO_HVA,
425 .u.shared_info.hva = (unsigned long)shinfo
426 };
427
428 struct kvm_xen_hvm_attr cache_deactivate_hva = {
429 .type = KVM_XEN_ATTR_TYPE_SHARED_INFO,
430 .u.shared_info.hva = 0
431 };
432
433 int xen_caps = kvm_check_cap(KVM_CAP_XEN_HVM);
434
435 for (;;) {
436 __vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &cache_activate_gfn);
437 pthread_testcancel();
438 __vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &cache_deactivate_gfn);
439
440 if (xen_caps & KVM_XEN_HVM_CONFIG_SHARED_INFO_HVA) {
441 __vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &cache_activate_hva);
442 pthread_testcancel();
443 __vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &cache_deactivate_hva);
444 }
445 }
446
447 return NULL;
448}
449
450int main(int argc, char *argv[])
451{
452 struct timespec min_ts, max_ts, vm_ts;
453 struct kvm_xen_hvm_attr evt_reset;
454 struct kvm_vm *vm;
455 pthread_t thread;
456 bool verbose;
457 int ret;
458
459 verbose = argc > 1 && (!strncmp(argv[1], "-v", 3) ||
460 !strncmp(argv[1], "--verbose", 10));
461
462 int xen_caps = kvm_check_cap(KVM_CAP_XEN_HVM);
463 TEST_REQUIRE(xen_caps & KVM_XEN_HVM_CONFIG_SHARED_INFO);
464
465 bool do_runstate_tests = !!(xen_caps & KVM_XEN_HVM_CONFIG_RUNSTATE);
466 bool do_runstate_flag = !!(xen_caps & KVM_XEN_HVM_CONFIG_RUNSTATE_UPDATE_FLAG);
467 bool do_eventfd_tests = !!(xen_caps & KVM_XEN_HVM_CONFIG_EVTCHN_2LEVEL);
468 bool do_evtchn_tests = do_eventfd_tests && !!(xen_caps & KVM_XEN_HVM_CONFIG_EVTCHN_SEND);
469 bool has_shinfo_hva = !!(xen_caps & KVM_XEN_HVM_CONFIG_SHARED_INFO_HVA);
470
471 clock_gettime(CLOCK_REALTIME, &min_ts);
472
473 vm = vm_create_with_one_vcpu(&vcpu, guest_code);
474
475 /* Map a region for the shared_info page */
476 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
477 SHINFO_REGION_GPA, SHINFO_REGION_SLOT, 3, 0);
478 virt_map(vm, SHINFO_REGION_GVA, SHINFO_REGION_GPA, 3);
479
480 shinfo = addr_gpa2hva(vm, SHINFO_VADDR);
481
482 int zero_fd = open("/dev/zero", O_RDONLY);
483 TEST_ASSERT(zero_fd != -1, "Failed to open /dev/zero");
484
485 struct kvm_xen_hvm_config hvmc = {
486 .flags = KVM_XEN_HVM_CONFIG_INTERCEPT_HCALL,
487 .msr = XEN_HYPERCALL_MSR,
488 };
489
490 /* Let the kernel know that we *will* use it for sending all
491 * event channels, which lets it intercept SCHEDOP_poll */
492 if (do_evtchn_tests)
493 hvmc.flags |= KVM_XEN_HVM_CONFIG_EVTCHN_SEND;
494
495 vm_ioctl(vm, KVM_XEN_HVM_CONFIG, &hvmc);
496
497 struct kvm_xen_hvm_attr lm = {
498 .type = KVM_XEN_ATTR_TYPE_LONG_MODE,
499 .u.long_mode = 1,
500 };
501 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &lm);
502
503 if (do_runstate_flag) {
504 struct kvm_xen_hvm_attr ruf = {
505 .type = KVM_XEN_ATTR_TYPE_RUNSTATE_UPDATE_FLAG,
506 .u.runstate_update_flag = 1,
507 };
508 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &ruf);
509
510 ruf.u.runstate_update_flag = 0;
511 vm_ioctl(vm, KVM_XEN_HVM_GET_ATTR, &ruf);
512 TEST_ASSERT(ruf.u.runstate_update_flag == 1,
513 "Failed to read back RUNSTATE_UPDATE_FLAG attr");
514 }
515
516 struct kvm_xen_hvm_attr ha = {};
517
518 if (has_shinfo_hva) {
519 ha.type = KVM_XEN_ATTR_TYPE_SHARED_INFO_HVA;
520 ha.u.shared_info.hva = (unsigned long)shinfo;
521 } else {
522 ha.type = KVM_XEN_ATTR_TYPE_SHARED_INFO;
523 ha.u.shared_info.gfn = SHINFO_ADDR / PAGE_SIZE;
524 }
525
526 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &ha);
527
528 /*
529 * Test what happens when the HVA of the shinfo page is remapped after
530 * the kernel has a reference to it. But make sure we copy the clock
531 * info over since that's only set at setup time, and we test it later.
532 */
533 struct pvclock_wall_clock wc_copy = shinfo->wc;
534 void *m = mmap(shinfo, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_FIXED|MAP_PRIVATE, zero_fd, 0);
535 TEST_ASSERT(m == shinfo, "Failed to map /dev/zero over shared info");
536 shinfo->wc = wc_copy;
537
538 struct kvm_xen_vcpu_attr vi = {
539 .type = KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO,
540 .u.gpa = VCPU_INFO_ADDR,
541 };
542 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &vi);
543
544 struct kvm_xen_vcpu_attr pvclock = {
545 .type = KVM_XEN_VCPU_ATTR_TYPE_VCPU_TIME_INFO,
546 .u.gpa = PVTIME_ADDR,
547 };
548 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &pvclock);
549
550 struct kvm_xen_hvm_attr vec = {
551 .type = KVM_XEN_ATTR_TYPE_UPCALL_VECTOR,
552 .u.vector = EVTCHN_VECTOR,
553 };
554 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &vec);
555
556 vm_init_descriptor_tables(vm);
557 vcpu_init_descriptor_tables(vcpu);
558 vm_install_exception_handler(vm, EVTCHN_VECTOR, evtchn_handler);
559
560 if (do_runstate_tests) {
561 struct kvm_xen_vcpu_attr st = {
562 .type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADDR,
563 .u.gpa = RUNSTATE_ADDR,
564 };
565 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &st);
566 }
567
568 int irq_fd[2] = { -1, -1 };
569
570 if (do_eventfd_tests) {
571 irq_fd[0] = eventfd(0, 0);
572 irq_fd[1] = eventfd(0, 0);
573
574 /* Unexpected, but not a KVM failure */
575 if (irq_fd[0] == -1 || irq_fd[1] == -1)
576 do_evtchn_tests = do_eventfd_tests = false;
577 }
578
579 if (do_eventfd_tests) {
580 irq_routes.info.nr = 2;
581
582 irq_routes.entries[0].gsi = 32;
583 irq_routes.entries[0].type = KVM_IRQ_ROUTING_XEN_EVTCHN;
584 irq_routes.entries[0].u.xen_evtchn.port = EVTCHN_TEST1;
585 irq_routes.entries[0].u.xen_evtchn.vcpu = vcpu->id;
586 irq_routes.entries[0].u.xen_evtchn.priority = KVM_IRQ_ROUTING_XEN_EVTCHN_PRIO_2LEVEL;
587
588 irq_routes.entries[1].gsi = 33;
589 irq_routes.entries[1].type = KVM_IRQ_ROUTING_XEN_EVTCHN;
590 irq_routes.entries[1].u.xen_evtchn.port = EVTCHN_TEST2;
591 irq_routes.entries[1].u.xen_evtchn.vcpu = vcpu->id;
592 irq_routes.entries[1].u.xen_evtchn.priority = KVM_IRQ_ROUTING_XEN_EVTCHN_PRIO_2LEVEL;
593
594 vm_ioctl(vm, KVM_SET_GSI_ROUTING, &irq_routes.info);
595
596 struct kvm_irqfd ifd = { };
597
598 ifd.fd = irq_fd[0];
599 ifd.gsi = 32;
600 vm_ioctl(vm, KVM_IRQFD, &ifd);
601
602 ifd.fd = irq_fd[1];
603 ifd.gsi = 33;
604 vm_ioctl(vm, KVM_IRQFD, &ifd);
605
606 struct sigaction sa = { };
607 sa.sa_handler = handle_alrm;
608 sigaction(SIGALRM, &sa, NULL);
609 }
610
611 struct kvm_xen_vcpu_attr tmr = {
612 .type = KVM_XEN_VCPU_ATTR_TYPE_TIMER,
613 .u.timer.port = EVTCHN_TIMER,
614 .u.timer.priority = KVM_IRQ_ROUTING_XEN_EVTCHN_PRIO_2LEVEL,
615 .u.timer.expires_ns = 0
616 };
617
618 if (do_evtchn_tests) {
619 struct kvm_xen_hvm_attr inj = {
620 .type = KVM_XEN_ATTR_TYPE_EVTCHN,
621 .u.evtchn.send_port = 127,
622 .u.evtchn.type = EVTCHNSTAT_interdomain,
623 .u.evtchn.flags = 0,
624 .u.evtchn.deliver.port.port = EVTCHN_TEST1,
625 .u.evtchn.deliver.port.vcpu = vcpu->id + 1,
626 .u.evtchn.deliver.port.priority = KVM_IRQ_ROUTING_XEN_EVTCHN_PRIO_2LEVEL,
627 };
628 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &inj);
629
630 /* Test migration to a different vCPU */
631 inj.u.evtchn.flags = KVM_XEN_EVTCHN_UPDATE;
632 inj.u.evtchn.deliver.port.vcpu = vcpu->id;
633 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &inj);
634
635 inj.u.evtchn.send_port = 197;
636 inj.u.evtchn.deliver.eventfd.port = 0;
637 inj.u.evtchn.deliver.eventfd.fd = irq_fd[1];
638 inj.u.evtchn.flags = 0;
639 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &inj);
640
641 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &tmr);
642 }
643 vinfo = addr_gpa2hva(vm, VCPU_INFO_VADDR);
644 vinfo->evtchn_upcall_pending = 0;
645
646 struct vcpu_runstate_info *rs = addr_gpa2hva(vm, RUNSTATE_ADDR);
647 rs->state = 0x5a;
648
649 bool evtchn_irq_expected = false;
650
651 for (;;) {
652 struct ucall uc;
653
654 vcpu_run(vcpu);
655 TEST_ASSERT_KVM_EXIT_REASON(vcpu, KVM_EXIT_IO);
656
657 switch (get_ucall(vcpu, &uc)) {
658 case UCALL_ABORT:
659 REPORT_GUEST_ASSERT(uc);
660 /* NOT REACHED */
661 case UCALL_SYNC: {
662 struct kvm_xen_vcpu_attr rst;
663 long rundelay;
664
665 if (do_runstate_tests)
666 TEST_ASSERT(rs->state_entry_time == rs->time[0] +
667 rs->time[1] + rs->time[2] + rs->time[3],
668 "runstate times don't add up");
669
670 switch (uc.args[1]) {
671 case TEST_INJECT_VECTOR:
672 if (verbose)
673 printf("Delivering evtchn upcall\n");
674 evtchn_irq_expected = true;
675 vinfo->evtchn_upcall_pending = 1;
676 break;
677
678 case TEST_RUNSTATE_runnable...TEST_RUNSTATE_offline:
679 TEST_ASSERT(!evtchn_irq_expected, "Event channel IRQ not seen");
680 if (!do_runstate_tests)
681 goto done;
682 if (verbose)
683 printf("Testing runstate %s\n", runstate_names[uc.args[1]]);
684 rst.type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_CURRENT;
685 rst.u.runstate.state = uc.args[1] + RUNSTATE_runnable -
686 TEST_RUNSTATE_runnable;
687 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &rst);
688 break;
689
690 case TEST_RUNSTATE_ADJUST:
691 if (verbose)
692 printf("Testing RUNSTATE_ADJUST\n");
693 rst.type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADJUST;
694 memset(&rst.u, 0, sizeof(rst.u));
695 rst.u.runstate.state = (uint64_t)-1;
696 rst.u.runstate.time_blocked =
697 0x5a - rs->time[RUNSTATE_blocked];
698 rst.u.runstate.time_offline =
699 0x6b6b - rs->time[RUNSTATE_offline];
700 rst.u.runstate.time_runnable = -rst.u.runstate.time_blocked -
701 rst.u.runstate.time_offline;
702 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &rst);
703 break;
704
705 case TEST_RUNSTATE_DATA:
706 if (verbose)
707 printf("Testing RUNSTATE_DATA\n");
708 rst.type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_DATA;
709 memset(&rst.u, 0, sizeof(rst.u));
710 rst.u.runstate.state = RUNSTATE_running;
711 rst.u.runstate.state_entry_time = 0x6b6b + 0x5a;
712 rst.u.runstate.time_blocked = 0x6b6b;
713 rst.u.runstate.time_offline = 0x5a;
714 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &rst);
715 break;
716
717 case TEST_STEAL_TIME:
718 if (verbose)
719 printf("Testing steal time\n");
720 /* Yield until scheduler delay exceeds target */
721 rundelay = get_run_delay() + MIN_STEAL_TIME;
722 do {
723 sched_yield();
724 } while (get_run_delay() < rundelay);
725 break;
726
727 case TEST_EVTCHN_MASKED:
728 if (!do_eventfd_tests)
729 goto done;
730 if (verbose)
731 printf("Testing masked event channel\n");
732 shinfo->evtchn_mask[0] = 1UL << EVTCHN_TEST1;
733 eventfd_write(irq_fd[0], 1UL);
734 alarm(1);
735 break;
736
737 case TEST_EVTCHN_UNMASKED:
738 if (verbose)
739 printf("Testing unmasked event channel\n");
740 /* Unmask that, but deliver the other one */
741 shinfo->evtchn_pending[0] = 0;
742 shinfo->evtchn_mask[0] = 0;
743 eventfd_write(irq_fd[1], 1UL);
744 evtchn_irq_expected = true;
745 alarm(1);
746 break;
747
748 case TEST_EVTCHN_SLOWPATH:
749 TEST_ASSERT(!evtchn_irq_expected,
750 "Expected event channel IRQ but it didn't happen");
751 shinfo->evtchn_pending[1] = 0;
752 if (verbose)
753 printf("Testing event channel after memslot change\n");
754 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
755 DUMMY_REGION_GPA, DUMMY_REGION_SLOT, 1, 0);
756 eventfd_write(irq_fd[0], 1UL);
757 evtchn_irq_expected = true;
758 alarm(1);
759 break;
760
761 case TEST_EVTCHN_SEND_IOCTL:
762 TEST_ASSERT(!evtchn_irq_expected,
763 "Expected event channel IRQ but it didn't happen");
764 if (!do_evtchn_tests)
765 goto done;
766
767 shinfo->evtchn_pending[0] = 0;
768 if (verbose)
769 printf("Testing injection with KVM_XEN_HVM_EVTCHN_SEND\n");
770
771 struct kvm_irq_routing_xen_evtchn e;
772 e.port = EVTCHN_TEST2;
773 e.vcpu = vcpu->id;
774 e.priority = KVM_IRQ_ROUTING_XEN_EVTCHN_PRIO_2LEVEL;
775
776 vm_ioctl(vm, KVM_XEN_HVM_EVTCHN_SEND, &e);
777 evtchn_irq_expected = true;
778 alarm(1);
779 break;
780
781 case TEST_EVTCHN_HCALL:
782 TEST_ASSERT(!evtchn_irq_expected,
783 "Expected event channel IRQ but it didn't happen");
784 shinfo->evtchn_pending[1] = 0;
785
786 if (verbose)
787 printf("Testing guest EVTCHNOP_send direct to evtchn\n");
788 evtchn_irq_expected = true;
789 alarm(1);
790 break;
791
792 case TEST_EVTCHN_HCALL_SLOWPATH:
793 TEST_ASSERT(!evtchn_irq_expected,
794 "Expected event channel IRQ but it didn't happen");
795 shinfo->evtchn_pending[0] = 0;
796
797 if (verbose)
798 printf("Testing guest EVTCHNOP_send direct to evtchn after memslot change\n");
799 vm_userspace_mem_region_add(vm, VM_MEM_SRC_ANONYMOUS,
800 DUMMY_REGION_GPA_2, DUMMY_REGION_SLOT_2, 1, 0);
801 evtchn_irq_expected = true;
802 alarm(1);
803 break;
804
805 case TEST_EVTCHN_HCALL_EVENTFD:
806 TEST_ASSERT(!evtchn_irq_expected,
807 "Expected event channel IRQ but it didn't happen");
808 shinfo->evtchn_pending[0] = 0;
809
810 if (verbose)
811 printf("Testing guest EVTCHNOP_send to eventfd\n");
812 evtchn_irq_expected = true;
813 alarm(1);
814 break;
815
816 case TEST_TIMER_SETUP:
817 TEST_ASSERT(!evtchn_irq_expected,
818 "Expected event channel IRQ but it didn't happen");
819 shinfo->evtchn_pending[1] = 0;
820
821 if (verbose)
822 printf("Testing guest oneshot timer\n");
823 break;
824
825 case TEST_TIMER_WAIT:
826 memset(&tmr, 0, sizeof(tmr));
827 tmr.type = KVM_XEN_VCPU_ATTR_TYPE_TIMER;
828 vcpu_ioctl(vcpu, KVM_XEN_VCPU_GET_ATTR, &tmr);
829 TEST_ASSERT(tmr.u.timer.port == EVTCHN_TIMER,
830 "Timer port not returned");
831 TEST_ASSERT(tmr.u.timer.priority == KVM_IRQ_ROUTING_XEN_EVTCHN_PRIO_2LEVEL,
832 "Timer priority not returned");
833 TEST_ASSERT(tmr.u.timer.expires_ns > rs->state_entry_time,
834 "Timer expiry not returned");
835 evtchn_irq_expected = true;
836 alarm(1);
837 break;
838
839 case TEST_TIMER_RESTORE:
840 TEST_ASSERT(!evtchn_irq_expected,
841 "Expected event channel IRQ but it didn't happen");
842 shinfo->evtchn_pending[0] = 0;
843
844 if (verbose)
845 printf("Testing restored oneshot timer\n");
846
847 tmr.u.timer.expires_ns = rs->state_entry_time + 100000000;
848 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &tmr);
849 evtchn_irq_expected = true;
850 alarm(1);
851 break;
852
853 case TEST_POLL_READY:
854 TEST_ASSERT(!evtchn_irq_expected,
855 "Expected event channel IRQ but it didn't happen");
856
857 if (verbose)
858 printf("Testing SCHEDOP_poll with already pending event\n");
859 shinfo->evtchn_pending[0] = shinfo->evtchn_mask[0] = 1UL << EVTCHN_TIMER;
860 alarm(1);
861 break;
862
863 case TEST_POLL_TIMEOUT:
864 if (verbose)
865 printf("Testing SCHEDOP_poll timeout\n");
866 shinfo->evtchn_pending[0] = 0;
867 alarm(1);
868 break;
869
870 case TEST_POLL_MASKED:
871 if (verbose)
872 printf("Testing SCHEDOP_poll wake on masked event\n");
873
874 tmr.u.timer.expires_ns = rs->state_entry_time + 100000000;
875 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &tmr);
876 alarm(1);
877 break;
878
879 case TEST_POLL_WAKE:
880 shinfo->evtchn_pending[0] = shinfo->evtchn_mask[0] = 0;
881 if (verbose)
882 printf("Testing SCHEDOP_poll wake on unmasked event\n");
883
884 evtchn_irq_expected = true;
885 tmr.u.timer.expires_ns = rs->state_entry_time + 100000000;
886 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &tmr);
887
888 /* Read it back and check the pending time is reported correctly */
889 tmr.u.timer.expires_ns = 0;
890 vcpu_ioctl(vcpu, KVM_XEN_VCPU_GET_ATTR, &tmr);
891 TEST_ASSERT(tmr.u.timer.expires_ns == rs->state_entry_time + 100000000,
892 "Timer not reported pending");
893 alarm(1);
894 break;
895
896 case SET_VCPU_INFO:
897 if (has_shinfo_hva) {
898 struct kvm_xen_vcpu_attr vih = {
899 .type = KVM_XEN_VCPU_ATTR_TYPE_VCPU_INFO_HVA,
900 .u.hva = (unsigned long)vinfo
901 };
902 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &vih);
903 }
904 break;
905
906 case TEST_TIMER_PAST:
907 TEST_ASSERT(!evtchn_irq_expected,
908 "Expected event channel IRQ but it didn't happen");
909 /* Read timer and check it is no longer pending */
910 vcpu_ioctl(vcpu, KVM_XEN_VCPU_GET_ATTR, &tmr);
911 TEST_ASSERT(!tmr.u.timer.expires_ns, "Timer still reported pending");
912
913 shinfo->evtchn_pending[0] = 0;
914 if (verbose)
915 printf("Testing timer in the past\n");
916
917 evtchn_irq_expected = true;
918 tmr.u.timer.expires_ns = rs->state_entry_time - 100000000ULL;
919 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &tmr);
920 alarm(1);
921 break;
922
923 case TEST_LOCKING_SEND_RACE:
924 TEST_ASSERT(!evtchn_irq_expected,
925 "Expected event channel IRQ but it didn't happen");
926 alarm(0);
927
928 if (verbose)
929 printf("Testing shinfo lock corruption (KVM_XEN_HVM_EVTCHN_SEND)\n");
930
931 ret = pthread_create(&thread, NULL, &juggle_shinfo_state, (void *)vm);
932 TEST_ASSERT(ret == 0, "pthread_create() failed: %s", strerror(ret));
933
934 struct kvm_irq_routing_xen_evtchn uxe = {
935 .port = 1,
936 .vcpu = vcpu->id,
937 .priority = KVM_IRQ_ROUTING_XEN_EVTCHN_PRIO_2LEVEL
938 };
939
940 evtchn_irq_expected = true;
941 for (time_t t = time(NULL) + SHINFO_RACE_TIMEOUT; time(NULL) < t;)
942 __vm_ioctl(vm, KVM_XEN_HVM_EVTCHN_SEND, &uxe);
943 break;
944
945 case TEST_LOCKING_POLL_RACE:
946 TEST_ASSERT(!evtchn_irq_expected,
947 "Expected event channel IRQ but it didn't happen");
948
949 if (verbose)
950 printf("Testing shinfo lock corruption (SCHEDOP_poll)\n");
951
952 shinfo->evtchn_pending[0] = 1;
953
954 evtchn_irq_expected = true;
955 tmr.u.timer.expires_ns = rs->state_entry_time +
956 SHINFO_RACE_TIMEOUT * 1000000000ULL;
957 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &tmr);
958 break;
959
960 case TEST_LOCKING_POLL_TIMEOUT:
961 /*
962 * Optional and possibly repeated sync point.
963 * Injecting the timer IRQ may fail if the
964 * shinfo is invalid when the timer expires.
965 * If the timer has expired but the IRQ hasn't
966 * been delivered, rearm the timer and retry.
967 */
968 vcpu_ioctl(vcpu, KVM_XEN_VCPU_GET_ATTR, &tmr);
969
970 /* Resume the guest if the timer is still pending. */
971 if (tmr.u.timer.expires_ns)
972 break;
973
974 /* All done if the IRQ was delivered. */
975 if (!evtchn_irq_expected)
976 break;
977
978 tmr.u.timer.expires_ns = rs->state_entry_time +
979 SHINFO_RACE_TIMEOUT * 1000000000ULL;
980 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &tmr);
981 break;
982 case TEST_DONE:
983 TEST_ASSERT(!evtchn_irq_expected,
984 "Expected event channel IRQ but it didn't happen");
985
986 ret = pthread_cancel(thread);
987 TEST_ASSERT(ret == 0, "pthread_cancel() failed: %s", strerror(ret));
988
989 ret = pthread_join(thread, 0);
990 TEST_ASSERT(ret == 0, "pthread_join() failed: %s", strerror(ret));
991 goto done;
992
993 case TEST_GUEST_SAW_IRQ:
994 TEST_ASSERT(evtchn_irq_expected, "Unexpected event channel IRQ");
995 evtchn_irq_expected = false;
996 break;
997 }
998 break;
999 }
1000 case UCALL_DONE:
1001 goto done;
1002 default:
1003 TEST_FAIL("Unknown ucall 0x%lx.", uc.cmd);
1004 }
1005 }
1006
1007 done:
1008 evt_reset.type = KVM_XEN_ATTR_TYPE_EVTCHN;
1009 evt_reset.u.evtchn.flags = KVM_XEN_EVTCHN_RESET;
1010 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &evt_reset);
1011
1012 alarm(0);
1013 clock_gettime(CLOCK_REALTIME, &max_ts);
1014
1015 /*
1016 * Just a *really* basic check that things are being put in the
1017 * right place. The actual calculations are much the same for
1018 * Xen as they are for the KVM variants, so no need to check.
1019 */
1020 struct pvclock_wall_clock *wc;
1021 struct pvclock_vcpu_time_info *ti, *ti2;
1022
1023 wc = addr_gpa2hva(vm, SHINFO_REGION_GPA + 0xc00);
1024 ti = addr_gpa2hva(vm, SHINFO_REGION_GPA + 0x40 + 0x20);
1025 ti2 = addr_gpa2hva(vm, PVTIME_ADDR);
1026
1027 if (verbose) {
1028 printf("Wall clock (v %d) %d.%09d\n", wc->version, wc->sec, wc->nsec);
1029 printf("Time info 1: v %u tsc %" PRIu64 " time %" PRIu64 " mul %u shift %u flags %x\n",
1030 ti->version, ti->tsc_timestamp, ti->system_time, ti->tsc_to_system_mul,
1031 ti->tsc_shift, ti->flags);
1032 printf("Time info 2: v %u tsc %" PRIu64 " time %" PRIu64 " mul %u shift %u flags %x\n",
1033 ti2->version, ti2->tsc_timestamp, ti2->system_time, ti2->tsc_to_system_mul,
1034 ti2->tsc_shift, ti2->flags);
1035 }
1036
1037 vm_ts.tv_sec = wc->sec;
1038 vm_ts.tv_nsec = wc->nsec;
1039 TEST_ASSERT(wc->version && !(wc->version & 1),
1040 "Bad wallclock version %x", wc->version);
1041 TEST_ASSERT(cmp_timespec(&min_ts, &vm_ts) <= 0, "VM time too old");
1042 TEST_ASSERT(cmp_timespec(&max_ts, &vm_ts) >= 0, "VM time too new");
1043
1044 TEST_ASSERT(ti->version && !(ti->version & 1),
1045 "Bad time_info version %x", ti->version);
1046 TEST_ASSERT(ti2->version && !(ti2->version & 1),
1047 "Bad time_info version %x", ti->version);
1048
1049 if (do_runstate_tests) {
1050 /*
1051 * Fetch runstate and check sanity. Strictly speaking in the
1052 * general case we might not expect the numbers to be identical
1053 * but in this case we know we aren't running the vCPU any more.
1054 */
1055 struct kvm_xen_vcpu_attr rst = {
1056 .type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_DATA,
1057 };
1058 vcpu_ioctl(vcpu, KVM_XEN_VCPU_GET_ATTR, &rst);
1059
1060 if (verbose) {
1061 printf("Runstate: %s(%d), entry %" PRIu64 " ns\n",
1062 rs->state <= RUNSTATE_offline ? runstate_names[rs->state] : "unknown",
1063 rs->state, rs->state_entry_time);
1064 for (int i = RUNSTATE_running; i <= RUNSTATE_offline; i++) {
1065 printf("State %s: %" PRIu64 " ns\n",
1066 runstate_names[i], rs->time[i]);
1067 }
1068 }
1069
1070 /*
1071 * Exercise runstate info at all points across the page boundary, in
1072 * 32-bit and 64-bit mode. In particular, test the case where it is
1073 * configured in 32-bit mode and then switched to 64-bit mode while
1074 * active, which takes it onto the second page.
1075 */
1076 unsigned long runstate_addr;
1077 struct compat_vcpu_runstate_info *crs;
1078 for (runstate_addr = SHINFO_REGION_GPA + PAGE_SIZE + PAGE_SIZE - sizeof(*rs) - 4;
1079 runstate_addr < SHINFO_REGION_GPA + PAGE_SIZE + PAGE_SIZE + 4; runstate_addr++) {
1080
1081 rs = addr_gpa2hva(vm, runstate_addr);
1082 crs = (void *)rs;
1083
1084 memset(rs, 0xa5, sizeof(*rs));
1085
1086 /* Set to compatibility mode */
1087 lm.u.long_mode = 0;
1088 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &lm);
1089
1090 /* Set runstate to new address (kernel will write it) */
1091 struct kvm_xen_vcpu_attr st = {
1092 .type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADDR,
1093 .u.gpa = runstate_addr,
1094 };
1095 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &st);
1096
1097 if (verbose)
1098 printf("Compatibility runstate at %08lx\n", runstate_addr);
1099
1100 TEST_ASSERT(crs->state == rst.u.runstate.state, "Runstate mismatch");
1101 TEST_ASSERT(crs->state_entry_time == rst.u.runstate.state_entry_time,
1102 "State entry time mismatch");
1103 TEST_ASSERT(crs->time[RUNSTATE_running] == rst.u.runstate.time_running,
1104 "Running time mismatch");
1105 TEST_ASSERT(crs->time[RUNSTATE_runnable] == rst.u.runstate.time_runnable,
1106 "Runnable time mismatch");
1107 TEST_ASSERT(crs->time[RUNSTATE_blocked] == rst.u.runstate.time_blocked,
1108 "Blocked time mismatch");
1109 TEST_ASSERT(crs->time[RUNSTATE_offline] == rst.u.runstate.time_offline,
1110 "Offline time mismatch");
1111 TEST_ASSERT(crs->time[RUNSTATE_offline + 1] == 0xa5a5a5a5a5a5a5a5ULL,
1112 "Structure overrun");
1113 TEST_ASSERT(crs->state_entry_time == crs->time[0] +
1114 crs->time[1] + crs->time[2] + crs->time[3],
1115 "runstate times don't add up");
1116
1117
1118 /* Now switch to 64-bit mode */
1119 lm.u.long_mode = 1;
1120 vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &lm);
1121
1122 memset(rs, 0xa5, sizeof(*rs));
1123
1124 /* Don't change the address, just trigger a write */
1125 struct kvm_xen_vcpu_attr adj = {
1126 .type = KVM_XEN_VCPU_ATTR_TYPE_RUNSTATE_ADJUST,
1127 .u.runstate.state = (uint64_t)-1
1128 };
1129 vcpu_ioctl(vcpu, KVM_XEN_VCPU_SET_ATTR, &adj);
1130
1131 if (verbose)
1132 printf("64-bit runstate at %08lx\n", runstate_addr);
1133
1134 TEST_ASSERT(rs->state == rst.u.runstate.state, "Runstate mismatch");
1135 TEST_ASSERT(rs->state_entry_time == rst.u.runstate.state_entry_time,
1136 "State entry time mismatch");
1137 TEST_ASSERT(rs->time[RUNSTATE_running] == rst.u.runstate.time_running,
1138 "Running time mismatch");
1139 TEST_ASSERT(rs->time[RUNSTATE_runnable] == rst.u.runstate.time_runnable,
1140 "Runnable time mismatch");
1141 TEST_ASSERT(rs->time[RUNSTATE_blocked] == rst.u.runstate.time_blocked,
1142 "Blocked time mismatch");
1143 TEST_ASSERT(rs->time[RUNSTATE_offline] == rst.u.runstate.time_offline,
1144 "Offline time mismatch");
1145 TEST_ASSERT(rs->time[RUNSTATE_offline + 1] == 0xa5a5a5a5a5a5a5a5ULL,
1146 "Structure overrun");
1147
1148 TEST_ASSERT(rs->state_entry_time == rs->time[0] +
1149 rs->time[1] + rs->time[2] + rs->time[3],
1150 "runstate times don't add up");
1151 }
1152 }
1153
1154 kvm_vm_free(vm);
1155 return 0;
1156}