ukvm,kernel: Replace pvclock with simplified tscclock

mato · mato · commit e3da88b964c4 · 2017-03-30T12:47:15.000+02:00
To enable multi-backend we need a clock that does not depend on any
backend-specific device. This change replaces the use of pvclock by the
ukvm target with:

- a simplified TSC-only implementation of tscclock
- a new hypercall to get wall clock time from the monitor
  (UKVM_HYPERCALL_WALLTIME).
- a new arch-dependent section in struct ukvm_boot_info, used to pass
  the (x86) TSC frequency to the guest.

Note that the monitor will now refuse to run on a host with an unstable
TSC, see the implementation notes in kernel/ukvm/tscclock.c for an
explanation.

Related changes also part of this commit:

- Add a simple test that the clock(s) work(s), in tests/test_time. The
  upper limit on how much is "too much" to sleep may need to be tweaked
  (or the test result ignored) on Travis.
- hypercall_poll() now blocks all signals except SIGINT and SIGTERM
  rather than restarting the ppoll() call which was incorrectly
  assuming (*ts) would be modified by ppoll().
diff --git a/kernel/Makefile b/kernel/Makefile
@@ -26,8 +26,7 @@ ee_printf.o \
 intr.o \
 lib.o \
 malloc.o \
-exit.o \
-pvclock.o
+exit.o
 
 UKVM_COBJS=\
 ukvm/kernel.o \
@@ -37,6 +36,7 @@ ukvm/platform.o \
 ukvm/platform_intr.o \
 ukvm/mem.o \
 ukvm/time.o \
+ukvm/tscclock.o \
 $(COMMON_COBJS)
 
 VIRTIO_COBJS=\
@@ -53,6 +53,7 @@ virtio/virtio_net.o \
 virtio/virtio_blk.o \
 virtio/tscclock.o \
 virtio/clock_subr.o \
+virtio/pvclock.o \
 $(COMMON_COBJS)
 
 HEADERS=\
diff --git a/kernel/kernel.h b/kernel/kernel.h
@@ -104,9 +104,6 @@ void *calloc(size_t nmemb, size_t size);
 void *realloc(void *ptr, size_t size);
 void *memalign(size_t alignment, size_t bytes);
 
-/* time.c: clocksource */
-void time_init(void);
-
 /* ee_printf.c: a third-party printf slightly modified and with
  *              snprintf added
  */
diff --git a/kernel/ukvm/kernel.c b/kernel/ukvm/kernel.c
@@ -33,7 +33,7 @@ void _start(struct ukvm_boot_info *bi)
     mem_init(bi->mem_size, bi->kernel_end);
     intr_init();
 
-    time_init();
+    time_init(bi->cpu.tsc_freq);
 
     intr_enable();
 
diff --git a/kernel/ukvm/kernel.h b/kernel/ukvm/kernel.h
@@ -32,4 +32,10 @@ void tss_load(uint16_t tss);
 
 void mem_init(uint64_t size, uint64_t _kernel_end);
 
+void time_init(uint64_t tsc_freq);
+
+/* tscclock.c: TSC-based clock */
+uint64_t tscclock_monotonic(void);
+int tscclock_init(uint64_t tsc_freq);
+uint64_t tscclock_epochoffset(void);
 #endif
diff --git a/kernel/ukvm/time.c b/kernel/ukvm/time.c
@@ -20,20 +20,20 @@
 
 #include "kernel.h"
 
-void time_init(void)
+void time_init(uint64_t tsc_freq)
 {
-    assert(pvclock_init() == 0);
+    assert(tscclock_init(tsc_freq) == 0);
 }
 
 uint64_t solo5_clock_monotonic(void)
 {
-    return pvclock_monotonic();
+    return tscclock_monotonic();
 }
 
 /* return wall time in nsecs */
 uint64_t solo5_clock_wall(void)
 {
-    return pvclock_monotonic() + pvclock_epochoffset();
+    return tscclock_monotonic() + tscclock_epochoffset();
 }
 
 int solo5_poll(uint64_t until_nsecs)
diff --git a/kernel/ukvm/tscclock.c b/kernel/ukvm/tscclock.c
@@ -0,0 +1,101 @@
+/* 
+ * Copyright (c) 2015-2017 Contributors as noted in the AUTHORS file
+ *
+ * This file is part of Solo5, a unikernel base layer.
+ *
+ * Permission to use, copy, modify, and/or distribute this software
+ * for any purpose with or without fee is hereby granted, provided
+ * that the above copyright notice and this permission notice appear
+ * in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "kernel.h"
+
+/* Wall clock offset at monotonic time base. */
+static uint64_t wc_epochoffset;
+
+/* Base time values at the last call to tscclock_monotonic(). */
+static uint64_t time_base;
+static uint64_t tsc_base;
+
+/* Multiplier for converting TSC ticks to nsecs. (0.32) fixed point. */
+static uint32_t tsc_mult;
+
+/*
+ * Beturn monotonic time using TSC clock.
+ */
+uint64_t tscclock_monotonic(void)
+{
+    uint64_t tsc_now, tsc_delta;
+
+    /*
+     * Update time_base (monotonic time) and tsc_base (TSC time).
+     */
+    tsc_now = cpu_rdtsc();
+    tsc_delta = tsc_now - tsc_base;
+    time_base += mul64_32(tsc_delta, tsc_mult);
+    tsc_base = tsc_now;
+
+    return time_base;
+}
+
+/*
+ * Initialise TSC clock.
+ *
+ * Implementation notes: This is a purely TSC-based clock with the following
+ * requirements:
+ *
+ * 1. The host TSC MUST be invariant, as defined in Intel SDM section 17.15.1
+ * "Invariant TSC".
+ * 2. The host hypervisor MUST NOT implement any RDTSC emulation.
+ *
+ * It is up to the monitor to ensure that these requirements are met, and to
+ * supply the TSC frequency to the guest.
+ */
+int tscclock_init(uint64_t tsc_freq)
+{
+    /*
+     * Calculate TSC scaling multiplier.
+     *
+     * (0.32) tsc_mult = NSEC_PER_SEC (32.32) / tsc_freq (32.0)
+     */
+    tsc_mult = (NSEC_PER_SEC << 32) / tsc_freq;
+
+    /*
+     * Monotonic time begins at tsc_base (first read of TSC before
+     * calibration).
+     */
+    tsc_base = cpu_rdtsc();
+    time_base = mul64_32(tsc_base, tsc_mult);
+
+    /*
+     * Compute wall clock epoch offset by subtracting monotonic time_base from
+     * wall time at boot.
+     *
+     * TODO: This arrangement minimises the use of hypercalls, but is subject
+     * to clock skew over time and cannot get corrections from the host (via
+     * e.g. NTP). 
+     */
+    struct ukvm_walltime t;
+    ukvm_do_hypercall(UKVM_HYPERCALL_WALLTIME, &t);
+    wc_epochoffset = t.nsecs - time_base;
+
+    return 0;
+}
+
+/*
+ * Return epoch offset (wall time offset to monotonic clock start).
+ */
+uint64_t tscclock_epochoffset(void)
+{
+	return wc_epochoffset;
+}
diff --git a/kernel/virtio/kernel.h b/kernel/virtio/kernel.h
@@ -30,6 +30,8 @@ void mem_init(struct multiboot_info *mb);
 void serial_init(void);
 void serial_putc(char a);
 
+void time_init(void);
+
 /* tscclock.c: TSC/PIT-based clock and sleep */
 int tscclock_init(void);
 uint64_t tscclock_monotonic(void);
diff --git a/kernel/virtio/pvclock.c b/kernel/virtio/pvclock.c
diff --git a/tests/Makefile b/tests/Makefile
@@ -16,7 +16,7 @@
 # NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-TESTDIRS=test_hello test_globals test_ping_serve test_blk test_exception test_fpu
+TESTDIRS=test_hello test_globals test_ping_serve test_blk test_exception test_fpu test_time
 
 UKVM_TESTS=$(subst test, _test_ukvm, $(TESTDIRS))
 VIRTIO_TESTS=$(subst test, _test_virtio, $(TESTDIRS))
diff --git a/tests/run-tests.sh b/tests/run-tests.sh
@@ -238,6 +238,7 @@ if [ -n "${BUILD_UKVM}" ]; then
     add_test test_globals.ukvm
     add_test test_exception.ukvm:-a
     add_test test_fpu.ukvm
+    add_test test_time.ukvm
     add_test test_blk.ukvm:-d
     add_test test_ping_serve.ukvm:-n:limit
 fi
@@ -246,6 +247,7 @@ if [ -n "${BUILD_VIRTIO}" ]; then
     add_test test_globals.virtio
     add_test test_exception.virtio:-a
     add_test test_fpu.virtio
+    add_test test_time.virtio
     add_test test_blk.virtio:-d
     add_test test_ping_serve.virtio:-n:limit
 fi
diff --git a/tests/test_time/Makefile b/tests/test_time/Makefile
@@ -0,0 +1,23 @@
+# Copyright (c) 2015-2017 Contributors as noted in the AUTHORS file
+#
+# This file is part of Solo5, a unikernel base layer.
+#
+# Permission to use, copy, modify, and/or distribute this software
+# for any purpose with or without fee is hereby granted, provided
+# that the above copyright notice and this permission notice appear
+# in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+# AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
+# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+# OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+UKVM_TARGETS=test_time.ukvm ukvm-bin
+VIRTIO_TARGETS=test_time.virtio
+UKVM_MODULES=
+
+include ../Makefile.tests
diff --git a/tests/test_time/test_time.c b/tests/test_time/test_time.c
@@ -0,0 +1,80 @@
+/* 
+ * Copyright (c) 2015-2017 Contributors as noted in the AUTHORS file
+ *
+ * This file is part of Solo5, a unikernel base layer.
+ *
+ * Permission to use, copy, modify, and/or distribute this software
+ * for any purpose with or without fee is hereby granted, provided
+ * that the above copyright notice and this permission notice appear
+ * in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
+ * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
+ * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+ * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+ * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "solo5.h"
+#include "../../kernel/lib.c"
+
+static void puts(const char *s)
+{
+    solo5_console_write(s, strlen(s));
+}
+
+#define NSEC_PER_SEC 1000000000ULL
+
+int solo5_app_main(char *cmdline __attribute__((unused)))
+{
+    puts("\n**** Solo5 standalone test_time ****\n\n");
+
+    /*
+     * Verify that monotonic time is passing
+     */
+    uint64_t ta, tb;
+    ta = solo5_clock_monotonic();
+    tb = solo5_clock_monotonic();
+    if (!(tb > ta)) {
+        puts("ERROR: time is not passing\n");
+        return 1;
+    }
+
+    /* 
+     * The monitor is configured with no I/O modules for this test so
+     * solo5_poll() is equivalent to a sleep here.
+     */
+    ta = solo5_clock_monotonic();
+    solo5_poll(ta + NSEC_PER_SEC);
+    tb = solo5_clock_monotonic();
+    /*
+     * Verify that we did not sleep less than requested (see above).
+     */
+    if ((tb - ta) < NSEC_PER_SEC) {
+        puts("ERROR: slept too little\n");
+        return 1;
+    }
+    /*
+     * Verify that we did not sleep more than requested, within reason
+     * (scheduling delays, general inaccuracy of the current timing code).
+     */
+    if ((tb - ta) > (NSEC_PER_SEC + 20000000ULL)) {
+        puts("ERROR: slept too much\n");
+        return 1;
+    }
+
+    /*
+     * Verify that wall time is 2017 or later
+     */
+    ta = solo5_clock_wall();
+    if (ta < (1483228800ULL * NSEC_PER_SEC)) {
+        puts("ERROR: wall time is not 2017 or later\n");
+        return 1;
+    }
+
+    puts("SUCCESS\n");
+    return 0;
+}
diff --git a/ukvm/ukvm_core.c b/ukvm/ukvm_core.c
@@ -29,6 +29,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/mman.h>
+#include <time.h>
 #include <unistd.h>
 
 #include "ukvm.h"
@@ -76,6 +77,17 @@ int ukvm_core_register_vmexit(ukvm_vmexit_fn_t fn)
     return 0;
 }
 
+static void hypercall_walltime(struct ukvm_hv *hv, ukvm_gpa_t gpa)
+{
+    struct ukvm_walltime *t =
+        UKVM_CHECKED_GPA_P(hv, gpa, sizeof (struct ukvm_walltime));
+    struct timespec ts;
+
+    int rc = clock_gettime(CLOCK_REALTIME, &ts);
+    assert(rc == 0);
+    t->nsecs = (ts.tv_sec * 1000000000ULL) + ts.tv_nsec;
+}
+
 static void hypercall_puts(struct ukvm_hv *hv, ukvm_gpa_t gpa)
 {
     struct ukvm_puts *p =
@@ -86,6 +98,7 @@ static void hypercall_puts(struct ukvm_hv *hv, ukvm_gpa_t gpa)
 
 static struct pollfd pollfds[NUM_MODULES];
 static int npollfds = 0;
+static sigset_t pollsigmask;
 
 int ukvm_core_register_pollfd(int fd)
 {
@@ -108,19 +121,27 @@ static void hypercall_poll(struct ukvm_hv *hv, ukvm_gpa_t gpa)
     ts.tv_sec = t->timeout_nsecs / 1000000000ULL;
     ts.tv_nsec = t->timeout_nsecs % 1000000000ULL;
 
-    do {
-        rc = ppoll(pollfds, npollfds, &ts, NULL);
-    } while (rc == -1 && errno == EINTR);
+    rc = ppoll(pollfds, npollfds, &ts, &pollsigmask);
     assert(rc >= 0);
     t->ret = rc;
 }
 
 static int setup(struct ukvm_hv *hv)
 {
+    assert(ukvm_core_register_hypercall(UKVM_HYPERCALL_WALLTIME,
+                hypercall_walltime) == 0);
     assert(ukvm_core_register_hypercall(UKVM_HYPERCALL_PUTS,
                 hypercall_puts) == 0);
     assert(ukvm_core_register_hypercall(UKVM_HYPERCALL_POLL,
                 hypercall_poll) == 0);
+
+    /*
+     * XXX: This needs documenting / coordination with the top-level caller.
+     */
+    sigfillset(&pollsigmask);
+    sigdelset(&pollsigmask, SIGTERM);
+    sigdelset(&pollsigmask, SIGINT);
+
     return 0;
 }
 
diff --git a/ukvm/ukvm_guest.h b/ukvm/ukvm_guest.h
diff --git a/ukvm/ukvm_hv_kvm_x86_64.c b/ukvm/ukvm_hv_kvm_x86_64.c

Original file line number	Diff line number	Diff line change
`@@ -20,20 +20,20 @@`
`20`	`20`
`21`	`21`	`#include "kernel.h"`
`22`	`22`
`23`		`-void time_init(void)`
	`23`	`+void time_init(uint64_t tsc_freq)`
`24`	`24`	`{`
`25`		`- assert(pvclock_init() == 0);`
	`25`	`+ assert(tscclock_init(tsc_freq) == 0);`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`uint64_t solo5_clock_monotonic(void)`
`29`	`29`	`{`
`30`		`- return pvclock_monotonic();`
	`30`	`+ return tscclock_monotonic();`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`/* return wall time in nsecs */`
`34`	`34`	`uint64_t solo5_clock_wall(void)`
`35`	`35`	`{`
`36`		`- return pvclock_monotonic() + pvclock_epochoffset();`
	`36`	`+ return tscclock_monotonic() + tscclock_epochoffset();`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`int solo5_poll(uint64_t until_nsecs)`