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

Pull timer changes from Ingo Molnar:
  - ARM clocksource/clockevent improvements and fixes
  - generic timekeeping updates: TAI fixes/improvements, cleanups
  - Posix cpu timer cleanups and improvements
  - dynticks updates: full dynticks bugfixes, optimizations and cleanups

* 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (46 commits)
  clocksource: Timer-sun5i: Switch to sched_clock_register()
  timekeeping: Remove comment that's mostly out of date
  rtc-cmos: Add an alarm disable quirk
  timekeeper: fix comment typo for tk_setup_internals()
  timekeeping: Fix missing timekeeping_update in suspend path
  timekeeping: Fix CLOCK_TAI timer/nanosleep delays
  tick/timekeeping: Call update_wall_time outside the jiffies lock
  timekeeping: Avoid possible deadlock from clock_was_set_delayed
  timekeeping: Fix potential lost pv notification of time change
  timekeeping: Fix lost updates to tai adjustment
  clocksource: sh_cmt: Add clk_prepare/unprepare support
  clocksource: bcm_kona_timer: Remove unused bcm_timer_ids
  clocksource: vt8500: Remove deprecated IRQF_DISABLED
  clocksource: tegra: Remove deprecated IRQF_DISABLED
  clocksource: misc drivers: Remove deprecated IRQF_DISABLED
  clocksource: sh_mtu2: Remove unnecessary platform_set_drvdata()
  clocksource: sh_tmu: Remove unnecessary platform_set_drvdata()
  clocksource: armada-370-xp: Enable timer divider only when needed
  clocksource: clksrc-of: Warn if no clock sources are found
  clocksource: orion: Switch to sched_clock_register()
  ...

5 files changed, 50 insertions, 55 deletions

diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 9532690daaa9..43780ab5e279 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -538,10 +538,10 @@ int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
  * Called from irq_enter() when idle was interrupted to reenable the
  * per cpu device.
  */
-void tick_check_oneshot_broadcast(int cpu)
+void tick_check_oneshot_broadcast_this_cpu(void)
 {
-        if (cpumask_test_cpu(cpu, tick_broadcast_oneshot_mask)) {
-                struct tick_device *td = &per_cpu(tick_cpu_device, cpu);
+        if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) {
+                struct tick_device *td = &__get_cpu_var(tick_cpu_device);
 
                 /*
                  * We might be in the middle of switching over from
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index 162b03ab0ad2..20b2fe37d105 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -85,6 +85,7 @@ static void tick_periodic(int cpu)
 
                 do_timer(1);
                 write_sequnlock(&jiffies_lock);
+                update_wall_time();
         }
 
         update_process_times(user_mode(get_irq_regs()));
diff --git a/kernel/time/tick-internal.h b/kernel/time/tick-internal.h
index 18e71f7fbc2a..8329669b51ec 100644
--- a/kernel/time/tick-internal.h
+++ b/kernel/time/tick-internal.h
@@ -51,7 +51,7 @@ extern void tick_broadcast_switch_to_oneshot(void);
 extern void tick_shutdown_broadcast_oneshot(unsigned int *cpup);
 extern int tick_resume_broadcast_oneshot(struct clock_event_device *bc);
 extern int tick_broadcast_oneshot_active(void);
-extern void tick_check_oneshot_broadcast(int cpu);
+extern void tick_check_oneshot_broadcast_this_cpu(void);
 bool tick_broadcast_oneshot_available(void);
 # else /* BROADCAST */
 static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
@@ -62,7 +62,7 @@ static inline void tick_broadcast_oneshot_control(unsigned long reason) { }
 static inline void tick_broadcast_switch_to_oneshot(void) { }
 static inline void tick_shutdown_broadcast_oneshot(unsigned int *cpup) { }
 static inline int tick_broadcast_oneshot_active(void) { return 0; }
-static inline void tick_check_oneshot_broadcast(int cpu) { }
+static inline void tick_check_oneshot_broadcast_this_cpu(void) { }
 static inline bool tick_broadcast_oneshot_available(void) { return true; }
 # endif /* !BROADCAST */
 
@@ -155,3 +155,4 @@ static inline int tick_device_is_functional(struct clock_event_device *dev)
 #endif
 
 extern void do_timer(unsigned long ticks);
+extern void update_wall_time(void);
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index c833249ab0fb..08cb0c3b8ccb 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -86,6 +86,7 @@ static void tick_do_update_jiffies64(ktime_t now)
                 tick_next_period = ktime_add(last_jiffies_update, tick_period);
         }
         write_sequnlock(&jiffies_lock);
+        update_wall_time();
 }
 
 /*
@@ -391,11 +392,9 @@ __setup("nohz=", setup_tick_nohz);
  */
 static void tick_nohz_update_jiffies(ktime_t now)
 {
-        int cpu = smp_processor_id();
-        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
         unsigned long flags;
 
-        ts->idle_waketime = now;
+        __this_cpu_write(tick_cpu_sched.idle_waketime, now);
 
         local_irq_save(flags);
         tick_do_update_jiffies64(now);
@@ -426,17 +425,15 @@ update_ts_time_stats(int cpu, struct tick_sched *ts, ktime_t now, u64 *last_upda
 
 }
 
-static void tick_nohz_stop_idle(int cpu, ktime_t now)
+static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now)
 {
-        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
-
-        update_ts_time_stats(cpu, ts, now, NULL);
+        update_ts_time_stats(smp_processor_id(), ts, now, NULL);
         ts->idle_active = 0;
 
         sched_clock_idle_wakeup_event(0);
 }
 
-static ktime_t tick_nohz_start_idle(int cpu, struct tick_sched *ts)
+static ktime_t tick_nohz_start_idle(struct tick_sched *ts)
 {
         ktime_t now = ktime_get();
 
@@ -754,7 +751,7 @@ static void __tick_nohz_idle_enter(struct tick_sched *ts)
         ktime_t now, expires;
         int cpu = smp_processor_id();
 
-        now = tick_nohz_start_idle(cpu, ts);
+        now = tick_nohz_start_idle(ts);
 
         if (can_stop_idle_tick(cpu, ts)) {
                 int was_stopped = ts->tick_stopped;
@@ -911,8 +908,7 @@ static void tick_nohz_account_idle_ticks(struct tick_sched *ts)
  */
 void tick_nohz_idle_exit(void)
 {
-        int cpu = smp_processor_id();
-        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+        struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
         ktime_t now;
 
         local_irq_disable();
@@ -925,7 +921,7 @@ void tick_nohz_idle_exit(void)
                 now = ktime_get();
 
         if (ts->idle_active)
-                tick_nohz_stop_idle(cpu, now);
+                tick_nohz_stop_idle(ts, now);
 
         if (ts->tick_stopped) {
                 tick_nohz_restart_sched_tick(ts, now);
@@ -1009,12 +1005,10 @@ static void tick_nohz_switch_to_nohz(void)
  * timer and do not touch the other magic bits which need to be done
  * when idle is left.
  */
-static void tick_nohz_kick_tick(int cpu, ktime_t now)
+static void tick_nohz_kick_tick(struct tick_sched *ts, ktime_t now)
 {
 #if 0
         /* Switch back to 2.6.27 behaviour */
-
-        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
         ktime_t delta;
 
         /*
@@ -1029,36 +1023,36 @@ static void tick_nohz_kick_tick(int cpu, ktime_t now)
 #endif
 }
 
-static inline void tick_check_nohz(int cpu)
+static inline void tick_check_nohz_this_cpu(void)
 {
-        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+        struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
         ktime_t now;
 
         if (!ts->idle_active && !ts->tick_stopped)
                 return;
         now = ktime_get();
         if (ts->idle_active)
-                tick_nohz_stop_idle(cpu, now);
+                tick_nohz_stop_idle(ts, now);
         if (ts->tick_stopped) {
                 tick_nohz_update_jiffies(now);
-                tick_nohz_kick_tick(cpu, now);
+                tick_nohz_kick_tick(ts, now);
         }
 }
 
 #else
 
 static inline void tick_nohz_switch_to_nohz(void) { }
-static inline void tick_check_nohz(int cpu) { }
+static inline void tick_check_nohz_this_cpu(void) { }
 
 #endif /* CONFIG_NO_HZ_COMMON */
 
 /*
  * Called from irq_enter to notify about the possible interruption of idle()
  */
-void tick_check_idle(int cpu)
+void tick_check_idle(void)
 {
-        tick_check_oneshot_broadcast(cpu);
-        tick_check_nohz(cpu);
+        tick_check_oneshot_broadcast_this_cpu();
+        tick_check_nohz_this_cpu();
 }
 
 /*
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 87b4f00284c9..0aa4ce81bc16 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -77,7 +77,7 @@ static void tk_set_wall_to_mono(struct timekeeper *tk, struct timespec wtm)
         tk->wall_to_monotonic = wtm;
         set_normalized_timespec(&tmp, -wtm.tv_sec, -wtm.tv_nsec);
         tk->offs_real = timespec_to_ktime(tmp);
-        tk->offs_tai = ktime_sub(tk->offs_real, ktime_set(tk->tai_offset, 0));
+        tk->offs_tai = ktime_add(tk->offs_real, ktime_set(tk->tai_offset, 0));
 }
 
 static void tk_set_sleep_time(struct timekeeper *tk, struct timespec t)
@@ -90,8 +90,9 @@ static void tk_set_sleep_time(struct timekeeper *tk, struct timespec t)
 }
 
 /**
- * timekeeper_setup_internals - Set up internals to use clocksource clock.
+ * tk_setup_internals - Set up internals to use clocksource clock.
  *
+ * @tk:         The target timekeeper to setup.
  * @clock:              Pointer to clocksource.
  *
  * Calculates a fixed cycle/nsec interval for a given clocksource/adjustment
@@ -595,7 +596,7 @@ s32 timekeeping_get_tai_offset(void)
 static void __timekeeping_set_tai_offset(struct timekeeper *tk, s32 tai_offset)
 {
         tk->tai_offset = tai_offset;
-        tk->offs_tai = ktime_sub(tk->offs_real, ktime_set(tai_offset, 0));
+        tk->offs_tai = ktime_add(tk->offs_real, ktime_set(tai_offset, 0));
 }
 
 /**
@@ -610,6 +611,7 @@ void timekeeping_set_tai_offset(s32 tai_offset)
         raw_spin_lock_irqsave(&timekeeper_lock, flags);
         write_seqcount_begin(&timekeeper_seq);
         __timekeeping_set_tai_offset(tk, tai_offset);
+        timekeeping_update(tk, TK_MIRROR | TK_CLOCK_WAS_SET);
         write_seqcount_end(&timekeeper_seq);
         raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
         clock_was_set();
@@ -1023,6 +1025,8 @@ static int timekeeping_suspend(void)
                 timekeeping_suspend_time =
                         timespec_add(timekeeping_suspend_time, delta_delta);
         }
+
+        timekeeping_update(tk, TK_MIRROR);
         write_seqcount_end(&timekeeper_seq);
         raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
@@ -1130,16 +1134,6 @@ static void timekeeping_adjust(struct timekeeper *tk, s64 offset)
                  * we can adjust by 1.
                  */
                 error >>= 2;
-                /*
-                 * XXX - In update_wall_time, we round up to the next
-                 * nanosecond, and store the amount rounded up into
-                 * the error. This causes the likely below to be unlikely.
-                 *
-                 * The proper fix is to avoid rounding up by using
-                 * the high precision tk->xtime_nsec instead of
-                 * xtime.tv_nsec everywhere. Fixing this will take some
-                 * time.
-                 */
                 if (likely(error <= interval))
                         adj = 1;
                 else
@@ -1255,7 +1249,7 @@ out_adjust:
 static inline unsigned int accumulate_nsecs_to_secs(struct timekeeper *tk)
 {
         u64 nsecps = (u64)NSEC_PER_SEC << tk->shift;
-        unsigned int action = 0;
+        unsigned int clock_set = 0;
 
         while (tk->xtime_nsec >= nsecps) {
                 int leap;
@@ -1277,11 +1271,10 @@ static inline unsigned int accumulate_nsecs_to_secs(struct timekeeper *tk)
 
                         __timekeeping_set_tai_offset(tk, tk->tai_offset - leap);
 
-                        clock_was_set_delayed();
-                        action = TK_CLOCK_WAS_SET;
+                        clock_set = TK_CLOCK_WAS_SET;
                 }
         }
-        return action;
+        return clock_set;
 }
 
 /**
@@ -1294,7 +1287,8 @@ static inline unsigned int accumulate_nsecs_to_secs(struct timekeeper *tk)
  * Returns the unconsumed cycles.
  */
 static cycle_t logarithmic_accumulation(struct timekeeper *tk, cycle_t offset,
-                                                u32 shift)
+                                                u32 shift,
+                                                unsigned int *clock_set)
 {
         cycle_t interval = tk->cycle_interval << shift;
         u64 raw_nsecs;
@@ -1308,7 +1302,7 @@ static cycle_t logarithmic_accumulation(struct timekeeper *tk, cycle_t offset,
         tk->cycle_last += interval;
 
         tk->xtime_nsec += tk->xtime_interval << shift;
-        accumulate_nsecs_to_secs(tk);
+        *clock_set |= accumulate_nsecs_to_secs(tk);
 
         /* Accumulate raw time */
         raw_nsecs = (u64)tk->raw_interval << shift;
@@ -1359,14 +1353,14 @@ static inline void old_vsyscall_fixup(struct timekeeper *tk)
  * update_wall_time - Uses the current clocksource to increment the wall time
  *
  */
-static void update_wall_time(void)
+void update_wall_time(void)
 {
         struct clocksource *clock;
         struct timekeeper *real_tk = &timekeeper;
         struct timekeeper *tk = &shadow_timekeeper;
         cycle_t offset;
         int shift = 0, maxshift;
-        unsigned int action;
+        unsigned int clock_set = 0;
         unsigned long flags;
 
         raw_spin_lock_irqsave(&timekeeper_lock, flags);
@@ -1401,7 +1395,8 @@ static void update_wall_time(void)
         maxshift = (64 - (ilog2(ntp_tick_length())+1)) - 1;
         shift = min(shift, maxshift);
         while (offset >= tk->cycle_interval) {
-                offset = logarithmic_accumulation(tk, offset, shift);
+                offset = logarithmic_accumulation(tk, offset, shift,
+                                                        &clock_set);
                 if (offset < tk->cycle_interval<<shift)
                         shift--;
         }
@@ -1419,7 +1414,7 @@ static void update_wall_time(void)
          * Finally, make sure that after the rounding
          * xtime_nsec isn't larger than NSEC_PER_SEC
          */
-        action = accumulate_nsecs_to_secs(tk);
+        clock_set |= accumulate_nsecs_to_secs(tk);
 
         write_seqcount_begin(&timekeeper_seq);
         /* Update clock->cycle_last with the new value */
@@ -1435,10 +1430,12 @@ static void update_wall_time(void)
          * updating.
          */
         memcpy(real_tk, tk, sizeof(*tk));
-        timekeeping_update(real_tk, action);
+        timekeeping_update(real_tk, clock_set);
         write_seqcount_end(&timekeeper_seq);
 out:
         raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
+        if (clock_set)
+                clock_was_set();
 }
 
 /**
@@ -1583,7 +1580,6 @@ struct timespec get_monotonic_coarse(void)
 void do_timer(unsigned long ticks)
 {
         jiffies_64 += ticks;
-        update_wall_time();
         calc_global_load(ticks);
 }
 
@@ -1698,12 +1694,14 @@ int do_adjtimex(struct timex *txc)
 
         if (tai != orig_tai) {
                 __timekeeping_set_tai_offset(tk, tai);
-                update_pvclock_gtod(tk, true);
-                clock_was_set_delayed();
+                timekeeping_update(tk, TK_MIRROR | TK_CLOCK_WAS_SET);
         }
         write_seqcount_end(&timekeeper_seq);
         raw_spin_unlock_irqrestore(&timekeeper_lock, flags);
 
+        if (tai != orig_tai)
+                clock_was_set();
+
         ntp_notify_cmos_timer();
 
         return ret;
@@ -1739,4 +1737,5 @@ void xtime_update(unsigned long ticks)
         write_seqlock(&jiffies_lock);
         do_timer(ticks);
         write_sequnlock(&jiffies_lock);
+        update_wall_time();
 }