7 files changed, 102 insertions, 57 deletions

diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c
index 5fb139fef9fa..3e59fce6dd43 100644
--- a/kernel/time/clockevents.c
+++ b/kernel/time/clockevents.c
@@ -41,6 +41,11 @@ unsigned long clockevent_delta2ns(unsigned long latch,
 {
         u64 clc = ((u64) latch << evt->shift);
 
+        if (unlikely(!evt->mult)) {
+                evt->mult = 1;
+                WARN_ON(1);
+        }
+
         do_div(clc, evt->mult);
         if (clc < 1000)
                 clc = 1000;
@@ -151,6 +156,14 @@ static void clockevents_notify_released(void)
 void clockevents_register_device(struct clock_event_device *dev)
 {
         BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED);
+        /*
+         * A nsec2cyc multiplicator of 0 is invalid and we'd crash
+         * on it, so fix it up and emit a warning:
+         */
+        if (unlikely(!dev->mult)) {
+                dev->mult = 1;
+                WARN_ON(1);
+        }
 
         spin_lock(&clockevents_lock);
 
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index 8d6125ad2cf0..6e9259a5d501 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -142,8 +142,13 @@ static void clocksource_watchdog(unsigned long data)
         }
 
         if (!list_empty(&watchdog_list)) {
-                __mod_timer(&watchdog_timer,
-                            watchdog_timer.expires + WATCHDOG_INTERVAL);
+                /* Cycle through CPUs to check if the CPUs stay synchronized to
+                 * each other. */
+                int next_cpu = next_cpu(raw_smp_processor_id(), cpu_online_map);
+                if (next_cpu >= NR_CPUS)
+                        next_cpu = first_cpu(cpu_online_map);
+                watchdog_timer.expires += WATCHDOG_INTERVAL;
+                add_timer_on(&watchdog_timer, next_cpu);
         }
         spin_unlock(&watchdog_lock);
 }
@@ -165,7 +170,7 @@ static void clocksource_check_watchdog(struct clocksource *cs)
                 if (!started && watchdog) {
                         watchdog_last = watchdog->read();
                         watchdog_timer.expires = jiffies + WATCHDOG_INTERVAL;
-                        add_timer(&watchdog_timer);
+                        add_timer_on(&watchdog_timer, first_cpu(cpu_online_map));
                 }
         } else {
                 if (cs->flags & CLOCK_SOURCE_IS_CONTINUOUS)
@@ -175,7 +180,7 @@ static void clocksource_check_watchdog(struct clocksource *cs)
                         if (watchdog)
                                 del_timer(&watchdog_timer);
                         watchdog = cs;
-                        init_timer(&watchdog_timer);
+                        init_timer_deferrable(&watchdog_timer);
                         watchdog_timer.function = clocksource_watchdog;
 
                         /* Reset watchdog cycles */
@@ -186,7 +191,8 @@ static void clocksource_check_watchdog(struct clocksource *cs)
                                 watchdog_last = watchdog->read();
                                 watchdog_timer.expires =
                                         jiffies + WATCHDOG_INTERVAL;
-                                add_timer(&watchdog_timer);
+                                add_timer_on(&watchdog_timer,
+                                                first_cpu(cpu_online_map));
                         }
                 }
         }
@@ -331,6 +337,21 @@ void clocksource_change_rating(struct clocksource *cs, int rating)
         spin_unlock_irqrestore(&clocksource_lock, flags);
 }
 
+/**
+ * clocksource_unregister - remove a registered clocksource
+ */
+void clocksource_unregister(struct clocksource *cs)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&clocksource_lock, flags);
+        list_del(&cs->list);
+        if (clocksource_override == cs)
+                clocksource_override = NULL;
+        next_clocksource = select_clocksource();
+        spin_unlock_irqrestore(&clocksource_lock, flags);
+}
+
 #ifdef CONFIG_SYSFS
 /**
  * sysfs_show_current_clocksources - sysfs interface for current clocksource
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 5b86698faa0b..e1bd50cbbf5d 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -126,9 +126,9 @@ int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
 /*
  * Broadcast the event to the cpus, which are set in the mask
  */
-int tick_do_broadcast(cpumask_t mask)
+static void tick_do_broadcast(cpumask_t mask)
 {
-        int ret = 0, cpu = smp_processor_id();
+        int cpu = smp_processor_id();
         struct tick_device *td;
 
         /*
@@ -138,7 +138,6 @@ int tick_do_broadcast(cpumask_t mask)
                 cpu_clear(cpu, mask);
                 td = &per_cpu(tick_cpu_device, cpu);
                 td->evtdev->event_handler(td->evtdev);
-                ret = 1;
         }
 
         if (!cpus_empty(mask)) {
@@ -151,9 +150,7 @@ int tick_do_broadcast(cpumask_t mask)
                 cpu = first_cpu(mask);
                 td = &per_cpu(tick_cpu_device, cpu);
                 td->evtdev->broadcast(mask);
-                ret = 1;
         }
-        return ret;
 }
 
 /*
diff --git a/kernel/time/tick-internal.h b/kernel/time/tick-internal.h
index bb13f2724905..f13f2b7f4fd4 100644
--- a/kernel/time/tick-internal.h
+++ b/kernel/time/tick-internal.h
@@ -70,8 +70,6 @@ static inline int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
  * Broadcasting support
  */
 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
-extern int tick_do_broadcast(cpumask_t mask);
-
 extern int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu);
 extern int tick_check_broadcast_device(struct clock_event_device *dev);
 extern int tick_is_broadcast_device(struct clock_event_device *dev);
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 1a21b6fdb674..63f24b550695 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -9,7 +9,7 @@
  *
  *  Started by: Thomas Gleixner and Ingo Molnar
  *
- *  For licencing details see kernel-base/COPYING
+ *  Distribute under GPLv2.
  */
 #include <linux/cpu.h>
 #include <linux/err.h>
@@ -143,6 +143,44 @@ void tick_nohz_update_jiffies(void)
         local_irq_restore(flags);
 }
 
+void tick_nohz_stop_idle(int cpu)
+{
+        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+
+        if (ts->idle_active) {
+                ktime_t now, delta;
+                now = ktime_get();
+                delta = ktime_sub(now, ts->idle_entrytime);
+                ts->idle_lastupdate = now;
+                ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
+                ts->idle_active = 0;
+        }
+}
+
+static ktime_t tick_nohz_start_idle(int cpu)
+{
+        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+        ktime_t now, delta;
+
+        now = ktime_get();
+        if (ts->idle_active) {
+                delta = ktime_sub(now, ts->idle_entrytime);
+                ts->idle_lastupdate = now;
+                ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
+        }
+        ts->idle_entrytime = now;
+        ts->idle_active = 1;
+        return now;
+}
+
+u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
+{
+        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+
+        *last_update_time = ktime_to_us(ts->idle_lastupdate);
+        return ktime_to_us(ts->idle_sleeptime);
+}
+
 /**
  * tick_nohz_stop_sched_tick - stop the idle tick from the idle task
  *
@@ -155,13 +193,14 @@ void tick_nohz_stop_sched_tick(void)
         unsigned long seq, last_jiffies, next_jiffies, delta_jiffies, flags;
         unsigned long rt_jiffies;
         struct tick_sched *ts;
-        ktime_t last_update, expires, now, delta;
+        ktime_t last_update, expires, now;
         struct clock_event_device *dev = __get_cpu_var(tick_cpu_device).evtdev;
         int cpu;
 
         local_irq_save(flags);
 
         cpu = smp_processor_id();
+        now = tick_nohz_start_idle(cpu);
         ts = &per_cpu(tick_cpu_sched, cpu);
 
         /*
@@ -193,19 +232,7 @@ void tick_nohz_stop_sched_tick(void)
                 }
         }
 
-        now = ktime_get();
-        /*
-         * When called from irq_exit we need to account the idle sleep time
-         * correctly.
-         */
-        if (ts->tick_stopped) {
-                delta = ktime_sub(now, ts->idle_entrytime);
-                ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
-        }
-
-        ts->idle_entrytime = now;
         ts->idle_calls++;
-
         /* Read jiffies and the time when jiffies were updated last */
         do {
                 seq = read_seqbegin(&xtime_lock);
@@ -296,7 +323,7 @@ void tick_nohz_stop_sched_tick(void)
                         /* Check, if the timer was already in the past */
                         if (hrtimer_active(&ts->sched_timer))
                                 goto out;
-                } else if(!tick_program_event(expires, 0))
+                } else if (!tick_program_event(expires, 0))
                                 goto out;
                 /*
                  * We are past the event already. So we crossed a
@@ -337,23 +364,22 @@ void tick_nohz_restart_sched_tick(void)
         int cpu = smp_processor_id();
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
         unsigned long ticks;
-        ktime_t now, delta;
+        ktime_t now;
 
-        if (!ts->tick_stopped)
+        local_irq_disable();
+        tick_nohz_stop_idle(cpu);
+
+        if (!ts->tick_stopped) {
+                local_irq_enable();
                 return;
+        }
 
         /* Update jiffies first */
-        now = ktime_get();
-
-        local_irq_disable();
         select_nohz_load_balancer(0);
+        now = ktime_get();
         tick_do_update_jiffies64(now);
         cpu_clear(cpu, nohz_cpu_mask);
 
-        /* Account the idle time */
-        delta = ktime_sub(now, ts->idle_entrytime);
-        ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
-
         /*
          * We stopped the tick in idle. Update process times would miss the
          * time we slept as update_process_times does only a 1 tick
@@ -507,7 +533,7 @@ static inline void tick_nohz_switch_to_nohz(void) { }
  */
 #ifdef CONFIG_HIGH_RES_TIMERS
 /*
- * We rearm the timer until we get disabled by the idle code
+ * We rearm the timer until we get disabled by the idle code.
  * Called with interrupts disabled and timer->base->cpu_base->lock held.
  */
 static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index ab46ae8c062b..092a2366b5a9 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -82,13 +82,12 @@ static inline s64 __get_nsec_offset(void)
 }
 
 /**
- * __get_realtime_clock_ts - Returns the time of day in a timespec
+ * getnstimeofday - Returns the time of day in a timespec
  * @ts:         pointer to the timespec to be set
  *
- * Returns the time of day in a timespec. Used by
- * do_gettimeofday() and get_realtime_clock_ts().
+ * Returns the time of day in a timespec.
  */
-static inline void __get_realtime_clock_ts(struct timespec *ts)
+void getnstimeofday(struct timespec *ts)
 {
         unsigned long seq;
         s64 nsecs;
@@ -104,30 +103,19 @@ static inline void __get_realtime_clock_ts(struct timespec *ts)
         timespec_add_ns(ts, nsecs);
 }
 
-/**
- * getnstimeofday - Returns the time of day in a timespec
- * @ts:         pointer to the timespec to be set
- *
- * Returns the time of day in a timespec.
- */
-void getnstimeofday(struct timespec *ts)
-{
-        __get_realtime_clock_ts(ts);
-}
-
 EXPORT_SYMBOL(getnstimeofday);
 
 /**
  * do_gettimeofday - Returns the time of day in a timeval
  * @tv:         pointer to the timeval to be set
  *
- * NOTE: Users should be converted to using get_realtime_clock_ts()
+ * NOTE: Users should be converted to using getnstimeofday()
  */
 void do_gettimeofday(struct timeval *tv)
 {
         struct timespec now;
 
-        __get_realtime_clock_ts(&now);
+        getnstimeofday(&now);
         tv->tv_sec = now.tv_sec;
         tv->tv_usec = now.tv_nsec/1000;
 }
@@ -198,7 +186,8 @@ static void change_clocksource(void)
 
         clock->error = 0;
         clock->xtime_nsec = 0;
-        clocksource_calculate_interval(clock, NTP_INTERVAL_LENGTH);
+        clocksource_calculate_interval(clock,
+                (unsigned long)(current_tick_length()>>TICK_LENGTH_SHIFT));
 
         tick_clock_notify();
 
@@ -255,7 +244,8 @@ void __init timekeeping_init(void)
         ntp_clear();
 
         clock = clocksource_get_next();
-        clocksource_calculate_interval(clock, NTP_INTERVAL_LENGTH);
+        clocksource_calculate_interval(clock,
+                (unsigned long)(current_tick_length()>>TICK_LENGTH_SHIFT));
         clock->cycle_last = clocksource_read(clock);
 
         xtime.tv_sec = sec;
diff --git a/kernel/time/timer_stats.c b/kernel/time/timer_stats.c
index c36bb7ed0301..417da8c5bc72 100644
--- a/kernel/time/timer_stats.c
+++ b/kernel/time/timer_stats.c
@@ -26,7 +26,7 @@
  * the pid and cmdline from the owner process if applicable.
  *
  * Start/stop data collection:
- * # echo 1[0] >/proc/timer_stats
+ * # echo [1|0] >/proc/timer_stats
  *
  * Display the information collected so far:
  * # cat /proc/timer_stats