improve clock_gettime and adapt it to support slightly-broken vdso

these changes are motivated by a functionally similar patch by Hauke
Mehrtens to address the needs of the new mips vdso clock_gettime,
which wrongly fails with ENOSYS rather than falling back to making a
syscall for clock ids it cannot handle from userspace. in the process
of preparing to handle that case, it was noticed that the old
clock_gettime use of the vdso was actually wrong with respect to error
handling -- the tail call to the vdso function failed to set errno and
instead returned an error code.

since tail calls to vdso are no longer possible and since the plain
syscall code is now needed as a fallback path anyway, it does not make
sense to use a function pointer to call the plain syscall code path.
instead, it's inlined at the end of the main clock_gettime function.

the new code also avoids the need to test for initialization of the
vdso function pointer by statically initializing it to a self-init
function, and eliminates redundant loads from the volatile pointer
object.

finally, the use of a_cas_p on an object of type other than void *,
which is not permitted aliasing, is replaced by using an object with
the correct type and casting the value.

diff --git a/src/time/clock_gettime.c b/src/time/clock_gettime.c
index 1572de0ef0029eb94b53a9928cd0a9fc57684d6a..241288042d64c36ce13f4506a5d0f5a8695a7ac1 100644 (file)
--- a/src/time/clock_gettime.c
+++ b/src/time/clock_gettime.c
@@ -5,37 +5,54 @@
 #include "libc.h"
 #include "atomic.h"
 
-static int sc_clock_gettime(clockid_t clk, struct timespec *ts)
+#ifdef VDSO_CGT_SYM
+
+void *__vdsosym(const char *, const char *);
+
+static void *volatile vdso_func;
+
+static int cgt_init(clockid_t clk, struct timespec *ts)
 {
-       int r = __syscall(SYS_clock_gettime, clk, ts);
-       if (!r) return r;
-       if (r == -ENOSYS) {
-               if (clk == CLOCK_REALTIME) {
-                       __syscall(SYS_gettimeofday, ts, 0);
-                       ts->tv_nsec = (int)ts->tv_nsec * 1000;
-                       return 0;
-               }
-               r = -EINVAL;
-       }
-       errno = -r;
-       return -1;
+       void *p = __vdsosym(VDSO_CGT_VER, VDSO_CGT_SYM);
+       int (*f)(clockid_t, struct timespec *) =
+               (int (*)(clockid_t, struct timespec *))p;
+       a_cas_p(&vdso_func, (void *)cgt_init, p);
+       return f ? f(clk, ts) : -ENOSYS;
 }
 
-void *__vdsosym(const char *, const char *);
+static void *volatile vdso_func = (void *)cgt_init;
+
+#endif
 
 int __clock_gettime(clockid_t clk, struct timespec *ts)
 {
+       int r;
+
 #ifdef VDSO_CGT_SYM
-       static int (*volatile cgt)(clockid_t, struct timespec *);
-       if (!cgt) {
-               void *f = __vdsosym(VDSO_CGT_VER, VDSO_CGT_SYM);
-               if (!f) f = (void *)sc_clock_gettime;
-               a_cas_p(&cgt, 0, f);
+       int (*f)(clockid_t, struct timespec *) =
+               (int (*)(clockid_t, struct timespec *))vdso_func;
+       if (f) {
+               r = f(clk, ts);
+               if (!r) return r;
+               if (r == -EINVAL) return __syscall_ret(r);
+               /* Fall through on errors other than EINVAL. Some buggy
+                * vdso implementations return ENOSYS for clocks they
+                * can't handle, rather than making the syscall. This
+                * also handles the case where cgt_init fails to find
+                * a vdso function to use. */
        }
-       return cgt(clk, ts);
-#else
-       return sc_clock_gettime(clk, ts);
 #endif
+
+       r = __syscall(SYS_clock_gettime, clk, ts);
+       if (r == -ENOSYS) {
+               if (clk == CLOCK_REALTIME) {
+                       __syscall(SYS_gettimeofday, ts, 0);
+                       ts->tv_nsec = (int)ts->tv_nsec * 1000;
+                       return 0;
+               }
+               r = -EINVAL;
+       }
+       return __syscall_ret(r);
 }
 
 weak_alias(__clock_gettime, clock_gettime);