Merge branch 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull timer core updates from Thomas Gleixner.

* 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  ia64: vsyscall: Add missing paranthesis
  alarmtimer: Don't call rtc_timer_init() when CONFIG_RTC_CLASS=n
  x86: vdso: Put declaration before code
  x86-64: Inline vdso clock_gettime helpers
  x86-64: Simplify and optimize vdso clock_gettime monotonic variants
  kernel-time: fix s/then/than/ spelling errors
  time: remove no_sync_cmos_clock
  time: Avoid scary backtraces when warning of > 11% adj
  alarmtimer: Make sure we initialize the rtctimer
  ntp: Fix leap-second hrtimer livelock
  x86, tsc: Skip refined tsc calibration on systems with reliable TSC
  rtc: Provide flag for rtc devices that don't support UIE
  ia64: vsyscall: Use seqcount instead of seqlock
  x86: vdso: Use seqcount instead of seqlock
  x86: vdso: Remove bogus locking in update_vsyscall_tz()
  time: Remove bogus comments
  time: Fix change_clocksource locking
  time: x86: Fix race switching from vsyscall to non-vsyscall clock

8 files changed, 106 insertions, 99 deletions

diff --git a/arch/ia64/kernel/asm-offsets.c b/arch/ia64/kernel/asm-offsets.c
index af5650169043..a48bd9a9927b 100644
--- a/arch/ia64/kernel/asm-offsets.c
+++ b/arch/ia64/kernel/asm-offsets.c
@@ -269,8 +269,8 @@ void foo(void)
         BLANK();
 
         /* used by fsys_gettimeofday in arch/ia64/kernel/fsys.S */
-        DEFINE(IA64_GTOD_LOCK_OFFSET,
-                offsetof (struct fsyscall_gtod_data_t, lock));
+        DEFINE(IA64_GTOD_SEQ_OFFSET,
+               offsetof (struct fsyscall_gtod_data_t, seq));
         DEFINE(IA64_GTOD_WALL_TIME_OFFSET,
                 offsetof (struct fsyscall_gtod_data_t, wall_time));
         DEFINE(IA64_GTOD_MONO_TIME_OFFSET,
diff --git a/arch/ia64/kernel/fsys.S b/arch/ia64/kernel/fsys.S
index f15d8601827f..cc26edac0ec6 100644
--- a/arch/ia64/kernel/fsys.S
+++ b/arch/ia64/kernel/fsys.S
@@ -173,7 +173,7 @@ ENTRY(fsys_set_tid_address)
         FSYS_RETURN
 END(fsys_set_tid_address)
 
-#if IA64_GTOD_LOCK_OFFSET !=0
+#if IA64_GTOD_SEQ_OFFSET !=0
 #error fsys_gettimeofday incompatible with changes to struct fsyscall_gtod_data_t
 #endif
 #if IA64_ITC_JITTER_OFFSET !=0
diff --git a/arch/ia64/kernel/fsyscall_gtod_data.h b/arch/ia64/kernel/fsyscall_gtod_data.h
index 57d2ee6c83e1..146b15b5fec3 100644
--- a/arch/ia64/kernel/fsyscall_gtod_data.h
+++ b/arch/ia64/kernel/fsyscall_gtod_data.h
@@ -6,7 +6,7 @@
  */
 
 struct fsyscall_gtod_data_t {
-        seqlock_t       lock;
+        seqcount_t      seq;
         struct timespec wall_time;
         struct timespec monotonic_time;
         cycle_t         clk_mask;
diff --git a/arch/ia64/kernel/time.c b/arch/ia64/kernel/time.c
index aa94bdda9de8..ecc904b33c5f 100644
--- a/arch/ia64/kernel/time.c
+++ b/arch/ia64/kernel/time.c
@@ -34,9 +34,7 @@
 
 static cycle_t itc_get_cycles(struct clocksource *cs);
 
-struct fsyscall_gtod_data_t fsyscall_gtod_data = {
-        .lock = __SEQLOCK_UNLOCKED(fsyscall_gtod_data.lock),
-};
+struct fsyscall_gtod_data_t fsyscall_gtod_data;
 
 struct itc_jitter_data_t itc_jitter_data;
 
@@ -459,9 +457,7 @@ void update_vsyscall_tz(void)
 void update_vsyscall(struct timespec *wall, struct timespec *wtm,
                         struct clocksource *c, u32 mult)
 {
-        unsigned long flags;
-
-        write_seqlock_irqsave(&fsyscall_gtod_data.lock, flags);
+        write_seqcount_begin(&fsyscall_gtod_data.seq);
 
         /* copy fsyscall clock data */
         fsyscall_gtod_data.clk_mask = c->mask;
@@ -484,6 +480,6 @@ void update_vsyscall(struct timespec *wall, struct timespec *wtm,
                 fsyscall_gtod_data.monotonic_time.tv_sec++;
         }
 
-        write_sequnlock_irqrestore(&fsyscall_gtod_data.lock, flags);
+        write_seqcount_end(&fsyscall_gtod_data.seq);
 }
 
diff --git a/arch/x86/include/asm/vgtod.h b/arch/x86/include/asm/vgtod.h
index 815285bcaceb..8b38be2de9e1 100644
--- a/arch/x86/include/asm/vgtod.h
+++ b/arch/x86/include/asm/vgtod.h
@@ -5,13 +5,8 @@
 #include <linux/clocksource.h>
 
 struct vsyscall_gtod_data {
-        seqlock_t       lock;
+        seqcount_t      seq;
 
-        /* open coded 'struct timespec' */
-        time_t          wall_time_sec;
-        u32             wall_time_nsec;
-
-        struct timezone sys_tz;
         struct { /* extract of a clocksource struct */
                 int vclock_mode;
                 cycle_t cycle_last;
@@ -19,8 +14,16 @@ struct vsyscall_gtod_data {
                 u32     mult;
                 u32     shift;
         } clock;
-        struct timespec wall_to_monotonic;
+
+        /* open coded 'struct timespec' */
+        time_t          wall_time_sec;
+        u32             wall_time_nsec;
+        u32             monotonic_time_nsec;
+        time_t          monotonic_time_sec;
+
+        struct timezone sys_tz;
         struct timespec wall_time_coarse;
+        struct timespec monotonic_time_coarse;
 };
 extern struct vsyscall_gtod_data vsyscall_gtod_data;
 
diff --git a/arch/x86/kernel/tsc.c b/arch/x86/kernel/tsc.c
index 899a03f2d181..fc0a147e3727 100644
--- a/arch/x86/kernel/tsc.c
+++ b/arch/x86/kernel/tsc.c
@@ -933,6 +933,16 @@ static int __init init_tsc_clocksource(void)
                 clocksource_tsc.rating = 0;
                 clocksource_tsc.flags &= ~CLOCK_SOURCE_IS_CONTINUOUS;
         }
+
+        /*
+         * Trust the results of the earlier calibration on systems
+         * exporting a reliable TSC.
+         */
+        if (boot_cpu_has(X86_FEATURE_TSC_RELIABLE)) {
+                clocksource_register_khz(&clocksource_tsc, tsc_khz);
+                return 0;
+        }
+
         schedule_delayed_work(&tsc_irqwork, 0);
         return 0;
 }
diff --git a/arch/x86/kernel/vsyscall_64.c b/arch/x86/kernel/vsyscall_64.c
index b07ba9393564..d5c69860b524 100644
--- a/arch/x86/kernel/vsyscall_64.c
+++ b/arch/x86/kernel/vsyscall_64.c
@@ -52,10 +52,7 @@
 #include "vsyscall_trace.h"
 
 DEFINE_VVAR(int, vgetcpu_mode);
-DEFINE_VVAR(struct vsyscall_gtod_data, vsyscall_gtod_data) =
-{
-        .lock = __SEQLOCK_UNLOCKED(__vsyscall_gtod_data.lock),
-};
+DEFINE_VVAR(struct vsyscall_gtod_data, vsyscall_gtod_data);
 
 static enum { EMULATE, NATIVE, NONE } vsyscall_mode = EMULATE;
 
@@ -80,20 +77,15 @@ early_param("vsyscall", vsyscall_setup);
 
 void update_vsyscall_tz(void)
 {
-        unsigned long flags;
-
-        write_seqlock_irqsave(&vsyscall_gtod_data.lock, flags);
-        /* sys_tz has changed */
         vsyscall_gtod_data.sys_tz = sys_tz;
-        write_sequnlock_irqrestore(&vsyscall_gtod_data.lock, flags);
 }
 
 void update_vsyscall(struct timespec *wall_time, struct timespec *wtm,
                         struct clocksource *clock, u32 mult)
 {
-        unsigned long flags;
+        struct timespec monotonic;
 
-        write_seqlock_irqsave(&vsyscall_gtod_data.lock, flags);
+        write_seqcount_begin(&vsyscall_gtod_data.seq);
 
         /* copy vsyscall data */
         vsyscall_gtod_data.clock.vclock_mode    = clock->archdata.vclock_mode;
@@ -101,12 +93,19 @@ void update_vsyscall(struct timespec *wall_time, struct timespec *wtm,
         vsyscall_gtod_data.clock.mask           = clock->mask;
         vsyscall_gtod_data.clock.mult           = mult;
         vsyscall_gtod_data.clock.shift          = clock->shift;
+
         vsyscall_gtod_data.wall_time_sec        = wall_time->tv_sec;
         vsyscall_gtod_data.wall_time_nsec       = wall_time->tv_nsec;
-        vsyscall_gtod_data.wall_to_monotonic    = *wtm;
+
+        monotonic = timespec_add(*wall_time, *wtm);
+        vsyscall_gtod_data.monotonic_time_sec   = monotonic.tv_sec;
+        vsyscall_gtod_data.monotonic_time_nsec  = monotonic.tv_nsec;
+
         vsyscall_gtod_data.wall_time_coarse     = __current_kernel_time();
+        vsyscall_gtod_data.monotonic_time_coarse =
+                timespec_add(vsyscall_gtod_data.wall_time_coarse, *wtm);
 
-        write_sequnlock_irqrestore(&vsyscall_gtod_data.lock, flags);
+        write_seqcount_end(&vsyscall_gtod_data.seq);
 }
 
 static void warn_bad_vsyscall(const char *level, struct pt_regs *regs,
diff --git a/arch/x86/vdso/vclock_gettime.c b/arch/x86/vdso/vclock_gettime.c
index 6bc0e723b6e8..885eff49d6ab 100644
--- a/arch/x86/vdso/vclock_gettime.c
+++ b/arch/x86/vdso/vclock_gettime.c
@@ -70,100 +70,98 @@ notrace static long vdso_fallback_gettime(long clock, struct timespec *ts)
         return ret;
 }
 
+notrace static long vdso_fallback_gtod(struct timeval *tv, struct timezone *tz)
+{
+        long ret;
+
+        asm("syscall" : "=a" (ret) :
+            "0" (__NR_gettimeofday), "D" (tv), "S" (tz) : "memory");
+        return ret;
+}
+
+
 notrace static inline long vgetns(void)
 {
         long v;
         cycles_t cycles;
         if (gtod->clock.vclock_mode == VCLOCK_TSC)
                 cycles = vread_tsc();
-        else
+        else if (gtod->clock.vclock_mode == VCLOCK_HPET)
                 cycles = vread_hpet();
+        else
+                return 0;
         v = (cycles - gtod->clock.cycle_last) & gtod->clock.mask;
         return (v * gtod->clock.mult) >> gtod->clock.shift;
 }
 
-notrace static noinline int do_realtime(struct timespec *ts)
+/* Code size doesn't matter (vdso is 4k anyway) and this is faster. */
+notrace static int __always_inline do_realtime(struct timespec *ts)
 {
         unsigned long seq, ns;
+        int mode;
+
         do {
-                seq = read_seqbegin(&gtod->lock);
+                seq = read_seqcount_begin(&gtod->seq);
+                mode = gtod->clock.vclock_mode;
                 ts->tv_sec = gtod->wall_time_sec;
                 ts->tv_nsec = gtod->wall_time_nsec;
                 ns = vgetns();
-        } while (unlikely(read_seqretry(&gtod->lock, seq)));
+        } while (unlikely(read_seqcount_retry(&gtod->seq, seq)));
+
         timespec_add_ns(ts, ns);
-        return 0;
+        return mode;
 }
 
-notrace static noinline int do_monotonic(struct timespec *ts)
+notrace static int do_monotonic(struct timespec *ts)
 {
-        unsigned long seq, ns, secs;
+        unsigned long seq, ns;
+        int mode;
+
         do {
-                seq = read_seqbegin(&gtod->lock);
-                secs = gtod->wall_time_sec;
-                ns = gtod->wall_time_nsec + vgetns();
-                secs += gtod->wall_to_monotonic.tv_sec;
-                ns += gtod->wall_to_monotonic.tv_nsec;
-        } while (unlikely(read_seqretry(&gtod->lock, seq)));
-
-        /* wall_time_nsec, vgetns(), and wall_to_monotonic.tv_nsec
-         * are all guaranteed to be nonnegative.
-         */
-        while (ns >= NSEC_PER_SEC) {
-                ns -= NSEC_PER_SEC;
-                ++secs;
-        }
-        ts->tv_sec = secs;
-        ts->tv_nsec = ns;
+                seq = read_seqcount_begin(&gtod->seq);
+                mode = gtod->clock.vclock_mode;
+                ts->tv_sec = gtod->monotonic_time_sec;
+                ts->tv_nsec = gtod->monotonic_time_nsec;
+                ns = vgetns();
+        } while (unlikely(read_seqcount_retry(&gtod->seq, seq)));
+        timespec_add_ns(ts, ns);
 
-        return 0;
+        return mode;
 }
 
-notrace static noinline int do_realtime_coarse(struct timespec *ts)
+notrace static int do_realtime_coarse(struct timespec *ts)
 {
         unsigned long seq;
         do {
-                seq = read_seqbegin(&gtod->lock);
+                seq = read_seqcount_begin(&gtod->seq);
                 ts->tv_sec = gtod->wall_time_coarse.tv_sec;
                 ts->tv_nsec = gtod->wall_time_coarse.tv_nsec;
-        } while (unlikely(read_seqretry(&gtod->lock, seq)));
+        } while (unlikely(read_seqcount_retry(&gtod->seq, seq)));
         return 0;
 }
 
-notrace static noinline int do_monotonic_coarse(struct timespec *ts)
+notrace static int do_monotonic_coarse(struct timespec *ts)
 {
-        unsigned long seq, ns, secs;
+        unsigned long seq;
         do {
-                seq = read_seqbegin(&gtod->lock);
-                secs = gtod->wall_time_coarse.tv_sec;
-                ns = gtod->wall_time_coarse.tv_nsec;
-                secs += gtod->wall_to_monotonic.tv_sec;
-                ns += gtod->wall_to_monotonic.tv_nsec;
-        } while (unlikely(read_seqretry(&gtod->lock, seq)));
-
-        /* wall_time_nsec and wall_to_monotonic.tv_nsec are
-         * guaranteed to be between 0 and NSEC_PER_SEC.
-         */
-        if (ns >= NSEC_PER_SEC) {
-                ns -= NSEC_PER_SEC;
-                ++secs;
-        }
-        ts->tv_sec = secs;
-        ts->tv_nsec = ns;
+                seq = read_seqcount_begin(&gtod->seq);
+                ts->tv_sec = gtod->monotonic_time_coarse.tv_sec;
+                ts->tv_nsec = gtod->monotonic_time_coarse.tv_nsec;
+        } while (unlikely(read_seqcount_retry(&gtod->seq, seq)));
 
         return 0;
 }
 
 notrace int __vdso_clock_gettime(clockid_t clock, struct timespec *ts)
 {
+        int ret = VCLOCK_NONE;
+
         switch (clock) {
         case CLOCK_REALTIME:
-                if (likely(gtod->clock.vclock_mode != VCLOCK_NONE))
-                        return do_realtime(ts);
+                ret = do_realtime(ts);
                 break;
         case CLOCK_MONOTONIC:
-                if (likely(gtod->clock.vclock_mode != VCLOCK_NONE))
-                        return do_monotonic(ts);
+                ret = do_monotonic(ts);
                 break;
         case CLOCK_REALTIME_COARSE:
                 return do_realtime_coarse(ts);
@@ -171,32 +169,33 @@ notrace int __vdso_clock_gettime(clockid_t clock, struct timespec *ts)
                 return do_monotonic_coarse(ts);
         }
 
-        return vdso_fallback_gettime(clock, ts);
+        if (ret == VCLOCK_NONE)
+                return vdso_fallback_gettime(clock, ts);
+        return 0;
 }
 int clock_gettime(clockid_t, struct timespec *)
         __attribute__((weak, alias("__vdso_clock_gettime")));
 
 notrace int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
 {
-        long ret;
-        if (likely(gtod->clock.vclock_mode != VCLOCK_NONE)) {
-                if (likely(tv != NULL)) {
-                        BUILD_BUG_ON(offsetof(struct timeval, tv_usec) !=
-                                     offsetof(struct timespec, tv_nsec) ||
-                                     sizeof(*tv) != sizeof(struct timespec));
-                        do_realtime((struct timespec *)tv);
-                        tv->tv_usec /= 1000;
-                }
-                if (unlikely(tz != NULL)) {
-                        /* Avoid memcpy. Some old compilers fail to inline it */
-                        tz->tz_minuteswest = gtod->sys_tz.tz_minuteswest;
-                        tz->tz_dsttime = gtod->sys_tz.tz_dsttime;
-                }
-                return 0;
+        long ret = VCLOCK_NONE;
+
+        if (likely(tv != NULL)) {
+                BUILD_BUG_ON(offsetof(struct timeval, tv_usec) !=
+                             offsetof(struct timespec, tv_nsec) ||
+                             sizeof(*tv) != sizeof(struct timespec));
+                ret = do_realtime((struct timespec *)tv);
+                tv->tv_usec /= 1000;
         }
-        asm("syscall" : "=a" (ret) :
-            "0" (__NR_gettimeofday), "D" (tv), "S" (tz) : "memory");
-        return ret;
+        if (unlikely(tz != NULL)) {
+                /* Avoid memcpy. Some old compilers fail to inline it */
+                tz->tz_minuteswest = gtod->sys_tz.tz_minuteswest;
+                tz->tz_dsttime = gtod->sys_tz.tz_dsttime;
+        }
+
+        if (ret == VCLOCK_NONE)
+                return vdso_fallback_gtod(tv, tz);
+        return 0;
 }
 int gettimeofday(struct timeval *, struct timezone *)
         __attribute__((weak, alias("__vdso_gettimeofday")));