KVM: selftests: Compare wall time from xen shinfo against KVM_GET_CLOCK

xen_shinfo_test is observed to be flaky failing sporadically with
"VM time too old". With min_ts/max_ts debug print added:

Wall clock (v 3269818) 1704906491.986255664
Time info 1: v 1282712 tsc 33530585736 time 14014430025 mul 3587552223 shift 4294967295 flags 1
Time info 2: v 1282712 tsc 33530585736 time 14014430025 mul 3587552223 shift 4294967295 flags 1
min_ts: 1704906491.986312153
max_ts: 1704906506.001006963
==== Test Assertion Failure ====
  x86_64/xen_shinfo_test.c:1003: cmp_timespec(&min_ts, &vm_ts) <= 0
  pid=32724 tid=32724 errno=4 - Interrupted system call
     1	0x00000000004030ad: main at xen_shinfo_test.c:1003
     2	0x00007fca6b23feaf: ?? ??:0
     3	0x00007fca6b23ff5f: ?? ??:0
     4	0x0000000000405e04: _start at ??:?
  VM time too old

The test compares wall clock data from shinfo (which is the output of
kvm_get_wall_clock_epoch()) against clock_gettime(CLOCK_REALTIME) in the
host system before the VM is created. In the example above, it compares

 shinfo: 1704906491.986255664 vs min_ts: 1704906491.986312153

and fails as the later is greater than the former.  While this sounds like
a sane test, it doesn't pass reality check: kvm_get_wall_clock_epoch()
calculates guest's epoch (realtime when the guest was created) by
subtracting kvmclock from the current realtime and the calculation happens
when shinfo is setup. The problem is that kvmclock is a raw clock and
realtime clock is affected by NTP. This means that if realtime ticks with a
slightly reduced frequency, "guest's epoch" calculated by
kvm_get_wall_clock_epoch() will actually tick backwards! This is not a big
issue from guest's perspective as the guest can't really observe this but
this epoch can't be compared with a fixed clock_gettime() on the host.

Replace the check with comparing wall clock data from shinfo to
KVM_GET_CLOCK. The later gives both realtime and kvmclock so guest's epoch
can be calculated by subtraction. Note, CLOCK_REALTIME is susceptible to
leap seconds jumps but there's no better alternative in KVM at this
moment. Leave a comment and accept 1s delta.

Reported-by: Jan Richter <jarichte@redhat.com>
Signed-off-by: Vitaly Kuznetsov <vkuznets@redhat.com>
Link: https://lore.kernel.org/r/20240206151950.31174-1-vkuznets@redhat.com
Signed-off-by: Sean Christopherson <seanjc@google.com>

diff --git a/tools/testing/selftests/kvm/x86_64/xen_shinfo_test.c b/tools/testing/selftests/kvm/x86_64/xen_shinfo_test.c
index 7d707d8068a46de4ea173818bc092c4e9f910ffb..1e44494fa4fb86d85c2205dffe44b47bdd2c0b2d 100644 (file)
--- a/tools/testing/selftests/kvm/x86_64/xen_shinfo_test.c
+++ b/tools/testing/selftests/kvm/x86_64/xen_shinfo_test.c
@@ -380,20 +380,6 @@ wait_for_timer:
        GUEST_SYNC(TEST_DONE);
 }
 
-static int cmp_timespec(struct timespec *a, struct timespec *b)
-{
-       if (a->tv_sec > b->tv_sec)
-               return 1;
-       else if (a->tv_sec < b->tv_sec)
-               return -1;
-       else if (a->tv_nsec > b->tv_nsec)
-               return 1;
-       else if (a->tv_nsec < b->tv_nsec)
-               return -1;
-       else
-               return 0;
-}
-
 static struct shared_info *shinfo;
 static struct vcpu_info *vinfo;
 static struct kvm_vcpu *vcpu;
@@ -449,7 +435,6 @@ static void *juggle_shinfo_state(void *arg)
 
 int main(int argc, char *argv[])
 {
-       struct timespec min_ts, max_ts, vm_ts;
        struct kvm_xen_hvm_attr evt_reset;
        struct kvm_vm *vm;
        pthread_t thread;
@@ -468,8 +453,6 @@ int main(int argc, char *argv[])
        bool do_evtchn_tests = do_eventfd_tests && !!(xen_caps & KVM_XEN_HVM_CONFIG_EVTCHN_SEND);
        bool has_shinfo_hva = !!(xen_caps & KVM_XEN_HVM_CONFIG_SHARED_INFO_HVA);
 
-       clock_gettime(CLOCK_REALTIME, &min_ts);
-
        vm = vm_create_with_one_vcpu(&vcpu, guest_code);
 
        /* Map a region for the shared_info page */
@@ -1010,7 +993,6 @@ int main(int argc, char *argv[])
        vm_ioctl(vm, KVM_XEN_HVM_SET_ATTR, &evt_reset);
 
        alarm(0);
-       clock_gettime(CLOCK_REALTIME, &max_ts);
 
        /*
         * Just a *really* basic check that things are being put in the
@@ -1019,6 +1001,8 @@ int main(int argc, char *argv[])
         */
        struct pvclock_wall_clock *wc;
        struct pvclock_vcpu_time_info *ti, *ti2;
+       struct kvm_clock_data kcdata;
+       long long delta;
 
        wc = addr_gpa2hva(vm, SHINFO_REGION_GPA + 0xc00);
        ti = addr_gpa2hva(vm, SHINFO_REGION_GPA + 0x40 + 0x20);
@@ -1034,12 +1018,34 @@ int main(int argc, char *argv[])
                       ti2->tsc_shift, ti2->flags);
        }
 
-       vm_ts.tv_sec = wc->sec;
-       vm_ts.tv_nsec = wc->nsec;
        TEST_ASSERT(wc->version && !(wc->version & 1),
                    "Bad wallclock version %x", wc->version);
-       TEST_ASSERT(cmp_timespec(&min_ts, &vm_ts) <= 0, "VM time too old");
-       TEST_ASSERT(cmp_timespec(&max_ts, &vm_ts) >= 0, "VM time too new");
+
+       vm_ioctl(vm, KVM_GET_CLOCK, &kcdata);
+
+       if (kcdata.flags & KVM_CLOCK_REALTIME) {
+               if (verbose) {
+                       printf("KVM_GET_CLOCK clock: %lld.%09lld\n",
+                              kcdata.clock / NSEC_PER_SEC, kcdata.clock % NSEC_PER_SEC);
+                       printf("KVM_GET_CLOCK realtime: %lld.%09lld\n",
+                              kcdata.realtime / NSEC_PER_SEC, kcdata.realtime % NSEC_PER_SEC);
+               }
+
+               delta = (wc->sec * NSEC_PER_SEC + wc->nsec) - (kcdata.realtime - kcdata.clock);
+
+               /*
+                * KVM_GET_CLOCK gives CLOCK_REALTIME which jumps on leap seconds updates but
+                * unfortunately KVM doesn't currently offer a CLOCK_TAI alternative. Accept 1s
+                * delta as testing clock accuracy is not the goal here. The test just needs to
+                * check that the value in shinfo is somewhat sane.
+                */
+               TEST_ASSERT(llabs(delta) < NSEC_PER_SEC,
+                           "Guest's epoch from shinfo %d.%09d differs from KVM_GET_CLOCK %lld.%lld",
+                           wc->sec, wc->nsec, (kcdata.realtime - kcdata.clock) / NSEC_PER_SEC,
+                           (kcdata.realtime - kcdata.clock) % NSEC_PER_SEC);
+       } else {
+               pr_info("Missing KVM_CLOCK_REALTIME, skipping shinfo epoch sanity check\n");
+       }
 
        TEST_ASSERT(ti->version && !(ti->version & 1),
                    "Bad time_info version %x", ti->version);