5 files changed, 67 insertions, 97 deletions

diff --git a/kernel/time/Kconfig b/kernel/time/Kconfig
index 95ed42951e0a..f06a8a365648 100644
--- a/kernel/time/Kconfig
+++ b/kernel/time/Kconfig
@@ -6,7 +6,7 @@ config TICK_ONESHOT
 
 config NO_HZ
         bool "Tickless System (Dynamic Ticks)"
-        depends on GENERIC_TIME && GENERIC_CLOCKEVENTS
+        depends on !ARCH_USES_GETTIMEOFFSET && GENERIC_CLOCKEVENTS
         select TICK_ONESHOT
         help
           This option enables a tickless system: timer interrupts will
@@ -15,7 +15,7 @@ config NO_HZ
 
 config HIGH_RES_TIMERS
         bool "High Resolution Timer Support"
-        depends on GENERIC_TIME && GENERIC_CLOCKEVENTS
+        depends on !ARCH_USES_GETTIMEOFFSET && GENERIC_CLOCKEVENTS
         select TICK_ONESHOT
         help
           This option enables high resolution timer support. If your
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index f08e99c1d561..c18d7efa1b4b 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -531,7 +531,7 @@ static u64 clocksource_max_deferment(struct clocksource *cs)
         return max_nsecs - (max_nsecs >> 5);
 }
 
-#ifdef CONFIG_GENERIC_TIME
+#ifndef CONFIG_ARCH_USES_GETTIMEOFFSET
 
 /**
  * clocksource_select - Select the best clocksource available
@@ -577,7 +577,7 @@ static void clocksource_select(void)
         }
 }
 
-#else /* CONFIG_GENERIC_TIME */
+#else /* !CONFIG_ARCH_USES_GETTIMEOFFSET */
 
 static inline void clocksource_select(void) { }
 
@@ -639,19 +639,18 @@ static void clocksource_enqueue(struct clocksource *cs)
 #define MAX_UPDATE_LENGTH 5 /* Seconds */
 
 /**
- * __clocksource_register_scale - Used to install new clocksources
+ * __clocksource_updatefreq_scale - Used update clocksource with new freq
  * @t:          clocksource to be registered
  * @scale:      Scale factor multiplied against freq to get clocksource hz
  * @freq:       clocksource frequency (cycles per second) divided by scale
  *
- * Returns -EBUSY if registration fails, zero otherwise.
+ * This should only be called from the clocksource->enable() method.
  *
  * This *SHOULD NOT* be called directly! Please use the
- * clocksource_register_hz() or clocksource_register_khz helper functions.
+ * clocksource_updatefreq_hz() or clocksource_updatefreq_khz helper functions.
  */
-int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
+void __clocksource_updatefreq_scale(struct clocksource *cs, u32 scale, u32 freq)
 {
-
         /*
          * Ideally we want to use  some of the limits used in
          * clocksource_max_deferment, to provide a more informed
@@ -662,7 +661,27 @@ int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
                                       NSEC_PER_SEC/scale,
                                       MAX_UPDATE_LENGTH*scale);
         cs->max_idle_ns = clocksource_max_deferment(cs);
+}
+EXPORT_SYMBOL_GPL(__clocksource_updatefreq_scale);
+
+/**
+ * __clocksource_register_scale - Used to install new clocksources
+ * @t:          clocksource to be registered
+ * @scale:      Scale factor multiplied against freq to get clocksource hz
+ * @freq:       clocksource frequency (cycles per second) divided by scale
+ *
+ * Returns -EBUSY if registration fails, zero otherwise.
+ *
+ * This *SHOULD NOT* be called directly! Please use the
+ * clocksource_register_hz() or clocksource_register_khz helper functions.
+ */
+int __clocksource_register_scale(struct clocksource *cs, u32 scale, u32 freq)
+{
+
+        /* Intialize mult/shift and max_idle_ns */
+        __clocksource_updatefreq_scale(cs, scale, freq);
 
+        /* Add clocksource to the clcoksource list */
         mutex_lock(&clocksource_mutex);
         clocksource_enqueue(cs);
         clocksource_select();
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index b3bafd5fc66d..48b2761b5668 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -188,7 +188,7 @@ static void tick_handle_periodic_broadcast(struct clock_event_device *dev)
         /*
          * Setup the next period for devices, which do not have
          * periodic mode. We read dev->next_event first and add to it
-         * when the event alrady expired. clockevents_program_event()
+         * when the event already expired. clockevents_program_event()
          * sets dev->next_event only when the event is really
          * programmed to the device.
          */
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 1d7b9bc1c034..3e216e01bbd1 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -154,14 +154,14 @@ static void tick_nohz_update_jiffies(ktime_t now)
  * Updates the per cpu time idle statistics counters
  */
 static void
-update_ts_time_stats(struct tick_sched *ts, ktime_t now, u64 *last_update_time)
+update_ts_time_stats(int cpu, struct tick_sched *ts, ktime_t now, u64 *last_update_time)
 {
         ktime_t delta;
 
         if (ts->idle_active) {
                 delta = ktime_sub(now, ts->idle_entrytime);
                 ts->idle_sleeptime = ktime_add(ts->idle_sleeptime, delta);
-                if (nr_iowait_cpu() > 0)
+                if (nr_iowait_cpu(cpu) > 0)
                         ts->iowait_sleeptime = ktime_add(ts->iowait_sleeptime, delta);
                 ts->idle_entrytime = now;
         }
@@ -175,19 +175,19 @@ static void tick_nohz_stop_idle(int cpu, ktime_t now)
 {
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 
-        update_ts_time_stats(ts, now, NULL);
+        update_ts_time_stats(cpu, ts, now, NULL);
         ts->idle_active = 0;
 
         sched_clock_idle_wakeup_event(0);
 }
 
-static ktime_t tick_nohz_start_idle(struct tick_sched *ts)
+static ktime_t tick_nohz_start_idle(int cpu, struct tick_sched *ts)
 {
         ktime_t now;
 
         now = ktime_get();
 
-        update_ts_time_stats(ts, now, NULL);
+        update_ts_time_stats(cpu, ts, now, NULL);
 
         ts->idle_entrytime = now;
         ts->idle_active = 1;
@@ -216,7 +216,7 @@ u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time)
         if (!tick_nohz_enabled)
                 return -1;
 
-        update_ts_time_stats(ts, ktime_get(), last_update_time);
+        update_ts_time_stats(cpu, ts, ktime_get(), last_update_time);
 
         return ktime_to_us(ts->idle_sleeptime);
 }
@@ -242,7 +242,7 @@ u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time)
         if (!tick_nohz_enabled)
                 return -1;
 
-        update_ts_time_stats(ts, ktime_get(), last_update_time);
+        update_ts_time_stats(cpu, ts, ktime_get(), last_update_time);
 
         return ktime_to_us(ts->iowait_sleeptime);
 }
@@ -284,7 +284,7 @@ void tick_nohz_stop_sched_tick(int inidle)
          */
         ts->inidle = 1;
 
-        now = tick_nohz_start_idle(ts);
+        now = tick_nohz_start_idle(cpu, ts);
 
         /*
          * If this cpu is offline and it is the one which updates
@@ -315,9 +315,6 @@ void tick_nohz_stop_sched_tick(int inidle)
                 goto end;
         }
 
-        if (nohz_ratelimit(cpu))
-                goto end;
-
         ts->idle_calls++;
         /* Read jiffies and the time when jiffies were updated last */
         do {
@@ -408,13 +405,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                  * the scheduler tick in nohz_restart_sched_tick.
                  */
                 if (!ts->tick_stopped) {
-                        if (select_nohz_load_balancer(1)) {
-                                /*
-                                 * sched tick not stopped!
-                                 */
-                                cpumask_clear_cpu(cpu, nohz_cpu_mask);
-                                goto out;
-                        }
+                        select_nohz_load_balancer(1);
 
                         ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);
                         ts->tick_stopped = 1;
@@ -783,7 +774,6 @@ void tick_setup_sched_timer(void)
 {
         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
         ktime_t now = ktime_get();
-        u64 offset;
 
         /*
          * Emulate tick processing via per-CPU hrtimers:
@@ -793,10 +783,6 @@ void tick_setup_sched_timer(void)
 
         /* Get the next period (per cpu) */
         hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
-        offset = ktime_to_ns(tick_period) >> 1;
-        do_div(offset, num_possible_cpus());
-        offset *= smp_processor_id();
-        hrtimer_add_expires_ns(&ts->sched_timer, offset);
 
         for (;;) {
                 hrtimer_forward(&ts->sched_timer, now, tick_period);
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index caf8d4d4f5c8..49010d822f72 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -153,8 +153,8 @@ __cacheline_aligned_in_smp DEFINE_SEQLOCK(xtime_lock);
  * - wall_to_monotonic is no longer the boot time, getboottime must be
  * used instead.
  */
-struct timespec xtime __attribute__ ((aligned (16)));
-struct timespec wall_to_monotonic __attribute__ ((aligned (16)));
+static struct timespec xtime __attribute__ ((aligned (16)));
+static struct timespec wall_to_monotonic __attribute__ ((aligned (16)));
 static struct timespec total_sleep_time;
 
 /*
@@ -170,11 +170,10 @@ void timekeeping_leap_insert(int leapsecond)
 {
         xtime.tv_sec += leapsecond;
         wall_to_monotonic.tv_sec -= leapsecond;
-        update_vsyscall(&xtime, timekeeper.clock, timekeeper.mult);
+        update_vsyscall(&xtime, &wall_to_monotonic, timekeeper.clock,
+                        timekeeper.mult);
 }
 
-#ifdef CONFIG_GENERIC_TIME
-
 /**
  * timekeeping_forward_now - update clock to the current time
  *
@@ -328,7 +327,8 @@ int do_settimeofday(struct timespec *tv)
         timekeeper.ntp_error = 0;
         ntp_clear();
 
-        update_vsyscall(&xtime, timekeeper.clock, timekeeper.mult);
+        update_vsyscall(&xtime, &wall_to_monotonic, timekeeper.clock,
+                                timekeeper.mult);
 
         write_sequnlock_irqrestore(&xtime_lock, flags);
 
@@ -376,52 +376,6 @@ void timekeeping_notify(struct clocksource *clock)
         tick_clock_notify();
 }
 
-#else /* GENERIC_TIME */
-
-static inline void timekeeping_forward_now(void) { }
-
-/**
- * ktime_get - get the monotonic time in ktime_t format
- *
- * returns the time in ktime_t format
- */
-ktime_t ktime_get(void)
-{
-        struct timespec now;
-
-        ktime_get_ts(&now);
-
-        return timespec_to_ktime(now);
-}
-EXPORT_SYMBOL_GPL(ktime_get);
-
-/**
- * ktime_get_ts - get the monotonic clock in timespec format
- * @ts:         pointer to timespec variable
- *
- * The function calculates the monotonic clock from the realtime
- * clock and the wall_to_monotonic offset and stores the result
- * in normalized timespec format in the variable pointed to by @ts.
- */
-void ktime_get_ts(struct timespec *ts)
-{
-        struct timespec tomono;
-        unsigned long seq;
-
-        do {
-                seq = read_seqbegin(&xtime_lock);
-                getnstimeofday(ts);
-                tomono = wall_to_monotonic;
-
-        } while (read_seqretry(&xtime_lock, seq));
-
-        set_normalized_timespec(ts, ts->tv_sec + tomono.tv_sec,
-                                ts->tv_nsec + tomono.tv_nsec);
-}
-EXPORT_SYMBOL_GPL(ktime_get_ts);
-
-#endif /* !GENERIC_TIME */
-
 /**
  * ktime_get_real - get the real (wall-) time in ktime_t format
  *
@@ -579,9 +533,9 @@ static int timekeeping_resume(struct sys_device *dev)
 
         if (timespec_compare(&ts, &timekeeping_suspend_time) > 0) {
                 ts = timespec_sub(ts, timekeeping_suspend_time);
-                xtime = timespec_add_safe(xtime, ts);
+                xtime = timespec_add(xtime, ts);
                 wall_to_monotonic = timespec_sub(wall_to_monotonic, ts);
-                total_sleep_time = timespec_add_safe(total_sleep_time, ts);
+                total_sleep_time = timespec_add(total_sleep_time, ts);
         }
         /* re-base the last cycle value */
         timekeeper.clock->cycle_last = timekeeper.clock->read(timekeeper.clock);
@@ -736,6 +690,7 @@ static void timekeeping_adjust(s64 offset)
 static cycle_t logarithmic_accumulation(cycle_t offset, int shift)
 {
         u64 nsecps = (u64)NSEC_PER_SEC << timekeeper.shift;
+        u64 raw_nsecs;
 
         /* If the offset is smaller then a shifted interval, do nothing */
         if (offset < timekeeper.cycle_interval<<shift)
@@ -752,12 +707,15 @@ static cycle_t logarithmic_accumulation(cycle_t offset, int shift)
                 second_overflow();
         }
 
-        /* Accumulate into raw time */
-        raw_time.tv_nsec += timekeeper.raw_interval << shift;;
-        while (raw_time.tv_nsec >= NSEC_PER_SEC) {
-                raw_time.tv_nsec -= NSEC_PER_SEC;
-                raw_time.tv_sec++;
+        /* Accumulate raw time */
+        raw_nsecs = timekeeper.raw_interval << shift;
+        raw_nsecs += raw_time.tv_nsec;
+        if (raw_nsecs >= NSEC_PER_SEC) {
+                u64 raw_secs = raw_nsecs;
+                raw_nsecs = do_div(raw_secs, NSEC_PER_SEC);
+                raw_time.tv_sec += raw_secs;
         }
+        raw_time.tv_nsec = raw_nsecs;
 
         /* Accumulate error between NTP and clock interval */
         timekeeper.ntp_error += tick_length << shift;
@@ -784,10 +742,11 @@ void update_wall_time(void)
                 return;
 
         clock = timekeeper.clock;
-#ifdef CONFIG_GENERIC_TIME
-        offset = (clock->read(clock) - clock->cycle_last) & clock->mask;
-#else
+
+#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
         offset = timekeeper.cycle_interval;
+#else
+        offset = (clock->read(clock) - clock->cycle_last) & clock->mask;
 #endif
         timekeeper.xtime_nsec = (s64)xtime.tv_nsec << timekeeper.shift;
 
@@ -856,7 +815,8 @@ void update_wall_time(void)
         }
 
         /* check to see if there is a new clocksource to use */
-        update_vsyscall(&xtime, timekeeper.clock, timekeeper.mult);
+        update_vsyscall(&xtime, &wall_to_monotonic, timekeeper.clock,
+                                timekeeper.mult);
 }
 
 /**
@@ -887,7 +847,7 @@ EXPORT_SYMBOL_GPL(getboottime);
  */
 void monotonic_to_bootbased(struct timespec *ts)
 {
-        *ts = timespec_add_safe(*ts, total_sleep_time);
+        *ts = timespec_add(*ts, total_sleep_time);
 }
 EXPORT_SYMBOL_GPL(monotonic_to_bootbased);
 
@@ -902,6 +862,11 @@ struct timespec __current_kernel_time(void)
         return xtime;
 }
 
+struct timespec __get_wall_to_monotonic(void)
+{
+        return wall_to_monotonic;
+}
+
 struct timespec current_kernel_time(void)
 {
         struct timespec now;