[PATCH] Fix next_timer_interrupt() for hrtimer

This patch adds support for hrtimer to next_timer_interrupt()
and fixes current breakage.

Function next_timer_interrupt() got broken with a recent patch
6ba1b91213e81aa92b5cf7539f7d2a94ff54947c as sys_nanosleep() was
moved to hrtimer. This broke things as next_timer_interrupt()
did not check hrtimer tree for next event.

Function next_timer_interrupt() is needed with dyntick
(CONFIG_NO_IDLE_HZ, VST) implementations, as the system can
be in idle when next hrtimer event was supposed to happen.
At least ARM and S390 currently use next_timer_interrupt().

Signed-off-by: Tony Lindgren <tony@atomide.com>

diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 6361544bb6ae5fef3ee1dcd84dc8788262bd7917..5a6ffd16c9b775f136ee242aa41c84b655281833 100644 (file)
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -115,6 +115,7 @@ extern int hrtimer_try_to_cancel(struct hrtimer *timer);
 /* Query timers: */
 extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
 extern int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp);
+extern int hrtimer_next_jiffie(unsigned long *next_jiffie);
 
 static inline int hrtimer_active(const struct hrtimer *timer)
 {

diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 5ae51f1bc7c80347d091bd4da0df2e8840c0bae4..5ad49ddb483969fe88fd7a8204861f47efe43d1a 100644 (file)
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -505,6 +505,79 @@ ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
        return rem;
 }
 
+#ifdef CONFIG_NO_IDLE_HZ
+
+/**
+ * hrtimer_get_next - get next hrtimer to expire
+ *
+ * @bases:     ktimer base array
+ */
+static inline struct hrtimer * hrtimer_get_next(struct hrtimer_base *bases)
+{
+       unsigned long flags;
+       struct hrtimer *timer = NULL;
+       int i;
+
+       for (i = 0; i < MAX_HRTIMER_BASES; i++) {
+               struct hrtimer_base *base;
+               struct hrtimer *cur;
+
+               base = &bases[i];
+               spin_lock_irqsave(&base->lock, flags);
+               cur = rb_entry(base->first, struct hrtimer, node);
+               spin_unlock_irqrestore(&base->lock, flags);
+
+               if (cur == NULL)
+                       continue;
+
+               if (timer == NULL || cur->expires.tv64 < timer->expires.tv64)
+                       timer = cur;
+       }
+
+       return timer;
+}
+
+/**
+ * ktime_to_jiffies - converts ktime to jiffies
+ *
+ * @event:     ktime event to be converted to jiffies
+ *
+ * Caller must take care xtime locking.
+ */
+static inline unsigned long ktime_to_jiffies(const ktime_t event)
+{
+       ktime_t now, delta;
+
+       now = timespec_to_ktime(xtime);
+       delta = ktime_sub(event, now);
+
+       return jiffies + (((delta.tv64 * NSEC_CONVERSION) >>
+                       (NSEC_JIFFIE_SC - SEC_JIFFIE_SC)) >> SEC_JIFFIE_SC);
+}
+
+/**
+ * hrtimer_next_jiffie - get next hrtimer event in jiffies
+ *
+ * Called from next_timer_interrupt() to get the next hrtimer event.
+ * Eventually we should change next_timer_interrupt() to return
+ * results in nanoseconds instead of jiffies. Caller must host xtime_lock.
+ */
+int hrtimer_next_jiffie(unsigned long *next_jiffie)
+{
+       struct hrtimer_base *base = __get_cpu_var(hrtimer_bases);
+       struct hrtimer * timer;
+
+       timer = hrtimer_get_next(base);
+       if (timer == NULL)
+               return -EAGAIN;
+
+       *next_jiffie = ktime_to_jiffies(timer->expires);
+
+       return 0;
+}
+
+#endif
+
 /**
  * hrtimer_init - initialize a timer to the given clock
  *

diff --git a/kernel/timer.c b/kernel/timer.c
index fe3a9a9f832849bddbb3bf1be92268af99287aa9..5e93a4e6fbe3eb10c54183493d03511cdbfc9d0d 100644 (file)
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -478,6 +478,7 @@ static inline void __run_timers(tvec_base_t *base)
 }
 
 #ifdef CONFIG_NO_IDLE_HZ
+
 /*
  * Find out when the next timer event is due to happen. This
  * is used on S/390 to stop all activity when a cpus is idle.
@@ -489,9 +490,15 @@ unsigned long next_timer_interrupt(void)
        struct list_head *list;
        struct timer_list *nte;
        unsigned long expires;
+       unsigned long hr_expires = jiffies + 10 * HZ;   /* Anything far ahead */
        tvec_t *varray[4];
        int i, j;
 
+       /* Look for timer events in hrtimer. */
+       if ((hrtimer_next_jiffie(&hr_expires) == 0)
+               && (time_before(hr_expires, jiffies + 2)))
+                       return hr_expires;
+
        base = &__get_cpu_var(tvec_bases);
        spin_lock(&base->t_base.lock);
        expires = base->timer_jiffies + (LONG_MAX >> 1);
@@ -542,6 +549,10 @@ found:
                }
        }
        spin_unlock(&base->t_base.lock);
+
+       if (time_before(hr_expires, expires))
+               expires = hr_expires;
+
        return expires;
 }
 #endif