3 files changed, 37 insertions, 9 deletions

diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index db8e0f3d40..aab881c86a 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -382,12 +382,23 @@ static int tick_broadcast_set_event(ktime_t expires, int force)
 
 int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
 {
+        int cpu = smp_processor_id();
+
+        /*
+         * If the CPU is marked for broadcast, enforce oneshot
+         * broadcast mode. The jinxed VAIO does not resume otherwise.
+         * No idea why it ends up in a lower C State during resume
+         * without notifying the clock events layer.
+         */
+        if (cpu_isset(cpu, tick_broadcast_mask))
+                cpu_set(cpu, tick_broadcast_oneshot_mask);
+
         clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
 
         if(!cpus_empty(tick_broadcast_oneshot_mask))
                 tick_broadcast_set_event(ktime_get(), 1);
 
-        return cpu_isset(smp_processor_id(), tick_broadcast_oneshot_mask);
+        return cpu_isset(cpu, tick_broadcast_oneshot_mask);
 }
 
 /*
@@ -549,20 +560,17 @@ void tick_broadcast_switch_to_oneshot(void)
  */
 void tick_shutdown_broadcast_oneshot(unsigned int *cpup)
 {
-        struct clock_event_device *bc;
         unsigned long flags;
         unsigned int cpu = *cpup;
 
         spin_lock_irqsave(&tick_broadcast_lock, flags);
 
-        bc = tick_broadcast_device.evtdev;
+        /*
+         * Clear the broadcast mask flag for the dead cpu, but do not
+         * stop the broadcast device!
+         */
         cpu_clear(cpu, tick_broadcast_oneshot_mask);
 
-        if (tick_broadcast_device.mode == TICKDEV_MODE_ONESHOT) {
-                if (bc && cpus_empty(tick_broadcast_oneshot_mask))
-                        clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
-        }
-
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index b416995b97..8c3fef1db0 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -160,6 +160,18 @@ void tick_nohz_stop_sched_tick(void)
         cpu = smp_processor_id();
         ts = &per_cpu(tick_cpu_sched, cpu);
 
+        /*
+         * If this cpu is offline and it is the one which updates
+         * jiffies, then give up the assignment and let it be taken by
+         * the cpu which runs the tick timer next. If we don't drop
+         * this here the jiffies might be stale and do_timer() never
+         * invoked.
+         */
+        if (unlikely(!cpu_online(cpu))) {
+                if (cpu == tick_do_timer_cpu)
+                        tick_do_timer_cpu = -1;
+        }
+
         if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE))
                 goto end;
 
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index acc417b5a9..4ad79f6bde 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -217,6 +217,7 @@ static void change_clocksource(void)
 }
 #else
 static inline void change_clocksource(void) { }
+static inline s64 __get_nsec_offset(void) { return 0; }
 #endif
 
 /**
@@ -280,6 +281,8 @@ 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.
@@ -305,6 +308,8 @@ 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);
         /* re-base the last cycle value */
         clock->cycle_last = clocksource_read(clock);
         clock->error = 0;
@@ -325,9 +330,12 @@ static int timekeeping_suspend(struct sys_device *dev, pm_message_t state)
 {
         unsigned long flags;
 
+        timekeeping_suspend_time = read_persistent_clock();
+
         write_seqlock_irqsave(&xtime_lock, flags);
+        /* Get the current xtime offset */
+        timekeeping_suspend_nsecs = __get_nsec_offset();
         timekeeping_suspended = 1;
-        timekeeping_suspend_time = read_persistent_clock();
         write_sequnlock_irqrestore(&xtime_lock, flags);
 
         clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);