10 files changed, 290 insertions, 147 deletions

diff --git a/kernel/time/Kconfig b/kernel/time/Kconfig
index 8d53106a0a92..95ed42951e0a 100644
--- a/kernel/time/Kconfig
+++ b/kernel/time/Kconfig
@@ -3,7 +3,6 @@
 #
 config TICK_ONESHOT
         bool
-        default n
 
 config NO_HZ
         bool "Tickless System (Dynamic Ticks)"
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index 093d4acf993b..9ed2eec97526 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -325,6 +325,9 @@ int clocksource_register(struct clocksource *c)
         unsigned long flags;
         int ret;
 
+        /* save mult_orig on registration */
+        c->mult_orig = c->mult;
+
         spin_lock_irqsave(&clocksource_lock, flags);
         ret = clocksource_enqueue(c);
         if (!ret)
diff --git a/kernel/time/jiffies.c b/kernel/time/jiffies.c
index 4c256fdb8875..1ca99557e929 100644
--- a/kernel/time/jiffies.c
+++ b/kernel/time/jiffies.c
@@ -61,6 +61,7 @@ struct clocksource clocksource_jiffies = {
         .read           = jiffies_read,
         .mask           = 0xffffffff, /*32bits*/
         .mult           = NSEC_PER_JIFFY << JIFFIES_SHIFT, /* details above */
+        .mult_orig      = NSEC_PER_JIFFY << JIFFIES_SHIFT,
         .shift          = JIFFIES_SHIFT,
 };
 
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index 1ad46f3df6e7..8ff15e5d486b 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -10,13 +10,13 @@
 
 #include <linux/mm.h>
 #include <linux/time.h>
-#include <linux/timer.h>
 #include <linux/timex.h>
 #include <linux/jiffies.h>
 #include <linux/hrtimer.h>
 #include <linux/capability.h>
 #include <linux/math64.h>
 #include <linux/clocksource.h>
+#include <linux/workqueue.h>
 #include <asm/timex.h>
 
 /*
@@ -142,8 +142,7 @@ static enum hrtimer_restart ntp_leap_second(struct hrtimer *timer)
                 time_state = TIME_OOP;
                 printk(KERN_NOTICE "Clock: "
                        "inserting leap second 23:59:60 UTC\n");
-                leap_timer.expires = ktime_add_ns(leap_timer.expires,
-                                                  NSEC_PER_SEC);
+                hrtimer_add_expires_ns(&leap_timer, NSEC_PER_SEC);
                 res = HRTIMER_RESTART;
                 break;
         case TIME_DEL:
@@ -218,11 +217,11 @@ void second_overflow(void)
 /* Disable the cmos update - used by virtualization and embedded */
 int no_sync_cmos_clock  __read_mostly;
 
-static void sync_cmos_clock(unsigned long dummy);
+static void sync_cmos_clock(struct work_struct *work);
 
-static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0);
+static DECLARE_DELAYED_WORK(sync_cmos_work, sync_cmos_clock);
 
-static void sync_cmos_clock(unsigned long dummy)
+static void sync_cmos_clock(struct work_struct *work)
 {
         struct timespec now, next;
         int fail = 1;
@@ -258,13 +257,13 @@ static void sync_cmos_clock(unsigned long dummy)
                 next.tv_sec++;
                 next.tv_nsec -= NSEC_PER_SEC;
         }
-        mod_timer(&sync_cmos_timer, jiffies + timespec_to_jiffies(&next));
+        schedule_delayed_work(&sync_cmos_work, timespec_to_jiffies(&next));
 }
 
 static void notify_cmos_timer(void)
 {
         if (!no_sync_cmos_clock)
-                mod_timer(&sync_cmos_timer, jiffies + 1);
+                schedule_delayed_work(&sync_cmos_work, 0);
 }
 
 #else
@@ -277,38 +276,50 @@ static inline void notify_cmos_timer(void) { }
 int do_adjtimex(struct timex *txc)
 {
         struct timespec ts;
-        long save_adjust, sec;
         int result;
 
-        /* In order to modify anything, you gotta be super-user! */
-        if (txc->modes && !capable(CAP_SYS_TIME))
-                return -EPERM;
-
-        /* Now we validate the data before disabling interrupts */
-
-        if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT) {
+        /* Validate the data before disabling interrupts */
+        if (txc->modes & ADJ_ADJTIME) {
                 /* singleshot must not be used with any other mode bits */
-                if (txc->modes & ~ADJ_OFFSET_SS_READ)
+                if (!(txc->modes & ADJ_OFFSET_SINGLESHOT))
                         return -EINVAL;
+                if (!(txc->modes & ADJ_OFFSET_READONLY) &&
+                    !capable(CAP_SYS_TIME))
+                        return -EPERM;
+        } else {
+                /* In order to modify anything, you gotta be super-user! */
+                 if (txc->modes && !capable(CAP_SYS_TIME))
+                        return -EPERM;
+
+                /* if the quartz is off by more than 10% something is VERY wrong! */
+                if (txc->modes & ADJ_TICK &&
+                    (txc->tick <  900000/USER_HZ ||
+                     txc->tick > 1100000/USER_HZ))
+                                return -EINVAL;
+
+                if (txc->modes & ADJ_STATUS && time_state != TIME_OK)
+                        hrtimer_cancel(&leap_timer);
         }
 
-        /* if the quartz is off by more than 10% something is VERY wrong ! */
-        if (txc->modes & ADJ_TICK)
-                if (txc->tick <  900000/USER_HZ ||
-                    txc->tick > 1100000/USER_HZ)
-                        return -EINVAL;
-
-        if (time_state != TIME_OK && txc->modes & ADJ_STATUS)
-                hrtimer_cancel(&leap_timer);
         getnstimeofday(&ts);
 
         write_seqlock_irq(&xtime_lock);
 
-        /* Save for later - semantics of adjtime is to return old value */
-        save_adjust = time_adjust;
-
         /* If there are input parameters, then process them */
+        if (txc->modes & ADJ_ADJTIME) {
+                long save_adjust = time_adjust;
+
+                if (!(txc->modes & ADJ_OFFSET_READONLY)) {
+                        /* adjtime() is independent from ntp_adjtime() */
+                        time_adjust = txc->offset;
+                        ntp_update_frequency();
+                }
+                txc->offset = save_adjust;
+                goto adj_done;
+        }
         if (txc->modes) {
+                long sec;
+
                 if (txc->modes & ADJ_STATUS) {
                         if ((time_status & STA_PLL) &&
                             !(txc->status & STA_PLL)) {
@@ -375,13 +386,8 @@ int do_adjtimex(struct timex *txc)
                 if (txc->modes & ADJ_TAI && txc->constant > 0)
                         time_tai = txc->constant;
 
-                if (txc->modes & ADJ_OFFSET) {
-                        if (txc->modes == ADJ_OFFSET_SINGLESHOT)
-                                /* adjtime() is independent from ntp_adjtime() */
-                                time_adjust = txc->offset;
-                        else
-                                ntp_update_offset(txc->offset);
-                }
+                if (txc->modes & ADJ_OFFSET)
+                        ntp_update_offset(txc->offset);
                 if (txc->modes & ADJ_TICK)
                         tick_usec = txc->tick;
 
@@ -389,22 +395,18 @@ int do_adjtimex(struct timex *txc)
                         ntp_update_frequency();
         }
 
+        txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
+                                  NTP_SCALE_SHIFT);
+        if (!(time_status & STA_NANO))
+                txc->offset /= NSEC_PER_USEC;
+
+adj_done:
         result = time_state;    /* mostly `TIME_OK' */
         if (time_status & (STA_UNSYNC|STA_CLOCKERR))
                 result = TIME_ERROR;
 
-        if ((txc->modes == ADJ_OFFSET_SINGLESHOT) ||
-            (txc->modes == ADJ_OFFSET_SS_READ))
-                txc->offset = save_adjust;
-        else {
-                txc->offset = shift_right(time_offset * NTP_INTERVAL_FREQ,
-                                          NTP_SCALE_SHIFT);
-                if (!(time_status & STA_NANO))
-                        txc->offset /= NSEC_PER_USEC;
-        }
-        txc->freq          = shift_right((s32)(time_freq >> PPM_SCALE_INV_SHIFT) *
-                                         (s64)PPM_SCALE_INV,
-                                         NTP_SCALE_SHIFT);
+        txc->freq          = shift_right((time_freq >> PPM_SCALE_INV_SHIFT) *
+                                         (s64)PPM_SCALE_INV, NTP_SCALE_SHIFT);
         txc->maxerror      = time_maxerror;
         txc->esterror      = time_esterror;
         txc->status        = time_status;
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index f1f3eee28113..f98a1b7b16e9 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -235,7 +235,8 @@ static void tick_do_broadcast_on_off(void *why)
         case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
                 if (!cpu_isset(cpu, tick_broadcast_mask)) {
                         cpu_set(cpu, tick_broadcast_mask);
-                        if (td->mode == TICKDEV_MODE_PERIODIC)
+                        if (tick_broadcast_device.mode ==
+                            TICKDEV_MODE_PERIODIC)
                                 clockevents_shutdown(dev);
                 }
                 if (*reason == CLOCK_EVT_NOTIFY_BROADCAST_FORCE)
@@ -245,7 +246,8 @@ static void tick_do_broadcast_on_off(void *why)
                 if (!tick_broadcast_force &&
                     cpu_isset(cpu, tick_broadcast_mask)) {
                         cpu_clear(cpu, tick_broadcast_mask);
-                        if (td->mode == TICKDEV_MODE_PERIODIC)
+                        if (tick_broadcast_device.mode ==
+                            TICKDEV_MODE_PERIODIC)
                                 tick_setup_periodic(dev, 0);
                 }
                 break;
@@ -382,6 +384,19 @@ 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)
+{
+        if (cpu_isset(cpu, tick_broadcast_oneshot_mask)) {
+                struct tick_device *td = &per_cpu(tick_cpu_device, cpu);
+
+                clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_ONESHOT);
+        }
+}
+
+/*
  * Handle oneshot mode broadcasting
  */
 static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
@@ -575,4 +590,12 @@ void tick_shutdown_broadcast_oneshot(unsigned int *cpup)
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 
+/*
+ * Check, whether the broadcast device is in one shot mode
+ */
+int tick_broadcast_oneshot_active(void)
+{
+        return tick_broadcast_device.mode == TICKDEV_MODE_ONESHOT;
+}
+
 #endif
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index 019315ebf9de..df12434b43ca 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -33,7 +33,7 @@ DEFINE_PER_CPU(struct tick_device, tick_cpu_device);
  */
 ktime_t tick_next_period;
 ktime_t tick_period;
-int tick_do_timer_cpu __read_mostly = -1;
+int tick_do_timer_cpu __read_mostly = TICK_DO_TIMER_BOOT;
 DEFINE_SPINLOCK(tick_device_lock);
 
 /*
@@ -109,7 +109,8 @@ void tick_setup_periodic(struct clock_event_device *dev, int broadcast)
         if (!tick_device_is_functional(dev))
                 return;
 
-        if (dev->features & CLOCK_EVT_FEAT_PERIODIC) {
+        if ((dev->features & CLOCK_EVT_FEAT_PERIODIC) &&
+            !tick_broadcast_oneshot_active()) {
                 clockevents_set_mode(dev, CLOCK_EVT_MODE_PERIODIC);
         } else {
                 unsigned long seq;
@@ -148,7 +149,7 @@ static void tick_setup_device(struct tick_device *td,
                  * If no cpu took the do_timer update, assign it to
                  * this cpu:
                  */
-                if (tick_do_timer_cpu == -1) {
+                if (tick_do_timer_cpu == TICK_DO_TIMER_BOOT) {
                         tick_do_timer_cpu = cpu;
                         tick_next_period = ktime_get();
                         tick_period = ktime_set(0, NSEC_PER_SEC / HZ);
@@ -300,7 +301,8 @@ static void tick_shutdown(unsigned int *cpup)
         if (*cpup == tick_do_timer_cpu) {
                 int cpu = first_cpu(cpu_online_map);
 
-                tick_do_timer_cpu = (cpu != NR_CPUS) ? cpu : -1;
+                tick_do_timer_cpu = (cpu != NR_CPUS) ? cpu :
+                        TICK_DO_TIMER_NONE;
         }
         spin_unlock_irqrestore(&tick_device_lock, flags);
 }
diff --git a/kernel/time/tick-internal.h b/kernel/time/tick-internal.h
index 6e9db9734aa6..b1c05bf75ee0 100644
--- a/kernel/time/tick-internal.h
+++ b/kernel/time/tick-internal.h
@@ -1,6 +1,10 @@
 /*
  * tick internal variable and functions used by low/high res code
  */
+
+#define TICK_DO_TIMER_NONE      -1
+#define TICK_DO_TIMER_BOOT      -2
+
 DECLARE_PER_CPU(struct tick_device, tick_cpu_device);
 extern spinlock_t tick_device_lock;
 extern ktime_t tick_next_period;
@@ -31,6 +35,8 @@ extern void tick_broadcast_oneshot_control(unsigned long reason);
 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);
 # else /* BROADCAST */
 static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
 {
@@ -39,6 +45,8 @@ static inline void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
 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) { }
 # endif /* !BROADCAST */
 
 #else /* !ONESHOT */
@@ -68,6 +76,7 @@ static inline int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
 {
         return 0;
 }
+static inline int tick_broadcast_oneshot_active(void) { return 0; }
 #endif /* !TICK_ONESHOT */
 
 /*
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index a87b0468568b..5bbb1044f847 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -20,6 +20,7 @@
 #include <linux/profile.h>
 #include <linux/sched.h>
 #include <linux/tick.h>
+#include <linux/module.h>
 
 #include <asm/irq_regs.h>
 
@@ -75,6 +76,9 @@ static void tick_do_update_jiffies64(ktime_t now)
                                                            incr * ticks);
                 }
                 do_timer(++ticks);
+
+                /* Keep the tick_next_period variable up to date */
+                tick_next_period = ktime_add(last_jiffies_update, tick_period);
         }
         write_sequnlock(&xtime_lock);
 }
@@ -151,7 +155,7 @@ void tick_nohz_update_jiffies(void)
         touch_softlockup_watchdog();
 }
 
-void tick_nohz_stop_idle(int cpu)
+static void tick_nohz_stop_idle(int cpu)
 {
         struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
 
@@ -187,9 +191,17 @@ 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);
+        if (!tick_nohz_enabled)
+                return -1;
+
+        if (ts->idle_active)
+                *last_update_time = ktime_to_us(ts->idle_lastupdate);
+        else
+                *last_update_time = ktime_to_us(ktime_get());
+
         return ktime_to_us(ts->idle_sleeptime);
 }
+EXPORT_SYMBOL_GPL(get_cpu_idle_time_us);
 
 /**
  * tick_nohz_stop_sched_tick - stop the idle tick from the idle task
@@ -221,7 +233,7 @@ void tick_nohz_stop_sched_tick(int inidle)
          */
         if (unlikely(!cpu_online(cpu))) {
                 if (cpu == tick_do_timer_cpu)
-                        tick_do_timer_cpu = -1;
+                        tick_do_timer_cpu = TICK_DO_TIMER_NONE;
         }
 
         if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))
@@ -258,7 +270,7 @@ void tick_nohz_stop_sched_tick(int inidle)
         next_jiffies = get_next_timer_interrupt(last_jiffies);
         delta_jiffies = next_jiffies - last_jiffies;
 
-        if (rcu_needs_cpu(cpu))
+        if (rcu_needs_cpu(cpu) || printk_needs_cpu(cpu))
                 delta_jiffies = 1;
         /*
          * Do not stop the tick, if we are only one off
@@ -288,7 +300,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                                 goto out;
                         }
 
-                        ts->idle_tick = ts->sched_timer.expires;
+                        ts->idle_tick = hrtimer_get_expires(&ts->sched_timer);
                         ts->tick_stopped = 1;
                         ts->idle_jiffies = last_jiffies;
                         rcu_enter_nohz();
@@ -303,7 +315,7 @@ void tick_nohz_stop_sched_tick(int inidle)
                  * invoked.
                  */
                 if (cpu == tick_do_timer_cpu)
-                        tick_do_timer_cpu = -1;
+                        tick_do_timer_cpu = TICK_DO_TIMER_NONE;
 
                 ts->idle_sleeps++;
 
@@ -365,6 +377,32 @@ ktime_t tick_nohz_get_sleep_length(void)
         return ts->sleep_length;
 }
 
+static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
+{
+        hrtimer_cancel(&ts->sched_timer);
+        hrtimer_set_expires(&ts->sched_timer, ts->idle_tick);
+
+        while (1) {
+                /* Forward the time to expire in the future */
+                hrtimer_forward(&ts->sched_timer, now, tick_period);
+
+                if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
+                        hrtimer_start_expires(&ts->sched_timer,
+                                      HRTIMER_MODE_ABS);
+                        /* Check, if the timer was already in the past */
+                        if (hrtimer_active(&ts->sched_timer))
+                                break;
+                } else {
+                        if (!tick_program_event(
+                                hrtimer_get_expires(&ts->sched_timer), 0))
+                                break;
+                }
+                /* Update jiffies and reread time */
+                tick_do_update_jiffies64(now);
+                now = ktime_get();
+        }
+}
+
 /**
  * tick_nohz_restart_sched_tick - restart the idle tick from the idle task
  *
@@ -418,35 +456,16 @@ void tick_nohz_restart_sched_tick(void)
          */
         ts->tick_stopped  = 0;
         ts->idle_exittime = now;
-        hrtimer_cancel(&ts->sched_timer);
-        ts->sched_timer.expires = ts->idle_tick;
 
-        while (1) {
-                /* Forward the time to expire in the future */
-                hrtimer_forward(&ts->sched_timer, now, tick_period);
+        tick_nohz_restart(ts, now);
 
-                if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {
-                        hrtimer_start(&ts->sched_timer,
-                                      ts->sched_timer.expires,
-                                      HRTIMER_MODE_ABS);
-                        /* Check, if the timer was already in the past */
-                        if (hrtimer_active(&ts->sched_timer))
-                                break;
-                } else {
-                        if (!tick_program_event(ts->sched_timer.expires, 0))
-                                break;
-                }
-                /* Update jiffies and reread time */
-                tick_do_update_jiffies64(now);
-                now = ktime_get();
-        }
         local_irq_enable();
 }
 
 static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)
 {
         hrtimer_forward(&ts->sched_timer, now, tick_period);
-        return tick_program_event(ts->sched_timer.expires, 0);
+        return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);
 }
 
 /*
@@ -468,7 +487,7 @@ static void tick_nohz_handler(struct clock_event_device *dev)
          * this duty, then the jiffies update is still serialized by
          * xtime_lock.
          */
-        if (unlikely(tick_do_timer_cpu == -1))
+        if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
                 tick_do_timer_cpu = cpu;
 
         /* Check, if the jiffies need an update */
@@ -491,10 +510,6 @@ static void tick_nohz_handler(struct clock_event_device *dev)
         update_process_times(user_mode(regs));
         profile_tick(CPU_PROFILING);
 
-        /* Do not restart, when we are in the idle loop */
-        if (ts->tick_stopped)
-                return;
-
         while (tick_nohz_reprogram(ts, now)) {
                 now = ktime_get();
                 tick_do_update_jiffies64(now);
@@ -529,7 +544,7 @@ static void tick_nohz_switch_to_nohz(void)
         next = tick_init_jiffy_update();
 
         for (;;) {
-                ts->sched_timer.expires = next;
+                hrtimer_set_expires(&ts->sched_timer, next);
                 if (!tick_program_event(next, 0))
                         break;
                 next = ktime_add(next, tick_period);
@@ -540,6 +555,37 @@ static void tick_nohz_switch_to_nohz(void)
                smp_processor_id());
 }
 
+/*
+ * When NOHZ is enabled and the tick is stopped, we need to kick the
+ * tick timer from irq_enter() so that the jiffies update is kept
+ * alive during long running softirqs. That's ugly as hell, but
+ * correctness is key even if we need to fix the offending softirq in
+ * the first place.
+ *
+ * Note, this is different to tick_nohz_restart. We just kick the
+ * 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)
+{
+        struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);
+        ktime_t delta, now;
+
+        if (!ts->tick_stopped)
+                return;
+
+        /*
+         * Do not touch the tick device, when the next expiry is either
+         * already reached or less/equal than the tick period.
+         */
+        now = ktime_get();
+        delta = ktime_sub(hrtimer_get_expires(&ts->sched_timer), now);
+        if (delta.tv64 <= tick_period.tv64)
+                return;
+
+        tick_nohz_restart(ts, now);
+}
+
 #else
 
 static inline void tick_nohz_switch_to_nohz(void) { }
@@ -547,6 +593,19 @@ static inline void tick_nohz_switch_to_nohz(void) { }
 #endif /* NO_HZ */
 
 /*
+ * Called from irq_enter to notify about the possible interruption of idle()
+ */
+void tick_check_idle(int cpu)
+{
+        tick_check_oneshot_broadcast(cpu);
+#ifdef CONFIG_NO_HZ
+        tick_nohz_stop_idle(cpu);
+        tick_nohz_update_jiffies();
+        tick_nohz_kick_tick(cpu);
+#endif
+}
+
+/*
  * High resolution timer specific code
  */
 #ifdef CONFIG_HIGH_RES_TIMERS
@@ -570,7 +629,7 @@ static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
          * this duty, then the jiffies update is still serialized by
          * xtime_lock.
          */
-        if (unlikely(tick_do_timer_cpu == -1))
+        if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))
                 tick_do_timer_cpu = cpu;
 #endif
 
@@ -599,10 +658,6 @@ static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
                 profile_tick(CPU_PROFILING);
         }
 
-        /* Do not restart, when we are in the idle loop */
-        if (ts->tick_stopped)
-                return HRTIMER_NORESTART;
-
         hrtimer_forward(timer, now, tick_period);
 
         return HRTIMER_RESTART;
@@ -622,19 +677,18 @@ void tick_setup_sched_timer(void)
          */
         hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
         ts->sched_timer.function = tick_sched_timer;
-        ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
+        ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_PERCPU;
 
         /* Get the next period (per cpu) */
-        ts->sched_timer.expires = tick_init_jiffy_update();
+        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();
-        ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);
+        hrtimer_add_expires_ns(&ts->sched_timer, offset);
 
         for (;;) {
                 hrtimer_forward(&ts->sched_timer, now, tick_period);
-                hrtimer_start(&ts->sched_timer, ts->sched_timer.expires,
-                              HRTIMER_MODE_ABS);
+                hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS);
                 /* Check, if the timer was already in the past */
                 if (hrtimer_active(&ts->sched_timer))
                         break;
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index e91c29f961c9..e7acfb482a68 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -58,27 +58,26 @@ struct clocksource *clock;
 
 #ifdef CONFIG_GENERIC_TIME
 /**
- * __get_nsec_offset - Returns nanoseconds since last call to periodic_hook
+ * clocksource_forward_now - update clock to the current time
  *
- * private function, must hold xtime_lock lock when being
- * called. Returns the number of nanoseconds since the
- * last call to update_wall_time() (adjusted by NTP scaling)
+ * Forward the current clock to update its state since the last call to
+ * update_wall_time(). This is useful before significant clock changes,
+ * as it avoids having to deal with this time offset explicitly.
  */
-static inline s64 __get_nsec_offset(void)
+static void clocksource_forward_now(void)
 {
         cycle_t cycle_now, cycle_delta;
-        s64 ns_offset;
+        s64 nsec;
 
-        /* read clocksource: */
         cycle_now = clocksource_read(clock);
-
-        /* calculate the delta since the last update_wall_time: */
         cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
+        clock->cycle_last = cycle_now;
 
-        /* convert to nanoseconds: */
-        ns_offset = cyc2ns(clock, cycle_delta);
+        nsec = cyc2ns(clock, cycle_delta);
+        timespec_add_ns(&xtime, nsec);
 
-        return ns_offset;
+        nsec = ((s64)cycle_delta * clock->mult_orig) >> clock->shift;
+        clock->raw_time.tv_nsec += nsec;
 }
 
 /**
@@ -89,6 +88,7 @@ static inline s64 __get_nsec_offset(void)
  */
 void getnstimeofday(struct timespec *ts)
 {
+        cycle_t cycle_now, cycle_delta;
         unsigned long seq;
         s64 nsecs;
 
@@ -96,7 +96,15 @@ void getnstimeofday(struct timespec *ts)
                 seq = read_seqbegin(&xtime_lock);
 
                 *ts = xtime;
-                nsecs = __get_nsec_offset();
+
+                /* read clocksource: */
+                cycle_now = clocksource_read(clock);
+
+                /* calculate the delta since the last update_wall_time: */
+                cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
+
+                /* convert to nanoseconds: */
+                nsecs = cyc2ns(clock, cycle_delta);
 
         } while (read_seqretry(&xtime_lock, seq));
 
@@ -129,22 +137,22 @@ EXPORT_SYMBOL(do_gettimeofday);
  */
 int do_settimeofday(struct timespec *tv)
 {
+        struct timespec ts_delta;
         unsigned long flags;
-        time_t wtm_sec, sec = tv->tv_sec;
-        long wtm_nsec, nsec = tv->tv_nsec;
 
         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
                 return -EINVAL;
 
         write_seqlock_irqsave(&xtime_lock, flags);
 
-        nsec -= __get_nsec_offset();
+        clocksource_forward_now();
+
+        ts_delta.tv_sec = tv->tv_sec - xtime.tv_sec;
+        ts_delta.tv_nsec = tv->tv_nsec - xtime.tv_nsec;
+        wall_to_monotonic = timespec_sub(wall_to_monotonic, ts_delta);
 
-        wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
-        wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
+        xtime = *tv;
 
-        set_normalized_timespec(&xtime, sec, nsec);
-        set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
         update_xtime_cache(0);
 
         clock->error = 0;
@@ -170,22 +178,19 @@ EXPORT_SYMBOL(do_settimeofday);
 static void change_clocksource(void)
 {
         struct clocksource *new;
-        cycle_t now;
-        u64 nsec;
 
         new = clocksource_get_next();
 
         if (clock == new)
                 return;
 
-        new->cycle_last = 0;
-        now = clocksource_read(new);
-        nsec =  __get_nsec_offset();
-        timespec_add_ns(&xtime, nsec);
+        clocksource_forward_now();
 
-        clock = new;
-        clock->cycle_last = now;
+        new->raw_time = clock->raw_time;
 
+        clock = new;
+        clock->cycle_last = 0;
+        clock->cycle_last = clocksource_read(new);
         clock->error = 0;
         clock->xtime_nsec = 0;
         clocksource_calculate_interval(clock, NTP_INTERVAL_LENGTH);
@@ -200,11 +205,44 @@ static void change_clocksource(void)
          */
 }
 #else
+static inline void clocksource_forward_now(void) { }
 static inline void change_clocksource(void) { }
-static inline s64 __get_nsec_offset(void) { return 0; }
 #endif
 
 /**
+ * getrawmonotonic - Returns the raw monotonic time in a timespec
+ * @ts:         pointer to the timespec to be set
+ *
+ * Returns the raw monotonic time (completely un-modified by ntp)
+ */
+void getrawmonotonic(struct timespec *ts)
+{
+        unsigned long seq;
+        s64 nsecs;
+        cycle_t cycle_now, cycle_delta;
+
+        do {
+                seq = read_seqbegin(&xtime_lock);
+
+                /* read clocksource: */
+                cycle_now = clocksource_read(clock);
+
+                /* calculate the delta since the last update_wall_time: */
+                cycle_delta = (cycle_now - clock->cycle_last) & clock->mask;
+
+                /* convert to nanoseconds: */
+                nsecs = ((s64)cycle_delta * clock->mult_orig) >> clock->shift;
+
+                *ts = clock->raw_time;
+
+        } while (read_seqretry(&xtime_lock, seq));
+
+        timespec_add_ns(ts, nsecs);
+}
+EXPORT_SYMBOL(getrawmonotonic);
+
+
+/**
  * timekeeping_valid_for_hres - Check if timekeeping is suitable for hres
  */
 int timekeeping_valid_for_hres(void)
@@ -265,8 +303,6 @@ void __init timekeeping_init(void)
 static int timekeeping_suspended;
 /* time in seconds when suspend began */
 static unsigned long timekeeping_suspend_time;
-/* xtime offset when we went into suspend */
-static s64 timekeeping_suspend_nsecs;
 
 /**
  * timekeeping_resume - Resumes the generic timekeeping subsystem.
@@ -292,8 +328,6 @@ static int timekeeping_resume(struct sys_device *dev)
                 wall_to_monotonic.tv_sec -= sleep_length;
                 total_sleep_time += sleep_length;
         }
-        /* Make sure that we have the correct xtime reference */
-        timespec_add_ns(&xtime, timekeeping_suspend_nsecs);
         update_xtime_cache(0);
         /* re-base the last cycle value */
         clock->cycle_last = 0;
@@ -319,8 +353,7 @@ static int timekeeping_suspend(struct sys_device *dev, pm_message_t state)
         timekeeping_suspend_time = read_persistent_clock();
 
         write_seqlock_irqsave(&xtime_lock, flags);
-        /* Get the current xtime offset */
-        timekeeping_suspend_nsecs = __get_nsec_offset();
+        clocksource_forward_now();
         timekeeping_suspended = 1;
         write_sequnlock_irqrestore(&xtime_lock, flags);
 
@@ -454,23 +487,29 @@ void update_wall_time(void)
 #else
         offset = clock->cycle_interval;
 #endif
-        clock->xtime_nsec += (s64)xtime.tv_nsec << clock->shift;
+        clock->xtime_nsec = (s64)xtime.tv_nsec << clock->shift;
 
         /* normally this loop will run just once, however in the
          * case of lost or late ticks, it will accumulate correctly.
          */
         while (offset >= clock->cycle_interval) {
                 /* accumulate one interval */
-                clock->xtime_nsec += clock->xtime_interval;
-                clock->cycle_last += clock->cycle_interval;
                 offset -= clock->cycle_interval;
+                clock->cycle_last += clock->cycle_interval;
 
+                clock->xtime_nsec += clock->xtime_interval;
                 if (clock->xtime_nsec >= (u64)NSEC_PER_SEC << clock->shift) {
                         clock->xtime_nsec -= (u64)NSEC_PER_SEC << clock->shift;
                         xtime.tv_sec++;
                         second_overflow();
                 }
 
+                clock->raw_time.tv_nsec += clock->raw_interval;
+                if (clock->raw_time.tv_nsec >= NSEC_PER_SEC) {
+                        clock->raw_time.tv_nsec -= NSEC_PER_SEC;
+                        clock->raw_time.tv_sec++;
+                }
+
                 /* accumulate error between NTP and clock interval */
                 clock->error += tick_length;
                 clock->error -= clock->xtime_interval << (NTP_SCALE_SHIFT - clock->shift);
@@ -479,9 +518,12 @@ void update_wall_time(void)
         /* correct the clock when NTP error is too big */
         clocksource_adjust(offset);
 
-        /* store full nanoseconds into xtime */
-        xtime.tv_nsec = (s64)clock->xtime_nsec >> clock->shift;
+        /* store full nanoseconds into xtime after rounding it up and
+         * add the remainder to the error difference.
+         */
+        xtime.tv_nsec = ((s64)clock->xtime_nsec >> clock->shift) + 1;
         clock->xtime_nsec -= (s64)xtime.tv_nsec << clock->shift;
+        clock->error += clock->xtime_nsec << (NTP_SCALE_SHIFT - clock->shift);
 
         update_xtime_cache(cyc2ns(clock, offset));
 
diff --git a/kernel/time/timer_list.c b/kernel/time/timer_list.c
index a40e20fd0001..a999b92a1277 100644
--- a/kernel/time/timer_list.c
+++ b/kernel/time/timer_list.c
@@ -47,13 +47,14 @@ static void print_name_offset(struct seq_file *m, void *sym)
 }
 
 static void
-print_timer(struct seq_file *m, struct hrtimer *timer, int idx, u64 now)
+print_timer(struct seq_file *m, struct hrtimer *taddr, struct hrtimer *timer,
+            int idx, u64 now)
 {
 #ifdef CONFIG_TIMER_STATS
         char tmp[TASK_COMM_LEN + 1];
 #endif
         SEQ_printf(m, " #%d: ", idx);
-        print_name_offset(m, timer);
+        print_name_offset(m, taddr);
         SEQ_printf(m, ", ");
         print_name_offset(m, timer->function);
         SEQ_printf(m, ", S:%02lx", timer->state);
@@ -65,9 +66,11 @@ print_timer(struct seq_file *m, struct hrtimer *timer, int idx, u64 now)
         SEQ_printf(m, ", %s/%d", tmp, timer->start_pid);
 #endif
         SEQ_printf(m, "\n");
-        SEQ_printf(m, " # expires at %Lu nsecs [in %Ld nsecs]\n",
-                (unsigned long long)ktime_to_ns(timer->expires),
-                (long long)(ktime_to_ns(timer->expires) - now));
+        SEQ_printf(m, " # expires at %Lu-%Lu nsecs [in %Ld to %Ld nsecs]\n",
+                (unsigned long long)ktime_to_ns(hrtimer_get_softexpires(timer)),
+                (unsigned long long)ktime_to_ns(hrtimer_get_expires(timer)),
+                (long long)(ktime_to_ns(hrtimer_get_softexpires(timer)) - now),
+                (long long)(ktime_to_ns(hrtimer_get_expires(timer)) - now));
 }
 
 static void
@@ -99,7 +102,7 @@ next_one:
                 tmp = *timer;
                 spin_unlock_irqrestore(&base->cpu_base->lock, flags);
 
-                print_timer(m, &tmp, i, now);
+                print_timer(m, timer, &tmp, i, now);
                 next++;
                 goto next_one;
         }
@@ -109,6 +112,7 @@ next_one:
 static void
 print_base(struct seq_file *m, struct hrtimer_clock_base *base, u64 now)
 {
+        SEQ_printf(m, "  .base:       %p\n", base);
         SEQ_printf(m, "  .index:      %d\n",
                         base->index);
         SEQ_printf(m, "  .resolution: %Lu nsecs\n",
@@ -183,12 +187,16 @@ static void print_cpu(struct seq_file *m, int cpu, u64 now)
 
 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 static void
-print_tickdevice(struct seq_file *m, struct tick_device *td)
+print_tickdevice(struct seq_file *m, struct tick_device *td, int cpu)
 {
         struct clock_event_device *dev = td->evtdev;
 
         SEQ_printf(m, "\n");
         SEQ_printf(m, "Tick Device: mode:     %d\n", td->mode);
+        if (cpu < 0)
+                SEQ_printf(m, "Broadcast device\n");
+        else
+                SEQ_printf(m, "Per CPU device: %d\n", cpu);
 
         SEQ_printf(m, "Clock Event Device: ");
         if (!dev) {
@@ -222,7 +230,7 @@ static void timer_list_show_tickdevices(struct seq_file *m)
         int cpu;
 
 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
-        print_tickdevice(m, tick_get_broadcast_device());
+        print_tickdevice(m, tick_get_broadcast_device(), -1);
         SEQ_printf(m, "tick_broadcast_mask: %08lx\n",
                    tick_get_broadcast_mask()->bits[0]);
 #ifdef CONFIG_TICK_ONESHOT
@@ -232,7 +240,7 @@ static void timer_list_show_tickdevices(struct seq_file *m)
         SEQ_printf(m, "\n");
 #endif
         for_each_online_cpu(cpu)
-                   print_tickdevice(m, tick_get_device(cpu));
+                print_tickdevice(m, tick_get_device(cpu), cpu);
         SEQ_printf(m, "\n");
 }
 #else
@@ -244,7 +252,7 @@ static int timer_list_show(struct seq_file *m, void *v)
         u64 now = ktime_to_ns(ktime_get());
         int cpu;
 
-        SEQ_printf(m, "Timer List Version: v0.3\n");
+        SEQ_printf(m, "Timer List Version: v0.4\n");
         SEQ_printf(m, "HRTIMER_MAX_CLOCK_BASES: %d\n", HRTIMER_MAX_CLOCK_BASES);
         SEQ_printf(m, "now at %Ld nsecs\n", (unsigned long long)now);