ARM: 8330/1: add VDSO user-space code

Place VDSO-related user-space code in arch/arm/kernel/vdso/.

It is almost completely written in C with some assembly helpers to
load the data page address, sample the counter, and fall back to
system calls when necessary.

The VDSO can service gettimeofday and clock_gettime when
CONFIG_ARM_ARCH_TIMER is enabled and the architected timer is present
(and correctly configured).  It reads the CP15-based virtual counter
to compute high-resolution timestamps.

Of particular note is that a post-processing step ("vdsomunge") is
necessary to produce a shared object which is architecturally allowed
to be used by both soft- and hard-float EABI programs.

The 2012 edition of the ARM ABI defines Tag_ABI_VFP_args = 3 "Code is
compatible with both the base and VFP variants; the user did not
permit non-variadic functions to pass FP parameters/results."
Unfortunately current toolchains do not support this tag, which is
ideally what we would use.

The best available option is to ensure that both EF_ARM_ABI_FLOAT_SOFT
and EF_ARM_ABI_FLOAT_HARD are unset in the ELF header's e_flags,
indicating that the shared object is "old" and should be accepted for
backward compatibility's sake.  While binutils < 2.24 appear to
produce a vdso.so with both flags clear, 2.24 always sets
EF_ARM_ABI_FLOAT_SOFT, with no way to inhibit this behavior.  So we
have to fix things up with a custom post-processing step.

In fact, the VDSO code in glibc does much less validation (including
checking these flags) than the code for handling conventional
file-backed shared libraries, so this is a bit moot unless glibc's
VDSO code becomes more strict.

Signed-off-by: Nathan Lynch <nathan_lynch@mentor.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

1 files changed, 282 insertions, 0 deletions

diff --git a/arch/arm/vdso/vgettimeofday.c b/arch/arm/vdso/vgettimeofday.c
new file mode 100644
index 000000000000..79214d5ff097
--- /dev/null
+++ b/arch/arm/vdso/vgettimeofday.c
@@ -0,0 +1,282 @@
+/*
+ * Copyright 2015 Mentor Graphics Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/compiler.h>
+#include <linux/hrtimer.h>
+#include <linux/time.h>
+#include <asm/arch_timer.h>
+#include <asm/barrier.h>
+#include <asm/bug.h>
+#include <asm/page.h>
+#include <asm/unistd.h>
+#include <asm/vdso_datapage.h>
+
+#ifndef CONFIG_AEABI
+#error This code depends on AEABI system call conventions
+#endif
+
+extern struct vdso_data *__get_datapage(void);
+
+static notrace u32 __vdso_read_begin(const struct vdso_data *vdata)
+{
+        u32 seq;
+repeat:
+        seq = ACCESS_ONCE(vdata->seq_count);
+        if (seq & 1) {
+                cpu_relax();
+                goto repeat;
+        }
+        return seq;
+}
+
+static notrace u32 vdso_read_begin(const struct vdso_data *vdata)
+{
+        u32 seq;
+
+        seq = __vdso_read_begin(vdata);
+
+        smp_rmb(); /* Pairs with smp_wmb in vdso_write_end */
+        return seq;
+}
+
+static notrace int vdso_read_retry(const struct vdso_data *vdata, u32 start)
+{
+        smp_rmb(); /* Pairs with smp_wmb in vdso_write_begin */
+        return vdata->seq_count != start;
+}
+
+static notrace long clock_gettime_fallback(clockid_t _clkid,
+                                           struct timespec *_ts)
+{
+        register struct timespec *ts asm("r1") = _ts;
+        register clockid_t clkid asm("r0") = _clkid;
+        register long ret asm ("r0");
+        register long nr asm("r7") = __NR_clock_gettime;
+
+        asm volatile(
+        "       swi #0\n"
+        : "=r" (ret)
+        : "r" (clkid), "r" (ts), "r" (nr)
+        : "memory");
+
+        return ret;
+}
+
+static notrace int do_realtime_coarse(struct timespec *ts,
+                                      struct vdso_data *vdata)
+{
+        u32 seq;
+
+        do {
+                seq = vdso_read_begin(vdata);
+
+                ts->tv_sec = vdata->xtime_coarse_sec;
+                ts->tv_nsec = vdata->xtime_coarse_nsec;
+
+        } while (vdso_read_retry(vdata, seq));
+
+        return 0;
+}
+
+static notrace int do_monotonic_coarse(struct timespec *ts,
+                                       struct vdso_data *vdata)
+{
+        struct timespec tomono;
+        u32 seq;
+
+        do {
+                seq = vdso_read_begin(vdata);
+
+                ts->tv_sec = vdata->xtime_coarse_sec;
+                ts->tv_nsec = vdata->xtime_coarse_nsec;
+
+                tomono.tv_sec = vdata->wtm_clock_sec;
+                tomono.tv_nsec = vdata->wtm_clock_nsec;
+
+        } while (vdso_read_retry(vdata, seq));
+
+        ts->tv_sec += tomono.tv_sec;
+        timespec_add_ns(ts, tomono.tv_nsec);
+
+        return 0;
+}
+
+#ifdef CONFIG_ARM_ARCH_TIMER
+
+static notrace u64 get_ns(struct vdso_data *vdata)
+{
+        u64 cycle_delta;
+        u64 cycle_now;
+        u64 nsec;
+
+        cycle_now = arch_counter_get_cntvct();
+
+        cycle_delta = (cycle_now - vdata->cs_cycle_last) & vdata->cs_mask;
+
+        nsec = (cycle_delta * vdata->cs_mult) + vdata->xtime_clock_snsec;
+        nsec >>= vdata->cs_shift;
+
+        return nsec;
+}
+
+static notrace int do_realtime(struct timespec *ts, struct vdso_data *vdata)
+{
+        u64 nsecs;
+        u32 seq;
+
+        do {
+                seq = vdso_read_begin(vdata);
+
+                if (!vdata->tk_is_cntvct)
+                        return -1;
+
+                ts->tv_sec = vdata->xtime_clock_sec;
+                nsecs = get_ns(vdata);
+
+        } while (vdso_read_retry(vdata, seq));
+
+        ts->tv_nsec = 0;
+        timespec_add_ns(ts, nsecs);
+
+        return 0;
+}
+
+static notrace int do_monotonic(struct timespec *ts, struct vdso_data *vdata)
+{
+        struct timespec tomono;
+        u64 nsecs;
+        u32 seq;
+
+        do {
+                seq = vdso_read_begin(vdata);
+
+                if (!vdata->tk_is_cntvct)
+                        return -1;
+
+                ts->tv_sec = vdata->xtime_clock_sec;
+                nsecs = get_ns(vdata);
+
+                tomono.tv_sec = vdata->wtm_clock_sec;
+                tomono.tv_nsec = vdata->wtm_clock_nsec;
+
+        } while (vdso_read_retry(vdata, seq));
+
+        ts->tv_sec += tomono.tv_sec;
+        ts->tv_nsec = 0;
+        timespec_add_ns(ts, nsecs + tomono.tv_nsec);
+
+        return 0;
+}
+
+#else /* CONFIG_ARM_ARCH_TIMER */
+
+static notrace int do_realtime(struct timespec *ts, struct vdso_data *vdata)
+{
+        return -1;
+}
+
+static notrace int do_monotonic(struct timespec *ts, struct vdso_data *vdata)
+{
+        return -1;
+}
+
+#endif /* CONFIG_ARM_ARCH_TIMER */
+
+notrace int __vdso_clock_gettime(clockid_t clkid, struct timespec *ts)
+{
+        struct vdso_data *vdata;
+        int ret = -1;
+
+        vdata = __get_datapage();
+
+        switch (clkid) {
+        case CLOCK_REALTIME_COARSE:
+                ret = do_realtime_coarse(ts, vdata);
+                break;
+        case CLOCK_MONOTONIC_COARSE:
+                ret = do_monotonic_coarse(ts, vdata);
+                break;
+        case CLOCK_REALTIME:
+                ret = do_realtime(ts, vdata);
+                break;
+        case CLOCK_MONOTONIC:
+                ret = do_monotonic(ts, vdata);
+                break;
+        default:
+                break;
+        }
+
+        if (ret)
+                ret = clock_gettime_fallback(clkid, ts);
+
+        return ret;
+}
+
+static notrace long gettimeofday_fallback(struct timeval *_tv,
+                                          struct timezone *_tz)
+{
+        register struct timezone *tz asm("r1") = _tz;
+        register struct timeval *tv asm("r0") = _tv;
+        register long ret asm ("r0");
+        register long nr asm("r7") = __NR_gettimeofday;
+
+        asm volatile(
+        "       swi #0\n"
+        : "=r" (ret)
+        : "r" (tv), "r" (tz), "r" (nr)
+        : "memory");
+
+        return ret;
+}
+
+notrace int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+        struct timespec ts;
+        struct vdso_data *vdata;
+        int ret;
+
+        vdata = __get_datapage();
+
+        ret = do_realtime(&ts, vdata);
+        if (ret)
+                return gettimeofday_fallback(tv, tz);
+
+        if (tv) {
+                tv->tv_sec = ts.tv_sec;
+                tv->tv_usec = ts.tv_nsec / 1000;
+        }
+        if (tz) {
+                tz->tz_minuteswest = vdata->tz_minuteswest;
+                tz->tz_dsttime = vdata->tz_dsttime;
+        }
+
+        return ret;
+}
+
+/* Avoid unresolved references emitted by GCC */
+
+void __aeabi_unwind_cpp_pr0(void)
+{
+}
+
+void __aeabi_unwind_cpp_pr1(void)
+{
+}
+
+void __aeabi_unwind_cpp_pr2(void)
+{
+}