6 files changed, 177 insertions, 67 deletions

diff --git a/arch/tile/kernel/smp.c b/arch/tile/kernel/smp.c
index 01e8ab29f43a..19eaa62d456a 100644
--- a/arch/tile/kernel/smp.c
+++ b/arch/tile/kernel/smp.c
@@ -183,6 +183,7 @@ void flush_icache_range(unsigned long start, unsigned long end)
                 preempt_enable();
         }
 }
+EXPORT_SYMBOL(flush_icache_range);
 
 
 /* Called when smp_send_reschedule() triggers IRQ_RESCHEDULE. */
diff --git a/arch/tile/kernel/time.c b/arch/tile/kernel/time.c
index d8fbc289e680..c1b362277fb7 100644
--- a/arch/tile/kernel/time.c
+++ b/arch/tile/kernel/time.c
@@ -249,33 +249,52 @@ cycles_t ns2cycles(unsigned long nsecs)
 
 void update_vsyscall_tz(void)
 {
-        /* Userspace gettimeofday will spin while this value is odd. */
-        ++vdso_data->tz_update_count;
-        smp_wmb();
+        write_seqcount_begin(&vdso_data->tz_seq);
         vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
         vdso_data->tz_dsttime = sys_tz.tz_dsttime;
-        smp_wmb();
-        ++vdso_data->tz_update_count;
+        write_seqcount_end(&vdso_data->tz_seq);
 }
 
 void update_vsyscall(struct timekeeper *tk)
 {
-        struct timespec *wtm = &tk->wall_to_monotonic;
-        struct clocksource *clock = tk->tkr.clock;
-
-        if (clock != &cycle_counter_cs)
+        if (tk->tkr.clock != &cycle_counter_cs)
                 return;
 
-        /* Userspace gettimeofday will spin while this value is odd. */
-        ++vdso_data->tb_update_count;
-        smp_wmb();
-        vdso_data->xtime_tod_stamp = tk->tkr.cycle_last;
-        vdso_data->xtime_clock_sec = tk->xtime_sec;
-        vdso_data->xtime_clock_nsec = tk->tkr.xtime_nsec;
-        vdso_data->wtom_clock_sec = wtm->tv_sec;
-        vdso_data->wtom_clock_nsec = wtm->tv_nsec;
-        vdso_data->mult = tk->tkr.mult;
-        vdso_data->shift = tk->tkr.shift;
-        smp_wmb();
-        ++vdso_data->tb_update_count;
+        write_seqcount_begin(&vdso_data->tb_seq);
+
+        vdso_data->cycle_last           = tk->tkr.cycle_last;
+        vdso_data->mask                 = tk->tkr.mask;
+        vdso_data->mult                 = tk->tkr.mult;
+        vdso_data->shift                = tk->tkr.shift;
+
+        vdso_data->wall_time_sec        = tk->xtime_sec;
+        vdso_data->wall_time_snsec      = tk->tkr.xtime_nsec;
+
+        vdso_data->monotonic_time_sec   = tk->xtime_sec
+                                        + tk->wall_to_monotonic.tv_sec;
+        vdso_data->monotonic_time_snsec = tk->tkr.xtime_nsec
+                                        + ((u64)tk->wall_to_monotonic.tv_nsec
+                                                << tk->tkr.shift);
+        while (vdso_data->monotonic_time_snsec >=
+                                        (((u64)NSEC_PER_SEC) << tk->tkr.shift)) {
+                vdso_data->monotonic_time_snsec -=
+                                        ((u64)NSEC_PER_SEC) << tk->tkr.shift;
+                vdso_data->monotonic_time_sec++;
+        }
+
+        vdso_data->wall_time_coarse_sec = tk->xtime_sec;
+        vdso_data->wall_time_coarse_nsec = (long)(tk->tkr.xtime_nsec >>
+                                                 tk->tkr.shift);
+
+        vdso_data->monotonic_time_coarse_sec =
+                vdso_data->wall_time_coarse_sec + tk->wall_to_monotonic.tv_sec;
+        vdso_data->monotonic_time_coarse_nsec =
+                vdso_data->wall_time_coarse_nsec + tk->wall_to_monotonic.tv_nsec;
+
+        while (vdso_data->monotonic_time_coarse_nsec >= NSEC_PER_SEC) {
+                vdso_data->monotonic_time_coarse_nsec -= NSEC_PER_SEC;
+                vdso_data->monotonic_time_coarse_sec++;
+        }
+
+        write_seqcount_end(&vdso_data->tb_seq);
 }
diff --git a/arch/tile/kernel/traps.c b/arch/tile/kernel/traps.c
index f3ceb6308e42..86900ccd4977 100644
--- a/arch/tile/kernel/traps.c
+++ b/arch/tile/kernel/traps.c
@@ -277,7 +277,7 @@ void __kprobes do_trap(struct pt_regs *regs, int fault_num,
                 if (fixup_exception(regs))  /* ILL_TRANS or UNALIGN_DATA */
                         return;
                 if (fault_num >= 0 &&
-                    fault_num < sizeof(int_name)/sizeof(int_name[0]) &&
+                    fault_num < ARRAY_SIZE(int_name) &&
                     int_name[fault_num] != NULL)
                         name = int_name[fault_num];
                 else
diff --git a/arch/tile/kernel/vdso/vdso.lds.S b/arch/tile/kernel/vdso/vdso.lds.S
index 041cd6c39c83..731529f3f06f 100644
--- a/arch/tile/kernel/vdso/vdso.lds.S
+++ b/arch/tile/kernel/vdso/vdso.lds.S
@@ -82,6 +82,8 @@ VERSION
                 __vdso_rt_sigreturn;
                 __vdso_gettimeofday;
                 gettimeofday;
+                __vdso_clock_gettime;
+                clock_gettime;
         local:*;
         };
 }
diff --git a/arch/tile/kernel/vdso/vgettimeofday.c b/arch/tile/kernel/vdso/vgettimeofday.c
index e933fb9fbf5c..8bb21eda07d8 100644
--- a/arch/tile/kernel/vdso/vgettimeofday.c
+++ b/arch/tile/kernel/vdso/vgettimeofday.c
@@ -15,6 +15,7 @@
 #define VDSO_BUILD  /* avoid some shift warnings for -m32 in <asm/page.h> */
 #include <linux/time.h>
 #include <asm/timex.h>
+#include <asm/unistd.h>
 #include <asm/vdso.h>
 
 #if CHIP_HAS_SPLIT_CYCLE()
@@ -35,6 +36,11 @@ static inline cycles_t get_cycles_inline(void)
 #define get_cycles get_cycles_inline
 #endif
 
+struct syscall_return_value {
+        long value;
+        long error;
+};
+
 /*
  * Find out the vDSO data page address in the process address space.
  */
@@ -50,59 +56,143 @@ inline unsigned long get_datapage(void)
         return ret;
 }
 
-int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
+static inline u64 vgetsns(struct vdso_data *vdso)
+{
+        return ((get_cycles() - vdso->cycle_last) & vdso->mask) * vdso->mult;
+}
+
+static inline int do_realtime(struct vdso_data *vdso, struct timespec *ts)
+{
+        unsigned count;
+        u64 ns;
+
+        do {
+                count = read_seqcount_begin(&vdso->tb_seq);
+                ts->tv_sec = vdso->wall_time_sec;
+                ns = vdso->wall_time_snsec;
+                ns += vgetsns(vdso);
+                ns >>= vdso->shift;
+        } while (unlikely(read_seqcount_retry(&vdso->tb_seq, count)));
+
+        ts->tv_sec += __iter_div_u64_rem(ns, NSEC_PER_SEC, &ns);
+        ts->tv_nsec = ns;
+
+        return 0;
+}
+
+static inline int do_monotonic(struct vdso_data *vdso, struct timespec *ts)
+{
+        unsigned count;
+        u64 ns;
+
+        do {
+                count = read_seqcount_begin(&vdso->tb_seq);
+                ts->tv_sec = vdso->monotonic_time_sec;
+                ns = vdso->monotonic_time_snsec;
+                ns += vgetsns(vdso);
+                ns >>= vdso->shift;
+        } while (unlikely(read_seqcount_retry(&vdso->tb_seq, count)));
+
+        ts->tv_sec += __iter_div_u64_rem(ns, NSEC_PER_SEC, &ns);
+        ts->tv_nsec = ns;
+
+        return 0;
+}
+
+static inline int do_realtime_coarse(struct vdso_data *vdso,
+                                     struct timespec *ts)
+{
+        unsigned count;
+
+        do {
+                count = read_seqcount_begin(&vdso->tb_seq);
+                ts->tv_sec = vdso->wall_time_coarse_sec;
+                ts->tv_nsec = vdso->wall_time_coarse_nsec;
+        } while (unlikely(read_seqcount_retry(&vdso->tb_seq, count)));
+
+        return 0;
+}
+
+static inline int do_monotonic_coarse(struct vdso_data *vdso,
+                                      struct timespec *ts)
 {
-        cycles_t cycles;
-        unsigned long count, sec, ns;
-        volatile struct vdso_data *vdso_data;
+        unsigned count;
+
+        do {
+                count = read_seqcount_begin(&vdso->tb_seq);
+                ts->tv_sec = vdso->monotonic_time_coarse_sec;
+                ts->tv_nsec = vdso->monotonic_time_coarse_nsec;
+        } while (unlikely(read_seqcount_retry(&vdso->tb_seq, count)));
+
+        return 0;
+}
+
+struct syscall_return_value __vdso_gettimeofday(struct timeval *tv,
+                                                struct timezone *tz)
+{
+        struct syscall_return_value ret = { 0, 0 };
+        unsigned count;
+        struct vdso_data *vdso = (struct vdso_data *)get_datapage();
 
-        vdso_data = (struct vdso_data *)get_datapage();
         /* The use of the timezone is obsolete, normally tz is NULL. */
         if (unlikely(tz != NULL)) {
-                while (1) {
-                        /* Spin until the update finish. */
-                        count = vdso_data->tz_update_count;
-                        if (count & 1)
-                                continue;
-
-                        tz->tz_minuteswest = vdso_data->tz_minuteswest;
-                        tz->tz_dsttime = vdso_data->tz_dsttime;
-
-                        /* Check whether updated, read again if so. */
-                        if (count == vdso_data->tz_update_count)
-                                break;
-                }
+                do {
+                        count = read_seqcount_begin(&vdso->tz_seq);
+                        tz->tz_minuteswest = vdso->tz_minuteswest;
+                        tz->tz_dsttime = vdso->tz_dsttime;
+                } while (unlikely(read_seqcount_retry(&vdso->tz_seq, count)));
         }
 
         if (unlikely(tv == NULL))
-                return 0;
-
-        while (1) {
-                /* Spin until the update finish. */
-                count = vdso_data->tb_update_count;
-                if (count & 1)
-                        continue;
-
-                sec = vdso_data->xtime_clock_sec;
-                cycles = get_cycles() - vdso_data->xtime_tod_stamp;
-                ns = (cycles * vdso_data->mult) + vdso_data->xtime_clock_nsec;
-                ns >>= vdso_data->shift;
-
-                if (ns >= NSEC_PER_SEC) {
-                        ns -= NSEC_PER_SEC;
-                        sec += 1;
-                }
-
-                /* Check whether updated, read again if so. */
-                if (count == vdso_data->tb_update_count)
-                        break;
-        }
+                return ret;
 
-        tv->tv_sec = sec;
-        tv->tv_usec = ns / 1000;
+        do_realtime(vdso, (struct timespec *)tv);
+        tv->tv_usec /= 1000;
 
-        return 0;
+        return ret;
 }
 
 int gettimeofday(struct timeval *tv, struct timezone *tz)
         __attribute__((weak, alias("__vdso_gettimeofday")));
+
+static struct syscall_return_value vdso_fallback_gettime(long clock,
+                                                         struct timespec *ts)
+{
+        struct syscall_return_value ret;
+        __asm__ __volatile__ (
+                "swint1"
+                : "=R00" (ret.value), "=R01" (ret.error)
+                : "R10" (__NR_clock_gettime), "R00" (clock), "R01" (ts)
+                : "r2", "r3", "r4", "r5", "r6", "r7",
+                "r8",  "r9", "r11", "r12", "r13", "r14", "r15",
+                "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
+                "r24", "r25", "r26", "r27", "r28", "r29", "memory");
+        return ret;
+}
+
+struct syscall_return_value __vdso_clock_gettime(clockid_t clock,
+                                                 struct timespec *ts)
+{
+        struct vdso_data *vdso = (struct vdso_data *)get_datapage();
+        struct syscall_return_value ret = { 0, 0 };
+
+        switch (clock) {
+        case CLOCK_REALTIME:
+                do_realtime(vdso, ts);
+                return ret;
+        case CLOCK_MONOTONIC:
+                do_monotonic(vdso, ts);
+                return ret;
+        case CLOCK_REALTIME_COARSE:
+                do_realtime_coarse(vdso, ts);
+                return ret;
+        case CLOCK_MONOTONIC_COARSE:
+                do_monotonic_coarse(vdso, ts);
+                return ret;
+        default:
+                return vdso_fallback_gettime(clock, ts);
+        }
+}
+
+int clock_gettime(clockid_t clock, struct timespec *ts)
+        __attribute__((weak, alias("__vdso_clock_gettime")));
diff --git a/arch/tile/kernel/vmlinux.lds.S b/arch/tile/kernel/vmlinux.lds.S
index f1819423ffc9..0e059a0101ea 100644
--- a/arch/tile/kernel/vmlinux.lds.S
+++ b/arch/tile/kernel/vmlinux.lds.S
@@ -66,11 +66,9 @@ SECTIONS
 
   . = ALIGN(PAGE_SIZE);
   __init_begin = .;
-  VMLINUX_SYMBOL(_sinitdata) = .;
   INIT_DATA_SECTION(16) :data =0
   PERCPU_SECTION(L2_CACHE_BYTES)
   . = ALIGN(PAGE_SIZE);
-  VMLINUX_SYMBOL(_einitdata) = .;
   __init_end = .;
 
   _sdata = .;                   /* Start of data section */