3 files changed, 25 insertions, 44 deletions

diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 9b5dff6b3f6a..44019ce30a14 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -297,18 +297,13 @@ handle_simple_irq(unsigned int irq, struct irq_desc *desc)
 
         if (unlikely(desc->status & IRQ_INPROGRESS))
                 goto out_unlock;
+        desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
         kstat_cpu(cpu).irqs[irq]++;
 
         action = desc->action;
-        if (unlikely(!action || (desc->status & IRQ_DISABLED))) {
-                if (desc->chip->mask)
-                        desc->chip->mask(irq);
-                desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
-                desc->status |= IRQ_PENDING;
+        if (unlikely(!action || (desc->status & IRQ_DISABLED)))
                 goto out_unlock;
-        }
 
-        desc->status &= ~(IRQ_REPLAY | IRQ_WAITING | IRQ_PENDING);
         desc->status |= IRQ_INPROGRESS;
         spin_unlock(&desc->lock);
 
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index aa82d7bf478a..5b86698faa0b 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -384,45 +384,19 @@ int tick_resume_broadcast_oneshot(struct clock_event_device *bc)
 }
 
 /*
- * Reprogram the broadcast device:
- *
- * Called with tick_broadcast_lock held and interrupts disabled.
- */
-static int tick_broadcast_reprogram(void)
-{
-        ktime_t expires = { .tv64 = KTIME_MAX };
-        struct tick_device *td;
-        int cpu;
-
-        /*
-         * Find the event which expires next:
-         */
-        for (cpu = first_cpu(tick_broadcast_oneshot_mask); cpu != NR_CPUS;
-             cpu = next_cpu(cpu, tick_broadcast_oneshot_mask)) {
-                td = &per_cpu(tick_cpu_device, cpu);
-                if (td->evtdev->next_event.tv64 < expires.tv64)
-                        expires = td->evtdev->next_event;
-        }
-
-        if (expires.tv64 == KTIME_MAX)
-                return 0;
-
-        return tick_broadcast_set_event(expires, 0);
-}
-
-/*
  * Handle oneshot mode broadcasting
  */
 static void tick_handle_oneshot_broadcast(struct clock_event_device *dev)
 {
         struct tick_device *td;
         cpumask_t mask;
-        ktime_t now;
+        ktime_t now, next_event;
         int cpu;
 
         spin_lock(&tick_broadcast_lock);
 again:
         dev->next_event.tv64 = KTIME_MAX;
+        next_event.tv64 = KTIME_MAX;
         mask = CPU_MASK_NONE;
         now = ktime_get();
         /* Find all expired events */
@@ -431,19 +405,31 @@ again:
                 td = &per_cpu(tick_cpu_device, cpu);
                 if (td->evtdev->next_event.tv64 <= now.tv64)
                         cpu_set(cpu, mask);
+                else if (td->evtdev->next_event.tv64 < next_event.tv64)
+                        next_event.tv64 = td->evtdev->next_event.tv64;
         }
 
         /*
-         * Wakeup the cpus which have an expired event. The broadcast
-         * device is reprogrammed in the return from idle code.
+         * Wakeup the cpus which have an expired event.
+         */
+        tick_do_broadcast(mask);
+
+        /*
+         * Two reasons for reprogram:
+         *
+         * - The global event did not expire any CPU local
+         * events. This happens in dyntick mode, as the maximum PIT
+         * delta is quite small.
+         *
+         * - There are pending events on sleeping CPUs which were not
+         * in the event mask
          */
-        if (!tick_do_broadcast(mask)) {
+        if (next_event.tv64 != KTIME_MAX) {
                 /*
-                 * The global event did not expire any CPU local
-                 * events. This happens in dyntick mode, as the
-                 * maximum PIT delta is quite small.
+                 * Rearm the broadcast device. If event expired,
+                 * repeat the above
                  */
-                if (tick_broadcast_reprogram())
+                if (tick_broadcast_set_event(next_event, 0))
                         goto again;
         }
         spin_unlock(&tick_broadcast_lock);
diff --git a/kernel/timer.c b/kernel/timer.c
index a05817c021d6..d4527dcef1af 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -1219,11 +1219,11 @@ asmlinkage long sys_sysinfo(struct sysinfo __user *info)
  */
 static struct lock_class_key base_lock_keys[NR_CPUS];
 
-static int __devinit init_timers_cpu(int cpu)
+static int __cpuinit init_timers_cpu(int cpu)
 {
         int j;
         tvec_base_t *base;
-        static char __devinitdata tvec_base_done[NR_CPUS];
+        static char __cpuinitdata tvec_base_done[NR_CPUS];
 
         if (!tvec_base_done[cpu]) {
                 static char boot_done;