1 files changed, 286 insertions, 64 deletions

diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 0086628b6e97..51168a1e663a 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -49,6 +49,7 @@
 #include <asm/uaccess.h>
 
 #include <trace/events/timer.h>
+#include <trace/events/hist.h>
 
 /*
  * The timer bases:
@@ -88,10 +89,10 @@ static void hrtimer_get_softirq_time(struct hrtimer_cpu_base *base)
         unsigned long seq;
 
         do {
-                seq = read_seqbegin(&xtime_lock);
+                seq = read_raw_seqbegin(&xtime_lock);
                 xts = current_kernel_time();
                 tom = wall_to_monotonic;
-        } while (read_seqretry(&xtime_lock, seq));
+        } while (read_raw_seqretry(&xtime_lock, seq));
 
         xtim = timespec_to_ktime(xts);
         tomono = timespec_to_ktime(tom);
@@ -499,9 +500,9 @@ static inline int hrtimer_is_hres_enabled(void)
 /*
  * Is the high resolution mode active ?
  */
-static inline int hrtimer_hres_active(void)
+static inline int hrtimer_hres_active(struct hrtimer_cpu_base *cpu_base)
 {
-        return __get_cpu_var(hrtimer_bases).hres_active;
+        return cpu_base->hres_active;
 }
 
 /*
@@ -567,8 +568,7 @@ static int hrtimer_reprogram(struct hrtimer *timer,
          * When the callback is running, we do not reprogram the clock event
          * device. The timer callback is either running on a different CPU or
          * the callback is executed in the hrtimer_interrupt context. The
-         * reprogramming is handled either by the softirq, which called the
-         * callback or at the end of the hrtimer_interrupt.
+         * reprogramming is handled at the end of the hrtimer_interrupt.
          */
         if (hrtimer_callback_running(timer))
                 return 0;
@@ -611,21 +611,19 @@ static int hrtimer_reprogram(struct hrtimer *timer,
  */
 static void retrigger_next_event(void *arg)
 {
-        struct hrtimer_cpu_base *base;
+        struct hrtimer_cpu_base *base = &__get_cpu_var(hrtimer_bases);
         struct timespec realtime_offset;
         unsigned long seq;
 
-        if (!hrtimer_hres_active())
+        if (!hrtimer_hres_active(base))
                 return;
 
         do {
-                seq = read_seqbegin(&xtime_lock);
+                seq = read_raw_seqbegin(&xtime_lock);
                 set_normalized_timespec(&realtime_offset,
                                         -wall_to_monotonic.tv_sec,
                                         -wall_to_monotonic.tv_nsec);
-        } while (read_seqretry(&xtime_lock, seq));
-
-        base = &__get_cpu_var(hrtimer_bases);
+        } while (read_raw_seqretry(&xtime_lock, seq));
 
         /* Adjust CLOCK_REALTIME offset */
         raw_spin_lock(&base->lock);
@@ -681,6 +679,8 @@ static inline void hrtimer_init_timer_hres(struct hrtimer *timer)
 {
 }
 
+static void __run_hrtimer(struct hrtimer *timer, ktime_t *now);
+static int hrtimer_rt_defer(struct hrtimer *timer);
 
 /*
  * When High resolution timers are active, try to reprogram. Note, that in case
@@ -692,7 +692,29 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
                                             struct hrtimer_clock_base *base,
                                             int wakeup)
 {
+#ifdef CONFIG_PREEMPT_RT
+again:
+#endif
         if (base->cpu_base->hres_active && hrtimer_reprogram(timer, base)) {
+#ifdef CONFIG_PREEMPT_RT
+                /*
+                 * Move softirq based timers away from the rbtree in
+                 * case it expired already. Otherwise we would have a
+                 * stale base->first entry until the softirq runs.
+                 */
+                if (!hrtimer_rt_defer(timer)) {
+                        ktime_t now = ktime_get();
+
+                        __run_hrtimer(timer, &now);
+                        /*
+                         * __run_hrtimer might have requeued timer and
+                         * it could be base->first again.
+                         */
+                        if (base->first == &timer->node)
+                                goto again;
+                        return 1;
+                }
+#endif
                 if (wakeup) {
                         raw_spin_unlock(&base->cpu_base->lock);
                         raise_softirq_irqoff(HRTIMER_SOFTIRQ);
@@ -709,10 +731,8 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
 /*
  * Switch to high resolution mode
  */
-static int hrtimer_switch_to_hres(void)
+static int hrtimer_switch_to_hres(struct hrtimer_cpu_base *base)
 {
-        int cpu = smp_processor_id();
-        struct hrtimer_cpu_base *base = &per_cpu(hrtimer_bases, cpu);
         unsigned long flags;
 
         if (base->hres_active)
@@ -723,7 +743,7 @@ static int hrtimer_switch_to_hres(void)
         if (tick_init_highres()) {
                 local_irq_restore(flags);
                 printk(KERN_WARNING "Could not switch to high resolution "
-                                    "mode on CPU %d\n", cpu);
+                       "mode on CPU %d\n", raw_smp_processor_id());
                 return 0;
         }
         base->hres_active = 1;
@@ -740,9 +760,15 @@ static int hrtimer_switch_to_hres(void)
 
 #else
 
-static inline int hrtimer_hres_active(void) { return 0; }
+static inline int hrtimer_hres_active(struct hrtimer_cpu_base *base)
+{
+        return 0;
+}
 static inline int hrtimer_is_hres_enabled(void) { return 0; }
-static inline int hrtimer_switch_to_hres(void) { return 0; }
+static inline int hrtimer_switch_to_hres(struct hrtimer_cpu_base *base)
+{
+        return 0;
+}
 static inline void
 hrtimer_force_reprogram(struct hrtimer_cpu_base *base, int skip_equal) { }
 static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
@@ -751,6 +777,13 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
 {
         return 0;
 }
+
+static inline int hrtimer_reprogram(struct hrtimer *timer,
+                                    struct hrtimer_clock_base *base)
+{
+        return 0;
+}
+
 static inline void hrtimer_init_hres(struct hrtimer_cpu_base *base) { }
 static inline void hrtimer_init_timer_hres(struct hrtimer *timer) { }
 
@@ -889,6 +922,32 @@ static int enqueue_hrtimer(struct hrtimer *timer,
         return leftmost;
 }
 
+#ifdef CONFIG_PREEMPT_SOFTIRQS
+# define wake_up_timer_waiters(b)       wake_up(&(b)->wait)
+
+/**
+ * hrtimer_wait_for_timer - Wait for a running timer
+ *
+ * @timer:      timer to wait for
+ *
+ * The function waits in case the timers callback function is
+ * currently executed on the waitqueue of the timer base. The
+ * waitqueue is woken up after the timer callback function has
+ * finished execution.
+ */
+void hrtimer_wait_for_timer(const struct hrtimer *timer)
+{
+        struct hrtimer_clock_base *base = timer->base;
+
+        if (base && base->cpu_base && !timer->irqsafe)
+                wait_event(base->cpu_base->wait,
+                           !(timer->state & HRTIMER_STATE_CALLBACK));
+}
+
+#else
+# define wake_up_timer_waiters(b)       do { } while (0)
+#endif
+
 /*
  * __remove_hrtimer - internal function to remove a timer
  *
@@ -906,6 +965,11 @@ static void __remove_hrtimer(struct hrtimer *timer,
         if (!(timer->state & HRTIMER_STATE_ENQUEUED))
                 goto out;
 
+        if (unlikely(!list_empty(&timer->cb_entry))) {
+                list_del_init(&timer->cb_entry);
+                goto out;
+        }
+
         /*
          * Remove the timer from the rbtree and replace the first
          * entry pointer if necessary.
@@ -914,7 +978,7 @@ static void __remove_hrtimer(struct hrtimer *timer,
                 base->first = rb_next(&timer->node);
 #ifdef CONFIG_HIGH_RES_TIMERS
                 /* Reprogram the clock event device. if enabled */
-                if (reprogram && hrtimer_hres_active()) {
+                if (reprogram && hrtimer_hres_active(base->cpu_base)) {
                         ktime_t expires;
 
                         expires = ktime_sub(hrtimer_get_expires(timer),
@@ -1085,7 +1149,7 @@ int hrtimer_cancel(struct hrtimer *timer)
 
                 if (ret >= 0)
                         return ret;
-                cpu_relax();
+                hrtimer_wait_for_timer(timer);
         }
 }
 EXPORT_SYMBOL_GPL(hrtimer_cancel);
@@ -1125,7 +1189,7 @@ ktime_t hrtimer_get_next_event(void)
 
         raw_spin_lock_irqsave(&cpu_base->lock, flags);
 
-        if (!hrtimer_hres_active()) {
+        if (!hrtimer_hres_active(cpu_base)) {
                 for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++, base++) {
                         struct hrtimer *timer;
 
@@ -1161,6 +1225,7 @@ static void __hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
                 clock_id = CLOCK_MONOTONIC;
 
         timer->base = &cpu_base->clock_base[clock_id];
+        INIT_LIST_HEAD(&timer->cb_entry);
         hrtimer_init_timer_hres(timer);
 
 #ifdef CONFIG_TIMER_STATS
@@ -1240,8 +1305,120 @@ static void __run_hrtimer(struct hrtimer *timer, ktime_t *now)
         timer->state &= ~HRTIMER_STATE_CALLBACK;
 }
 
+#ifdef CONFIG_PREEMPT_RT
+
+static void hrtimer_rt_reprogram(int restart, struct hrtimer *timer,
+                                 struct hrtimer_clock_base *base)
+{
+        /*
+         * Note, we clear the callback flag before we requeue the
+         * timer otherwise we trigger the callback_running() check
+         * in hrtimer_reprogram().
+         */
+        timer->state &= ~HRTIMER_STATE_CALLBACK;
+
+        if (restart != HRTIMER_NORESTART) {
+                BUG_ON(hrtimer_active(timer));
+                /*
+                 * Enqueue the timer, if it's the leftmost timer then
+                 * we need to reprogram it.
+                 */
+                if (!enqueue_hrtimer(timer, base))
+                        return;
+
+                if (hrtimer_reprogram(timer, base))
+                        goto requeue;
+
+        } else if (hrtimer_active(timer)) {
+                /*
+                 * If the timer was rearmed on another CPU, reprogram
+                 * the event device.
+                 */
+                if (base->first == &timer->node &&
+                    hrtimer_reprogram(timer, base))
+                        goto requeue;
+        }
+        return;
+
+requeue:
+        /*
+         * Timer is expired. Thus move it from tree to pending list
+         * again.
+         */
+        __remove_hrtimer(timer, base, timer->state, 0);
+        list_add_tail(&timer->cb_entry, &base->expired);
+}
+
+/*
+ * The changes in mainline which removed the callback modes from
+ * hrtimer are not yet working with -rt. The non wakeup_process()
+ * based callbacks which involve sleeping locks need to be treated
+ * seperately.
+ */
+static void hrtimer_rt_run_pending(void)
+{
+        enum hrtimer_restart (*fn)(struct hrtimer *);
+        struct hrtimer_cpu_base *cpu_base;
+        struct hrtimer_clock_base *base;
+        struct hrtimer *timer;
+        int index, restart;
+
+        local_irq_disable();
+        cpu_base = &per_cpu(hrtimer_bases, smp_processor_id());
+
+        raw_spin_lock(&cpu_base->lock);
+
+        for (index = 0; index < HRTIMER_MAX_CLOCK_BASES; index++) {
+                base = &cpu_base->clock_base[index];
+
+                while (!list_empty(&base->expired)) {
+                        timer = list_first_entry(&base->expired,
+                                                 struct hrtimer, cb_entry);
+
+                        /*
+                         * Same as the above __run_hrtimer function
+                         * just we run with interrupts enabled.
+                         */
+                        debug_hrtimer_deactivate(timer);
+                        __remove_hrtimer(timer, base, HRTIMER_STATE_CALLBACK, 0);
+                        timer_stats_account_hrtimer(timer);
+                        fn = timer->function;
+
+                        raw_spin_unlock_irq(&cpu_base->lock);
+                        restart = fn(timer);
+                        raw_spin_lock_irq(&cpu_base->lock);
+
+                        hrtimer_rt_reprogram(restart, timer, base);
+                }
+        }
+
+        raw_spin_unlock_irq(&cpu_base->lock);
+
+        wake_up_timer_waiters(cpu_base);
+}
+
+static int hrtimer_rt_defer(struct hrtimer *timer)
+{
+        if (timer->irqsafe)
+                return 0;
+
+        __remove_hrtimer(timer, timer->base, timer->state, 0);
+        list_add_tail(&timer->cb_entry, &timer->base->expired);
+        return 1;
+}
+
+#else
+
+static inline void hrtimer_rt_run_pending(void) { }
+static inline int hrtimer_rt_defer(struct hrtimer *timer) { return 0; }
+
+#endif
+
+
 #ifdef CONFIG_HIGH_RES_TIMERS
 
+static enum hrtimer_restart hrtimer_wakeup(struct hrtimer *timer);
+
 /*
  * High resolution timer interrupt
  * Called with interrupts disabled
@@ -1251,7 +1428,7 @@ void hrtimer_interrupt(struct clock_event_device *dev)
         struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
         struct hrtimer_clock_base *base;
         ktime_t expires_next, now, entry_time, delta;
-        int i, retries = 0;
+        int i, retries = 0, raise = 0;
 
         BUG_ON(!cpu_base->hres_active);
         cpu_base->nr_events++;
@@ -1284,6 +1461,14 @@ retry:
 
                         timer = rb_entry(node, struct hrtimer, node);
 
+                        trace_hrtimer_interrupt(raw_smp_processor_id(),
+                            ktime_to_ns(ktime_sub(
+                                hrtimer_get_expires(timer), basenow)),
+                            current,
+                            timer->function == hrtimer_wakeup ?
+                            container_of(timer, struct hrtimer_sleeper,
+                                timer)->task : NULL);
+
                         /*
                          * The immediate goal for using the softexpires is
                          * minimizing wakeups, not running timers at the
@@ -1307,7 +1492,10 @@ retry:
                                 break;
                         }
 
-                        __run_hrtimer(timer, &basenow);
+                        if (!hrtimer_rt_defer(timer))
+                                __run_hrtimer(timer, &basenow);
+                        else
+                                raise = 1;
                 }
                 base++;
         }
@@ -1323,6 +1511,10 @@ retry:
         if (expires_next.tv64 == KTIME_MAX ||
             !tick_program_event(expires_next, 0)) {
                 cpu_base->hang_detected = 0;
+
+                if (raise)
+                        raise_softirq_irqoff(HRTIMER_SOFTIRQ);
+
                 return;
         }
 
@@ -1370,9 +1562,11 @@ retry:
  */
 static void __hrtimer_peek_ahead_timers(void)
 {
+        struct hrtimer_cpu_base *cpu_base;
         struct tick_device *td;
 
-        if (!hrtimer_hres_active())
+        cpu_base = &__get_cpu_var(hrtimer_bases);
+        if (!hrtimer_hres_active(cpu_base))
                 return;
 
         td = &__get_cpu_var(tick_cpu_device);
@@ -1398,17 +1592,17 @@ void hrtimer_peek_ahead_timers(void)
         local_irq_restore(flags);
 }
 
-static void run_hrtimer_softirq(struct softirq_action *h)
-{
-        hrtimer_peek_ahead_timers();
-}
-
 #else /* CONFIG_HIGH_RES_TIMERS */
 
 static inline void __hrtimer_peek_ahead_timers(void) { }
 
 #endif  /* !CONFIG_HIGH_RES_TIMERS */
 
+static void run_hrtimer_softirq(struct softirq_action *h)
+{
+        hrtimer_rt_run_pending();
+}
+
 /*
  * Called from timer softirq every jiffy, expire hrtimers:
  *
@@ -1418,7 +1612,9 @@ static inline void __hrtimer_peek_ahead_timers(void) { }
  */
 void hrtimer_run_pending(void)
 {
-        if (hrtimer_hres_active())
+        struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
+
+        if (hrtimer_hres_active(cpu_base))
                 return;
 
         /*
@@ -1430,7 +1626,7 @@ void hrtimer_run_pending(void)
          * deadlock vs. xtime_lock.
          */
         if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))
-                hrtimer_switch_to_hres();
+                hrtimer_switch_to_hres(cpu_base);
 }
 
 /*
@@ -1439,11 +1635,12 @@ void hrtimer_run_pending(void)
 void hrtimer_run_queues(void)
 {
         struct rb_node *node;
-        struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
+        struct hrtimer_cpu_base *cpu_base;
         struct hrtimer_clock_base *base;
-        int index, gettime = 1;
+        int index, gettime = 1, raise = 0;
 
-        if (hrtimer_hres_active())
+        cpu_base = &per_cpu(hrtimer_bases, raw_smp_processor_id());
+        if (hrtimer_hres_active(cpu_base))
                 return;
 
         for (index = 0; index < HRTIMER_MAX_CLOCK_BASES; index++) {
@@ -1467,10 +1664,16 @@ void hrtimer_run_queues(void)
                                         hrtimer_get_expires_tv64(timer))
                                 break;
 
-                        __run_hrtimer(timer, &base->softirq_time);
+                        if (!hrtimer_rt_defer(timer))
+                                __run_hrtimer(timer, &base->softirq_time);
+                        else
+                                raise = 1;
                 }
                 raw_spin_unlock(&cpu_base->lock);
         }
+
+        if (raise)
+                raise_softirq_irqoff(HRTIMER_SOFTIRQ);
 }
 
 /*
@@ -1492,6 +1695,7 @@ static enum hrtimer_restart hrtimer_wakeup(struct hrtimer *timer)
 void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task)
 {
         sl->timer.function = hrtimer_wakeup;
+        sl->timer.irqsafe = 1;
         sl->task = task;
 }
 EXPORT_SYMBOL_GPL(hrtimer_init_sleeper);
@@ -1627,10 +1831,15 @@ static void __cpuinit init_hrtimers_cpu(int cpu)
 
         raw_spin_lock_init(&cpu_base->lock);
 
-        for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++)
+        for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
                 cpu_base->clock_base[i].cpu_base = cpu_base;
+                INIT_LIST_HEAD(&cpu_base->clock_base[i].expired);
+        }
 
         hrtimer_init_hres(cpu_base);
+#ifdef CONFIG_PREEMPT_RT
+        init_waitqueue_head(&cpu_base->wait);
+#endif
 }
 
 #ifdef CONFIG_HOTPLUG_CPU
@@ -1743,41 +1952,19 @@ void __init hrtimers_init(void)
         hrtimer_cpu_notify(&hrtimers_nb, (unsigned long)CPU_UP_PREPARE,
                           (void *)(long)smp_processor_id());
         register_cpu_notifier(&hrtimers_nb);
-#ifdef CONFIG_HIGH_RES_TIMERS
         open_softirq(HRTIMER_SOFTIRQ, run_hrtimer_softirq);
-#endif
 }
 
 /**
- * schedule_hrtimeout_range - sleep until timeout
+ * schedule_hrtimeout_range_clock - sleep until timeout
  * @expires:    timeout value (ktime_t)
  * @delta:      slack in expires timeout (ktime_t)
  * @mode:       timer mode, HRTIMER_MODE_ABS or HRTIMER_MODE_REL
- *
- * Make the current task sleep until the given expiry time has
- * elapsed. The routine will return immediately unless
- * the current task state has been set (see set_current_state()).
- *
- * The @delta argument gives the kernel the freedom to schedule the
- * actual wakeup to a time that is both power and performance friendly.
- * The kernel give the normal best effort behavior for "@expires+@delta",
- * but may decide to fire the timer earlier, but no earlier than @expires.
- *
- * You can set the task state as follows -
- *
- * %TASK_UNINTERRUPTIBLE - at least @timeout time is guaranteed to
- * pass before the routine returns.
- *
- * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
- * delivered to the current task.
- *
- * The current task state is guaranteed to be TASK_RUNNING when this
- * routine returns.
- *
- * Returns 0 when the timer has expired otherwise -EINTR
+ * @clock:      timer clock, CLOCK_MONOTONIC or CLOCK_REALTIME
  */
-int __sched schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
-                               const enum hrtimer_mode mode)
+int __sched
+schedule_hrtimeout_range_clock(ktime_t *expires, unsigned long delta,
+                               const enum hrtimer_mode mode, int clock)
 {
         struct hrtimer_sleeper t;
 
@@ -1799,7 +1986,7 @@ int __sched schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
                 return -EINTR;
         }
 
-        hrtimer_init_on_stack(&t.timer, CLOCK_MONOTONIC, mode);
+        hrtimer_init_on_stack(&t.timer, clock, mode);
         hrtimer_set_expires_range_ns(&t.timer, *expires, delta);
 
         hrtimer_init_sleeper(&t, current);
@@ -1818,6 +2005,41 @@ int __sched schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
 
         return !t.task ? 0 : -EINTR;
 }
+
+/**
+ * schedule_hrtimeout_range - sleep until timeout
+ * @expires:    timeout value (ktime_t)
+ * @delta:      slack in expires timeout (ktime_t)
+ * @mode:       timer mode, HRTIMER_MODE_ABS or HRTIMER_MODE_REL
+ *
+ * Make the current task sleep until the given expiry time has
+ * elapsed. The routine will return immediately unless
+ * the current task state has been set (see set_current_state()).
+ *
+ * The @delta argument gives the kernel the freedom to schedule the
+ * actual wakeup to a time that is both power and performance friendly.
+ * The kernel give the normal best effort behavior for "@expires+@delta",
+ * but may decide to fire the timer earlier, but no earlier than @expires.
+ *
+ * You can set the task state as follows -
+ *
+ * %TASK_UNINTERRUPTIBLE - at least @timeout time is guaranteed to
+ * pass before the routine returns.
+ *
+ * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
+ * delivered to the current task.
+ *
+ * The current task state is guaranteed to be TASK_RUNNING when this
+ * routine returns.
+ *
+ * Returns 0 when the timer has expired otherwise -EINTR
+ */
+int __sched schedule_hrtimeout_range(ktime_t *expires, unsigned long delta,
+                                     const enum hrtimer_mode mode)
+{
+        return schedule_hrtimeout_range_clock(expires, delta, mode,
+                                              CLOCK_MONOTONIC);
+}
 EXPORT_SYMBOL_GPL(schedule_hrtimeout_range);
 
 /**