8 files changed, 43 insertions, 59 deletions

diff --git a/kernel/time/Kconfig b/kernel/time/Kconfig
index f66351126544..8d53106a0a92 100644
--- a/kernel/time/Kconfig
+++ b/kernel/time/Kconfig
@@ -23,3 +23,8 @@ config HIGH_RES_TIMERS
           hardware is not capable then this option only increases
           the size of the kernel image.
 
+config GENERIC_CLOCKEVENTS_BUILD
+        bool
+        default y
+        depends on GENERIC_CLOCKEVENTS || GENERIC_CLOCKEVENTS_MIGR
+
diff --git a/kernel/time/Makefile b/kernel/time/Makefile
index 99b6034fc86b..905b0b50792d 100644
--- a/kernel/time/Makefile
+++ b/kernel/time/Makefile
@@ -1,6 +1,6 @@
 obj-y += timekeeping.o ntp.o clocksource.o jiffies.o timer_list.o
 
-obj-$(CONFIG_GENERIC_CLOCKEVENTS)               += clockevents.o
+obj-$(CONFIG_GENERIC_CLOCKEVENTS_BUILD)         += clockevents.o
 obj-$(CONFIG_GENERIC_CLOCKEVENTS)               += tick-common.o
 obj-$(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)     += tick-broadcast.o
 obj-$(CONFIG_TICK_ONESHOT)                      += tick-oneshot.o
diff --git a/kernel/time/clockevents.c b/kernel/time/clockevents.c
index 41dd3105ce7f..822beebe664a 100644
--- a/kernel/time/clockevents.c
+++ b/kernel/time/clockevents.c
@@ -194,6 +194,7 @@ void clockevents_exchange_device(struct clock_event_device *old,
         local_irq_restore(flags);
 }
 
+#ifdef CONFIG_GENERIC_CLOCKEVENTS
 /**
  * clockevents_notify - notification about relevant events
  */
@@ -222,4 +223,4 @@ void clockevents_notify(unsigned long reason, void *arg)
         spin_unlock(&clockevents_lock);
 }
 EXPORT_SYMBOL_GPL(clockevents_notify);
-
+#endif
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index 51b6a6a6158c..c8a9d13874df 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -207,15 +207,12 @@ static inline void clocksource_resume_watchdog(void) { }
  */
 void clocksource_resume(void)
 {
-        struct list_head *tmp;
+        struct clocksource *cs;
         unsigned long flags;
 
         spin_lock_irqsave(&clocksource_lock, flags);
 
-        list_for_each(tmp, &clocksource_list) {
-                struct clocksource *cs;
-
-                cs = list_entry(tmp, struct clocksource, list);
+        list_for_each_entry(cs, &clocksource_list, list) {
                 if (cs->resume)
                         cs->resume();
         }
@@ -369,7 +366,6 @@ static ssize_t sysfs_override_clocksource(struct sys_device *dev,
                                           const char *buf, size_t count)
 {
         struct clocksource *ovr = NULL;
-        struct list_head *tmp;
         size_t ret = count;
         int len;
 
@@ -389,12 +385,11 @@ static ssize_t sysfs_override_clocksource(struct sys_device *dev,
 
         len = strlen(override_name);
         if (len) {
+                struct clocksource *cs;
+
                 ovr = clocksource_override;
                 /* try to select it: */
-                list_for_each(tmp, &clocksource_list) {
-                        struct clocksource *cs;
-
-                        cs = list_entry(tmp, struct clocksource, list);
+                list_for_each_entry(cs, &clocksource_list, list) {
                         if (strlen(cs->name) == len &&
                             !strcmp(cs->name, override_name))
                                 ovr = cs;
@@ -422,14 +417,11 @@ static ssize_t sysfs_override_clocksource(struct sys_device *dev,
 static ssize_t
 sysfs_show_available_clocksources(struct sys_device *dev, char *buf)
 {
-        struct list_head *tmp;
+        struct clocksource *src;
         char *curr = buf;
 
         spin_lock_irq(&clocksource_lock);
-        list_for_each(tmp, &clocksource_list) {
-                struct clocksource *src;
-
-                src = list_entry(tmp, struct clocksource, list);
+        list_for_each_entry(src, &clocksource_list, list) {
                 curr += sprintf(curr, "%s ", src->name);
         }
         spin_unlock_irq(&clocksource_lock);
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 0962e0577660..8cfb8b2ce773 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -64,8 +64,9 @@ static void tick_broadcast_start_periodic(struct clock_event_device *bc)
  */
 int tick_check_broadcast_device(struct clock_event_device *dev)
 {
-        if (tick_broadcast_device.evtdev ||
-            (dev->features & CLOCK_EVT_FEAT_C3STOP))
+        if ((tick_broadcast_device.evtdev &&
+             tick_broadcast_device.evtdev->rating >= dev->rating) ||
+             (dev->features & CLOCK_EVT_FEAT_C3STOP))
                 return 0;
 
         clockevents_exchange_device(NULL, dev);
@@ -176,8 +177,6 @@ static void tick_do_periodic_broadcast(void)
  */
 static void tick_handle_periodic_broadcast(struct clock_event_device *dev)
 {
-        dev->next_event.tv64 = KTIME_MAX;
-
         tick_do_periodic_broadcast();
 
         /*
@@ -218,26 +217,33 @@ static void tick_do_broadcast_on_off(void *why)
         bc = tick_broadcast_device.evtdev;
 
         /*
-         * Is the device in broadcast mode forever or is it not
-         * affected by the powerstate ?
+         * Is the device not affected by the powerstate ?
          */
-        if (!dev || !tick_device_is_functional(dev) ||
-            !(dev->features & CLOCK_EVT_FEAT_C3STOP))
+        if (!dev || !(dev->features & CLOCK_EVT_FEAT_C3STOP))
+                goto out;
+
+        if (!tick_device_is_functional(dev))
                 goto out;
 
-        if (*reason == CLOCK_EVT_NOTIFY_BROADCAST_ON) {
+        switch (*reason) {
+        case CLOCK_EVT_NOTIFY_BROADCAST_ON:
+        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)
                                 clockevents_set_mode(dev,
                                                      CLOCK_EVT_MODE_SHUTDOWN);
                 }
-        } else {
+                if (*reason == CLOCK_EVT_NOTIFY_BROADCAST_FORCE)
+                        dev->features |= CLOCK_EVT_FEAT_DUMMY;
+                break;
+        case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
                 if (cpu_isset(cpu, tick_broadcast_mask)) {
                         cpu_clear(cpu, tick_broadcast_mask);
                         if (td->mode == TICKDEV_MODE_PERIODIC)
                                 tick_setup_periodic(dev, 0);
                 }
+                break;
         }
 
         if (cpus_empty(tick_broadcast_mask))
@@ -258,21 +264,12 @@ out:
  */
 void tick_broadcast_on_off(unsigned long reason, int *oncpu)
 {
-        int cpu = get_cpu();
-
-        if (!cpu_isset(*oncpu, cpu_online_map)) {
+        if (!cpu_isset(*oncpu, cpu_online_map))
                 printk(KERN_ERR "tick-braodcast: ignoring broadcast for "
                        "offline CPU #%d\n", *oncpu);
-        } else {
-
-                if (cpu == *oncpu)
-                        tick_do_broadcast_on_off(&reason);
-                else
-                        smp_call_function_single(*oncpu,
-                                                 tick_do_broadcast_on_off,
-                                                 &reason, 1, 1);
-        }
-        put_cpu();
+        else
+                smp_call_function_single(*oncpu, tick_do_broadcast_on_off,
+                                         &reason, 1, 1);
 }
 
 /*
@@ -515,11 +512,9 @@ static void tick_broadcast_clear_oneshot(int cpu)
  */
 void tick_broadcast_setup_oneshot(struct clock_event_device *bc)
 {
-        if (bc->mode != CLOCK_EVT_MODE_ONESHOT) {
-                bc->event_handler = tick_handle_oneshot_broadcast;
-                clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
-                bc->next_event.tv64 = KTIME_MAX;
-        }
+        bc->event_handler = tick_handle_oneshot_broadcast;
+        clockevents_set_mode(bc, CLOCK_EVT_MODE_ONESHOT);
+        bc->next_event.tv64 = KTIME_MAX;
 }
 
 /*
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index 77a21abc8716..1bea399a9ef0 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -200,7 +200,7 @@ static int tick_check_new_device(struct clock_event_device *newdev)
 
         cpu = smp_processor_id();
         if (!cpu_isset(cpu, newdev->cpumask))
-                goto out;
+                goto out_bc;
 
         td = &per_cpu(tick_cpu_device, cpu);
         curdev = td->evtdev;
@@ -265,7 +265,7 @@ out_bc:
          */
         if (tick_check_broadcast_device(newdev))
                 ret = NOTIFY_STOP;
-out:
+
         spin_unlock_irqrestore(&tick_device_lock, flags);
 
         return ret;
@@ -345,6 +345,7 @@ static int tick_notify(struct notifier_block *nb, unsigned long reason,
 
         case CLOCK_EVT_NOTIFY_BROADCAST_ON:
         case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
+        case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
                 tick_broadcast_on_off(reason, dev);
                 break;
 
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 637519af6151..10a1347597fd 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -586,7 +586,7 @@ void tick_setup_sched_timer(void)
         /* Get the next period (per cpu) */
         ts->sched_timer.expires = tick_init_jiffy_update();
         offset = ktime_to_ns(tick_period) >> 1;
-        do_div(offset, NR_CPUS);
+        do_div(offset, num_possible_cpus());
         offset *= smp_processor_id();
         ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);
 
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 4ad79f6bdec6..e5e466b27598 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -24,9 +24,7 @@
  * This read-write spinlock protects us from races in SMP while
  * playing with xtime and avenrun.
  */
-__attribute__((weak)) __cacheline_aligned_in_smp DEFINE_SEQLOCK(xtime_lock);
-
-EXPORT_SYMBOL(xtime_lock);
+__cacheline_aligned_in_smp DEFINE_SEQLOCK(xtime_lock);
 
 
 /*
@@ -47,21 +45,13 @@ EXPORT_SYMBOL(xtime_lock);
 struct timespec xtime __attribute__ ((aligned (16)));
 struct timespec wall_to_monotonic __attribute__ ((aligned (16)));
 static unsigned long total_sleep_time;          /* seconds */
-EXPORT_SYMBOL(xtime);
-
 
-#ifdef CONFIG_NO_HZ
 static struct timespec xtime_cache __attribute__ ((aligned (16)));
 static inline void update_xtime_cache(u64 nsec)
 {
         xtime_cache = xtime;
         timespec_add_ns(&xtime_cache, nsec);
 }
-#else
-#define xtime_cache xtime
-/* We do *not* want to evaluate the argument for this case */
-#define update_xtime_cache(n) do { } while (0)
-#endif
 
 static struct clocksource *clock; /* pointer to current clocksource */