1 files changed, 93 insertions, 18 deletions

diff --git a/kernel/timer.c b/kernel/timer.c
index c61a7949387f..c850d06bd19e 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -34,6 +34,7 @@
 #include <linux/posix-timers.h>
 #include <linux/cpu.h>
 #include <linux/syscalls.h>
+#include <linux/kallsyms.h>
 #include <linux/delay.h>
 #include <linux/tick.h>
 #include <linux/kallsyms.h>
@@ -74,6 +75,7 @@ struct tvec_root {
 struct tvec_base {
         spinlock_t lock;
         struct timer_list *running_timer;
+        wait_queue_head_t wait_for_running_timer;
         unsigned long timer_jiffies;
         unsigned long next_timer;
         struct tvec_root tv1;
@@ -322,9 +324,7 @@ EXPORT_SYMBOL_GPL(round_jiffies_up_relative);
 static inline void set_running_timer(struct tvec_base *base,
                                         struct timer_list *timer)
 {
-#ifdef CONFIG_SMP
         base->running_timer = timer;
-#endif
 }
 
 static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
@@ -656,6 +656,7 @@ __mod_timer(struct timer_list *timer, unsigned long expires,
 
         debug_activate(timer, expires);
 
+        preempt_disable();
         cpu = smp_processor_id();
 
 #if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
@@ -666,6 +667,8 @@ __mod_timer(struct timer_list *timer, unsigned long expires,
                         cpu = preferred_cpu;
         }
 #endif
+        preempt_enable();
+
         new_base = per_cpu(tvec_bases, cpu);
 
         if (base != new_base) {
@@ -825,6 +828,18 @@ void add_timer_on(struct timer_list *timer, int cpu)
 }
 EXPORT_SYMBOL_GPL(add_timer_on);
 
+/*
+ * Wait for a running timer
+ */
+void wait_for_running_timer(struct timer_list *timer)
+{
+        struct tvec_base *base = timer->base;
+
+        if (base->running_timer == timer)
+                wait_event(base->wait_for_running_timer,
+                           base->running_timer != timer);
+}
+
 /**
  * del_timer - deactive a timer.
  * @timer: the timer to be deactivated
@@ -859,7 +874,34 @@ int del_timer(struct timer_list *timer)
 }
 EXPORT_SYMBOL(del_timer);
 
-#ifdef CONFIG_SMP
+#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT_SOFTIRQS)
+/*
+ * This function checks whether a timer is active and not running on any
+ * CPU. Upon successful (ret >= 0) exit the timer is not queued and the
+ * handler is not running on any CPU.
+ *
+ * It must not be called from interrupt contexts.
+ */
+int timer_pending_sync(struct timer_list *timer)
+{
+        struct tvec_base *base;
+        unsigned long flags;
+        int ret = -1;
+
+        base = lock_timer_base(timer, &flags);
+
+        if (base->running_timer == timer)
+                goto out;
+
+        ret = 0;
+        if (timer_pending(timer))
+                ret = 1;
+out:
+        spin_unlock_irqrestore(&base->lock, flags);
+
+        return ret;
+}
+
 /**
  * try_to_del_timer_sync - Try to deactivate a timer
  * @timer: timer do del
@@ -927,7 +969,7 @@ int del_timer_sync(struct timer_list *timer)
                 int ret = try_to_del_timer_sync(timer);
                 if (ret >= 0)
                         return ret;
-                cpu_relax();
+                wait_for_running_timer(timer);
         }
 }
 EXPORT_SYMBOL(del_timer_sync);
@@ -972,6 +1014,20 @@ static inline void __run_timers(struct tvec_base *base)
                 struct list_head *head = &work_list;
                 int index = base->timer_jiffies & TVR_MASK;
 
+                if (softirq_need_resched()) {
+                        spin_unlock_irq(&base->lock);
+                        wake_up(&base->wait_for_running_timer);
+                        cond_resched_softirq_context();
+                        cpu_relax();
+                        spin_lock_irq(&base->lock);
+                        /*
+                         * We can simply continue after preemption, nobody
+                         * else can touch timer_jiffies so 'index' is still
+                         * valid. Any new jiffy will be taken care of in
+                         * subsequent loops:
+                         */
+                }
+
                 /*
                  * Cascade timers:
                  */
@@ -1027,18 +1083,17 @@ static inline void __run_timers(struct tvec_base *base)
                                 lock_map_release(&lockdep_map);
 
                                 if (preempt_count != preempt_count()) {
-                                        printk(KERN_ERR "huh, entered %p "
-                                               "with preempt_count %08x, exited"
-                                               " with %08x?\n",
-                                               fn, preempt_count,
-                                               preempt_count());
-                                        BUG();
+                                        print_symbol("BUG: unbalanced timer-handler preempt count in %s!\n", (unsigned long) fn);
+                                        printk("entered with %08x, exited with %08x.\n", preempt_count, preempt_count());
+                                        preempt_count() = preempt_count;
                                 }
                         }
+                        set_running_timer(base, NULL);
+                        cond_resched_softirq_context();
                         spin_lock_irq(&base->lock);
                 }
         }
-        set_running_timer(base, NULL);
+        wake_up(&base->wait_for_running_timer);
         spin_unlock_irq(&base->lock);
 }
 
@@ -1171,6 +1226,18 @@ unsigned long get_next_timer_interrupt(unsigned long now)
         struct tvec_base *base = __get_cpu_var(tvec_bases);
         unsigned long expires;
 
+#ifdef CONFIG_PREEMPT_RT
+        /*
+         * On PREEMPT_RT we cannot sleep here. If the trylock does not
+         * succeed then we return the worst-case 'expires in 1 tick'
+         * value:
+         */
+        if (spin_trylock(&base->lock)) {
+                expires = __next_timer_interrupt(base);
+                spin_unlock(&base->lock);
+        } else
+                expires = now + 1;
+#else
         spin_lock(&base->lock);
         if (time_before_eq(base->next_timer, base->timer_jiffies))
                 base->next_timer = __next_timer_interrupt(base);
@@ -1179,7 +1246,7 @@ unsigned long get_next_timer_interrupt(unsigned long now)
 
         if (time_before_eq(expires, now))
                 return now;
-
+#endif
         return cmp_next_hrtimer_event(now, expires);
 }
 #endif
@@ -1195,11 +1262,10 @@ void update_process_times(int user_tick)
 
         /* Note: this timer irq context must be accounted for as well. */
         account_process_tick(p, user_tick);
+        scheduler_tick();
         run_local_timers();
         rcu_check_callbacks(cpu, user_tick);
-        printk_tick();
         perf_event_do_pending();
-        scheduler_tick();
         run_posix_cpu_timers(p);
 }
 
@@ -1208,9 +1274,11 @@ void update_process_times(int user_tick)
  */
 static void run_timer_softirq(struct softirq_action *h)
 {
-        struct tvec_base *base = __get_cpu_var(tvec_bases);
+        struct tvec_base *base = per_cpu(tvec_bases, raw_smp_processor_id());
 
+        printk_tick();
         hrtimer_run_pending();
+        perf_event_do_pending_softirq();
 
         if (time_after_eq(jiffies, base->timer_jiffies))
                 __run_timers(base);
@@ -1550,6 +1618,7 @@ static int __cpuinit init_timers_cpu(int cpu)
         }
 
         spin_lock_init(&base->lock);
+        init_waitqueue_head(&base->wait_for_running_timer);
 
         for (j = 0; j < TVN_SIZE; j++) {
                 INIT_LIST_HEAD(base->tv5.vec + j);
@@ -1585,6 +1654,7 @@ static void __cpuinit migrate_timers(int cpu)
 {
         struct tvec_base *old_base;
         struct tvec_base *new_base;
+        unsigned long flags;
         int i;
 
         BUG_ON(cpu_online(cpu));
@@ -1594,8 +1664,11 @@ static void __cpuinit migrate_timers(int cpu)
          * The caller is globally serialized and nobody else
          * takes two locks at once, deadlock is not possible.
          */
-        spin_lock_irq(&new_base->lock);
-        spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
+        local_irq_save(flags);
+        while (!spin_trylock(&new_base->lock))
+                cpu_relax();
+        while (!spin_trylock(&old_base->lock))
+                cpu_relax();
 
         BUG_ON(old_base->running_timer);
 
@@ -1609,7 +1682,9 @@ static void __cpuinit migrate_timers(int cpu)
         }
 
         spin_unlock(&old_base->lock);
-        spin_unlock_irq(&new_base->lock);
+        spin_unlock(&new_base->lock);
+        local_irq_restore(flags);
+
         put_cpu_var(tvec_bases);
 }
 #endif /* CONFIG_HOTPLUG_CPU */