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