7 files changed, 118 insertions, 28 deletions

diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index de93a8176ca6..ec4cb9f3e3b7 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -540,19 +540,19 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
 /*
  * Switch to high resolution mode
  */
-static void hrtimer_switch_to_hres(void)
+static int hrtimer_switch_to_hres(void)
 {
         struct hrtimer_cpu_base *base = &__get_cpu_var(hrtimer_bases);
         unsigned long flags;
 
         if (base->hres_active)
-                return;
+                return 1;
 
         local_irq_save(flags);
 
         if (tick_init_highres()) {
                 local_irq_restore(flags);
-                return;
+                return 0;
         }
         base->hres_active = 1;
         base->clock_base[CLOCK_REALTIME].resolution = KTIME_HIGH_RES;
@@ -565,13 +565,14 @@ static void hrtimer_switch_to_hres(void)
         local_irq_restore(flags);
         printk(KERN_INFO "Switched to high resolution mode on CPU %d\n",
                smp_processor_id());
+        return 1;
 }
 
 #else
 
 static inline int hrtimer_hres_active(void) { return 0; }
 static inline int hrtimer_is_hres_enabled(void) { return 0; }
-static inline void hrtimer_switch_to_hres(void) { }
+static inline int hrtimer_switch_to_hres(void) { return 0; }
 static inline void hrtimer_force_reprogram(struct hrtimer_cpu_base *base) { }
 static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
                                             struct hrtimer_clock_base *base)
@@ -1130,6 +1131,9 @@ static inline void run_hrtimer_queue(struct hrtimer_cpu_base *cpu_base,
                 if (base->softirq_time.tv64 <= timer->expires.tv64)
                         break;
 
+#ifdef CONFIG_HIGH_RES_TIMERS
+                WARN_ON_ONCE(timer->cb_mode == HRTIMER_CB_IRQSAFE_NO_SOFTIRQ);
+#endif
                 timer_stats_account_hrtimer(timer);
 
                 fn = timer->function;
@@ -1173,7 +1177,8 @@ void hrtimer_run_queues(void)
          * deadlock vs. xtime_lock.
          */
         if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))
-                hrtimer_switch_to_hres();
+                if (hrtimer_switch_to_hres())
+                        return;
 
         hrtimer_get_softirq_time(cpu_base);
 
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 95f6657fff73..51a4dd0f1b74 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -81,29 +81,34 @@ config SOFTWARE_SUSPEND
         bool "Software Suspend"
         depends on PM && SWAP && ((X86 && (!SMP || SUSPEND_SMP)) || ((FRV || PPC32) && !SMP))
         ---help---
-          Enable the possibility of suspending the machine.
-          It doesn't need ACPI or APM.
-          You may suspend your machine by 'swsusp' or 'shutdown -z <time>' 
-          (patch for sysvinit needed). 
+          Enable the suspend to disk (STD) functionality.
 
-          It creates an image which is saved in your active swap. Upon next
+          You can suspend your machine with 'echo disk > /sys/power/state'.
+          Alternatively, you can use the additional userland tools available
+          from <http://suspend.sf.net>.
+
+          In principle it does not require ACPI or APM, although for example
+          ACPI will be used if available.
+
+          It creates an image which is saved in your active swap. Upon the next
           boot, pass the 'resume=/dev/swappartition' argument to the kernel to
           have it detect the saved image, restore memory state from it, and
           continue to run as before. If you do not want the previous state to
-          be reloaded, then use the 'noresume' kernel argument. However, note
-          that your partitions will be fsck'd and you must re-mkswap your swap
-          partitions. It does not work with swap files.
+          be reloaded, then use the 'noresume' kernel command line argument.
+          Note, however, that fsck will be run on your filesystems and you will
+          need to run mkswap against the swap partition used for the suspend.
 
-          Right now you may boot without resuming and then later resume but
-          in meantime you cannot use those swap partitions/files which were
-          involved in suspending. Also in this case there is a risk that buffers
-          on disk won't match with saved ones.
+          It also works with swap files to a limited extent (for details see
+          <file:Documentation/power/swsusp-and-swap-files.txt>).
 
-          For more information take a look at <file:Documentation/power/swsusp.txt>.
+          Right now you may boot without resuming and resume later but in the
+          meantime you cannot use the swap partition(s)/file(s) involved in
+          suspending.  Also in this case you must not use the filesystems
+          that were mounted before the suspend.  In particular, you MUST NOT
+          MOUNT any journaled filesystems mounted before the suspend or they
+          will get corrupted in a nasty way.
 
-          (For now, swsusp is incompatible with PAE aka HIGHMEM_64G on i386.
-          we need identity mapping for resume to work, and that is trivial
-          to get with 4MB pages, but less than trivial on PAE).
+          For more information take a look at <file:Documentation/power/swsusp.txt>.
 
 config PM_STD_PARTITION
         string "Default resume partition"
diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index 482b11ff65cb..bcd14e83ef39 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -60,19 +60,19 @@ static int test_no_idle_hz;	/* Test RCU's support for tickless idle CPUs. */
 static int shuffle_interval = 5; /* Interval between shuffles (in sec)*/
 static char *torture_type = "rcu"; /* What RCU implementation to torture. */
 
-module_param(nreaders, int, 0);
+module_param(nreaders, int, 0444);
 MODULE_PARM_DESC(nreaders, "Number of RCU reader threads");
-module_param(nfakewriters, int, 0);
+module_param(nfakewriters, int, 0444);
 MODULE_PARM_DESC(nfakewriters, "Number of RCU fake writer threads");
-module_param(stat_interval, int, 0);
+module_param(stat_interval, int, 0444);
 MODULE_PARM_DESC(stat_interval, "Number of seconds between stats printk()s");
-module_param(verbose, bool, 0);
+module_param(verbose, bool, 0444);
 MODULE_PARM_DESC(verbose, "Enable verbose debugging printk()s");
-module_param(test_no_idle_hz, bool, 0);
+module_param(test_no_idle_hz, bool, 0444);
 MODULE_PARM_DESC(test_no_idle_hz, "Test support for tickless idle CPUs");
-module_param(shuffle_interval, int, 0);
+module_param(shuffle_interval, int, 0444);
 MODULE_PARM_DESC(shuffle_interval, "Number of seconds between shuffles");
-module_param(torture_type, charp, 0);
+module_param(torture_type, charp, 0444);
 MODULE_PARM_DESC(torture_type, "Type of RCU to torture (rcu, rcu_bh, srcu)");
 
 #define TORTURE_FLAG "-torture:"
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 12b3efeb9f6f..5567745470f7 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -284,6 +284,42 @@ void tick_shutdown_broadcast(unsigned int *cpup)
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 
+void tick_suspend_broadcast(void)
+{
+        struct clock_event_device *bc;
+        unsigned long flags;
+
+        spin_lock_irqsave(&tick_broadcast_lock, flags);
+
+        bc = tick_broadcast_device.evtdev;
+        if (bc && tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
+                clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
+
+        spin_unlock_irqrestore(&tick_broadcast_lock, flags);
+}
+
+int tick_resume_broadcast(void)
+{
+        struct clock_event_device *bc;
+        unsigned long flags;
+        int broadcast = 0;
+
+        spin_lock_irqsave(&tick_broadcast_lock, flags);
+
+        bc = tick_broadcast_device.evtdev;
+        if (bc) {
+                if (tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC &&
+                    !cpus_empty(tick_broadcast_mask))
+                        tick_broadcast_start_periodic(bc);
+
+                broadcast = cpu_isset(smp_processor_id(), tick_broadcast_mask);
+        }
+        spin_unlock_irqrestore(&tick_broadcast_lock, flags);
+
+        return broadcast;
+}
+
+
 #ifdef CONFIG_TICK_ONESHOT
 
 static cpumask_t tick_broadcast_oneshot_mask;
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index 0986a2bfab49..43ba1bdec14c 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -298,6 +298,28 @@ static void tick_shutdown(unsigned int *cpup)
         spin_unlock_irqrestore(&tick_device_lock, flags);
 }
 
+static void tick_suspend_periodic(void)
+{
+        struct tick_device *td = &__get_cpu_var(tick_cpu_device);
+        unsigned long flags;
+
+        spin_lock_irqsave(&tick_device_lock, flags);
+        if (td->mode == TICKDEV_MODE_PERIODIC)
+                clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_SHUTDOWN);
+        spin_unlock_irqrestore(&tick_device_lock, flags);
+}
+
+static void tick_resume_periodic(void)
+{
+        struct tick_device *td = &__get_cpu_var(tick_cpu_device);
+        unsigned long flags;
+
+        spin_lock_irqsave(&tick_device_lock, flags);
+        if (td->mode == TICKDEV_MODE_PERIODIC)
+                tick_setup_periodic(td->evtdev, 0);
+        spin_unlock_irqrestore(&tick_device_lock, flags);
+}
+
 /*
  * Notification about clock event devices
  */
@@ -325,6 +347,16 @@ static int tick_notify(struct notifier_block *nb, unsigned long reason,
                 tick_shutdown(dev);
                 break;
 
+        case CLOCK_EVT_NOTIFY_SUSPEND:
+                tick_suspend_periodic();
+                tick_suspend_broadcast();
+                break;
+
+        case CLOCK_EVT_NOTIFY_RESUME:
+                if (!tick_resume_broadcast())
+                        tick_resume_periodic();
+                break;
+
         default:
                 break;
         }
diff --git a/kernel/time/tick-internal.h b/kernel/time/tick-internal.h
index 54861a0f29ff..75890efd24ff 100644
--- a/kernel/time/tick-internal.h
+++ b/kernel/time/tick-internal.h
@@ -67,6 +67,8 @@ extern int tick_check_broadcast_device(struct clock_event_device *dev);
 extern int tick_is_broadcast_device(struct clock_event_device *dev);
 extern void tick_broadcast_on_off(unsigned long reason, int *oncpu);
 extern void tick_shutdown_broadcast(unsigned int *cpup);
+extern void tick_suspend_broadcast(void);
+extern int tick_resume_broadcast(void);
 
 extern void
 tick_set_periodic_handler(struct clock_event_device *dev, int broadcast);
@@ -90,6 +92,8 @@ static inline int tick_device_uses_broadcast(struct clock_event_device *dev,
 static inline void tick_do_periodic_broadcast(struct clock_event_device *d) { }
 static inline void tick_broadcast_on_off(unsigned long reason, int *oncpu) { }
 static inline void tick_shutdown_broadcast(unsigned int *cpup) { }
+static inline void tick_suspend_broadcast(void) { }
+static inline int tick_resume_broadcast(void) { return 0; }
 
 /*
  * Set the periodic handler in non broadcast mode
diff --git a/kernel/timer.c b/kernel/timer.c
index 8ad384253ef2..797cccb86431 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -862,6 +862,8 @@ int do_settimeofday(struct timespec *tv)
         clock->error = 0;
         ntp_clear();
 
+        update_vsyscall(&xtime, clock);
+
         write_sequnlock_irqrestore(&xtime_lock, flags);
 
         /* signal hrtimers about time change */
@@ -997,6 +999,9 @@ static int timekeeping_resume(struct sys_device *dev)
         write_sequnlock_irqrestore(&xtime_lock, flags);
 
         touch_softlockup_watchdog();
+
+        clockevents_notify(CLOCK_EVT_NOTIFY_RESUME, NULL);
+
         /* Resume hrtimers */
         clock_was_set();
 
@@ -1011,6 +1016,9 @@ static int timekeeping_suspend(struct sys_device *dev, pm_message_t state)
         timekeeping_suspended = 1;
         timekeeping_suspend_time = read_persistent_clock();
         write_sequnlock_irqrestore(&xtime_lock, flags);
+
+        clockevents_notify(CLOCK_EVT_NOTIFY_SUSPEND, NULL);
+
         return 0;
 }