Merge branch 'wip-2.6.34' into old-private-masterarchived-private-master

1 files changed, 106 insertions, 72 deletions

diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 7b19403900ad..02e5097bf319 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -129,11 +129,11 @@ struct hrtimer_clock_base *lock_hrtimer_base(const struct hrtimer *timer,
         for (;;) {
                 base = timer->base;
                 if (likely(base != NULL)) {
-                        spin_lock_irqsave(&base->cpu_base->lock, *flags);
+                        raw_spin_lock_irqsave(&base->cpu_base->lock, *flags);
                         if (likely(base == timer->base))
                                 return base;
                         /* The timer has migrated to another CPU: */
-                        spin_unlock_irqrestore(&base->cpu_base->lock, *flags);
+                        raw_spin_unlock_irqrestore(&base->cpu_base->lock, *flags);
                 }
                 cpu_relax();
         }
@@ -210,13 +210,13 @@ again:
 
                 /* See the comment in lock_timer_base() */
                 timer->base = NULL;
-                spin_unlock(&base->cpu_base->lock);
-                spin_lock(&new_base->cpu_base->lock);
+                raw_spin_unlock(&base->cpu_base->lock);
+                raw_spin_lock(&new_base->cpu_base->lock);
 
                 if (cpu != this_cpu && hrtimer_check_target(timer, new_base)) {
                         cpu = this_cpu;
-                        spin_unlock(&new_base->cpu_base->lock);
-                        spin_lock(&base->cpu_base->lock);
+                        raw_spin_unlock(&new_base->cpu_base->lock);
+                        raw_spin_lock(&base->cpu_base->lock);
                         timer->base = base;
                         goto again;
                 }
@@ -232,7 +232,7 @@ lock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
 {
         struct hrtimer_clock_base *base = timer->base;
 
-        spin_lock_irqsave(&base->cpu_base->lock, *flags);
+        raw_spin_lock_irqsave(&base->cpu_base->lock, *flags);
 
         return base;
 }
@@ -559,7 +559,7 @@ hrtimer_force_reprogram(struct hrtimer_cpu_base *cpu_base, int skip_equal)
 static int hrtimer_reprogram(struct hrtimer *timer,
                              struct hrtimer_clock_base *base)
 {
-        ktime_t *expires_next = &__get_cpu_var(hrtimer_bases).expires_next;
+        struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);
         ktime_t expires = ktime_sub(hrtimer_get_expires(timer), base->offset);
         int res;
 
@@ -584,7 +584,16 @@ static int hrtimer_reprogram(struct hrtimer *timer,
         if (expires.tv64 < 0)
                 return -ETIME;
 
-        if (expires.tv64 >= expires_next->tv64)
+        if (expires.tv64 >= cpu_base->expires_next.tv64)
+                return 0;
+
+        /*
+         * If a hang was detected in the last timer interrupt then we
+         * do not schedule a timer which is earlier than the expiry
+         * which we enforced in the hang detection. We want the system
+         * to make progress.
+         */
+        if (cpu_base->hang_detected)
                 return 0;
 
         /*
@@ -592,7 +601,7 @@ static int hrtimer_reprogram(struct hrtimer *timer,
          */
         res = tick_program_event(expires, 0);
         if (!IS_ERR_VALUE(res))
-                *expires_next = expires;
+                cpu_base->expires_next = expires;
         return res;
 }
 
@@ -621,12 +630,12 @@ static void retrigger_next_event(void *arg)
         base = &__get_cpu_var(hrtimer_bases);
 
         /* Adjust CLOCK_REALTIME offset */
-        spin_lock(&base->lock);
+        raw_spin_lock(&base->lock);
         base->clock_base[CLOCK_REALTIME].offset =
                 timespec_to_ktime(realtime_offset);
 
         hrtimer_force_reprogram(base, 0);
-        spin_unlock(&base->lock);
+        raw_spin_unlock(&base->lock);
 }
 
 /*
@@ -687,9 +696,9 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
 {
         if (base->cpu_base->hres_active && hrtimer_reprogram(timer, base)) {
                 if (wakeup) {
-                        spin_unlock(&base->cpu_base->lock);
+                        raw_spin_unlock(&base->cpu_base->lock);
                         raise_softirq_irqoff(HRTIMER_SOFTIRQ);
-                        spin_lock(&base->cpu_base->lock);
+                        raw_spin_lock(&base->cpu_base->lock);
                 } else
                         __raise_softirq_irqoff(HRTIMER_SOFTIRQ);
 
@@ -749,17 +758,33 @@ static inline void hrtimer_init_timer_hres(struct hrtimer *timer) { }
 
 #endif /* CONFIG_HIGH_RES_TIMERS */
 
-#ifdef CONFIG_TIMER_STATS
-void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer, void *addr)
+static inline void timer_stats_hrtimer_set_start_info(struct hrtimer *timer)
 {
+#ifdef CONFIG_TIMER_STATS
         if (timer->start_site)
                 return;
-
-        timer->start_site = addr;
+        timer->start_site = __builtin_return_address(0);
         memcpy(timer->start_comm, current->comm, TASK_COMM_LEN);
         timer->start_pid = current->pid;
+#endif
 }
+
+static inline void timer_stats_hrtimer_clear_start_info(struct hrtimer *timer)
+{
+#ifdef CONFIG_TIMER_STATS
+        timer->start_site = NULL;
+#endif
+}
+
+static inline void timer_stats_account_hrtimer(struct hrtimer *timer)
+{
+#ifdef CONFIG_TIMER_STATS
+        if (likely(!timer_stats_active))
+                return;
+        timer_stats_update_stats(timer, timer->start_pid, timer->start_site,
+                                 timer->function, timer->start_comm, 0);
 #endif
+}
 
 /*
  * Counterpart to lock_hrtimer_base above:
@@ -767,7 +792,7 @@ void __timer_stats_hrtimer_set_start_info(struct hrtimer *timer, void *addr)
 static inline
 void unlock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
 {
-        spin_unlock_irqrestore(&timer->base->cpu_base->lock, *flags);
+        raw_spin_unlock_irqrestore(&timer->base->cpu_base->lock, *flags);
 }
 
 /**
@@ -1027,9 +1052,9 @@ void hrtimer_pull(void)
         struct hrtimer_start_on_info *info;
         struct list_head *pos, *safe, list;
 
-        spin_lock(&base->lock);
+        raw_spin_lock(&base->lock);
         list_replace_init(&base->to_pull, &list);
-        spin_unlock(&base->lock);
+        raw_spin_unlock(&base->lock);
 
         list_for_each_safe(pos, safe, &list) {
                 info = list_entry(pos, struct hrtimer_start_on_info, list);
@@ -1083,10 +1108,10 @@ int hrtimer_start_on(int cpu, struct hrtimer_start_on_info* info,
                 } else {
                         TRACE("hrtimer_start_on: pulling to remote CPU\n");
                         base = &per_cpu(hrtimer_bases, cpu);
-                        spin_lock_irqsave(&base->lock, flags);
+                        raw_spin_lock_irqsave(&base->lock, flags);
                         was_empty = list_empty(&base->to_pull);
                         list_add(&info->list, &base->to_pull);
-                        spin_unlock_irqrestore(&base->lock, flags);
+                        raw_spin_unlock_irqrestore(&base->lock, flags);
                         if (was_empty)
                                 /* only send IPI if other no else
                                  * has done so already
@@ -1179,7 +1204,7 @@ ktime_t hrtimer_get_next_event(void)
         unsigned long flags;
         int i;
 
-        spin_lock_irqsave(&cpu_base->lock, flags);
+        raw_spin_lock_irqsave(&cpu_base->lock, flags);
 
         if (!hrtimer_hres_active()) {
                 for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++, base++) {
@@ -1196,7 +1221,7 @@ ktime_t hrtimer_get_next_event(void)
                 }
         }
 
-        spin_unlock_irqrestore(&cpu_base->lock, flags);
+        raw_spin_unlock_irqrestore(&cpu_base->lock, flags);
 
         if (mindelta.tv64 < 0)
                 mindelta.tv64 = 0;
@@ -1278,11 +1303,11 @@ static void __run_hrtimer(struct hrtimer *timer, ktime_t *now)
          * they get migrated to another cpu, therefore its safe to unlock
          * the timer base.
          */
-        spin_unlock(&cpu_base->lock);
+        raw_spin_unlock(&cpu_base->lock);
         trace_hrtimer_expire_entry(timer, now);
         restart = fn(timer);
         trace_hrtimer_expire_exit(timer);
-        spin_lock(&cpu_base->lock);
+        raw_spin_lock(&cpu_base->lock);
 
         /*
          * Note: We clear the CALLBACK bit after enqueue_hrtimer and
@@ -1298,29 +1323,6 @@ static void __run_hrtimer(struct hrtimer *timer, ktime_t *now)
 
 #ifdef CONFIG_HIGH_RES_TIMERS
 
-static int force_clock_reprogram;
-
-/*
- * After 5 iteration's attempts, we consider that hrtimer_interrupt()
- * is hanging, which could happen with something that slows the interrupt
- * such as the tracing. Then we force the clock reprogramming for each future
- * hrtimer interrupts to avoid infinite loops and use the min_delta_ns
- * threshold that we will overwrite.
- * The next tick event will be scheduled to 3 times we currently spend on
- * hrtimer_interrupt(). This gives a good compromise, the cpus will spend
- * 1/4 of their time to process the hrtimer interrupts. This is enough to
- * let it running without serious starvation.
- */
-
-static inline void
-hrtimer_interrupt_hanging(struct clock_event_device *dev,
-                        ktime_t try_time)
-{
-        force_clock_reprogram = 1;
-        dev->min_delta_ns = (unsigned long)try_time.tv64 * 3;
-        printk(KERN_WARNING "hrtimer: interrupt too slow, "
-                "forcing clock min delta to %lu ns\n", dev->min_delta_ns);
-}
 /*
  * High resolution timer interrupt
  * Called with interrupts disabled
@@ -1329,24 +1331,18 @@ 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;
-        int nr_retries = 0;
-        int i;
+        ktime_t expires_next, now, entry_time, delta;
+        int i, retries = 0;
 
         BUG_ON(!cpu_base->hres_active);
         cpu_base->nr_events++;
         dev->next_event.tv64 = KTIME_MAX;
 
- retry:
-        /* 5 retries is enough to notice a hang */
-        if (!(++nr_retries % 5))
-                hrtimer_interrupt_hanging(dev, ktime_sub(ktime_get(), now));
-
-        now = ktime_get();
-
+        entry_time = now = ktime_get();
+retry:
         expires_next.tv64 = KTIME_MAX;
 
-        spin_lock(&cpu_base->lock);
+        raw_spin_lock(&cpu_base->lock);
         /*
          * We set expires_next to KTIME_MAX here with cpu_base->lock
          * held to prevent that a timer is enqueued in our queue via
@@ -1402,13 +1398,51 @@ void hrtimer_interrupt(struct clock_event_device *dev)
          * against it.
          */
         cpu_base->expires_next = expires_next;
-        spin_unlock(&cpu_base->lock);
+        raw_spin_unlock(&cpu_base->lock);
 
         /* Reprogramming necessary ? */
-        if (expires_next.tv64 != KTIME_MAX) {
-                if (tick_program_event(expires_next, force_clock_reprogram))
-                        goto retry;
+        if (expires_next.tv64 == KTIME_MAX ||
+            !tick_program_event(expires_next, 0)) {
+                cpu_base->hang_detected = 0;
+                return;
         }
+
+        /*
+         * The next timer was already expired due to:
+         * - tracing
+         * - long lasting callbacks
+         * - being scheduled away when running in a VM
+         *
+         * We need to prevent that we loop forever in the hrtimer
+         * interrupt routine. We give it 3 attempts to avoid
+         * overreacting on some spurious event.
+         */
+        now = ktime_get();
+        cpu_base->nr_retries++;
+        if (++retries < 3)
+                goto retry;
+        /*
+         * Give the system a chance to do something else than looping
+         * here. We stored the entry time, so we know exactly how long
+         * we spent here. We schedule the next event this amount of
+         * time away.
+         */
+        cpu_base->nr_hangs++;
+        cpu_base->hang_detected = 1;
+        delta = ktime_sub(now, entry_time);
+        if (delta.tv64 > cpu_base->max_hang_time.tv64)
+                cpu_base->max_hang_time = delta;
+        /*
+         * Limit it to a sensible value as we enforce a longer
+         * delay. Give the CPU at least 100ms to catch up.
+         */
+        if (delta.tv64 > 100 * NSEC_PER_MSEC)
+                expires_next = ktime_add_ns(now, 100 * NSEC_PER_MSEC);
+        else
+                expires_next = ktime_add(now, delta);
+        tick_program_event(expires_next, 1);
+        printk_once(KERN_WARNING "hrtimer: interrupt took %llu ns\n",
+                    ktime_to_ns(delta));
 }
 
 /*
@@ -1504,7 +1538,7 @@ void hrtimer_run_queues(void)
                         gettime = 0;
                 }
 
-                spin_lock(&cpu_base->lock);
+                raw_spin_lock(&cpu_base->lock);
 
                 while ((node = base->first)) {
                         struct hrtimer *timer;
@@ -1516,7 +1550,7 @@ void hrtimer_run_queues(void)
 
                         __run_hrtimer(timer, &base->softirq_time);
                 }
-                spin_unlock(&cpu_base->lock);
+                raw_spin_unlock(&cpu_base->lock);
         }
 }
 
@@ -1672,7 +1706,7 @@ static void __cpuinit init_hrtimers_cpu(int cpu)
         struct hrtimer_cpu_base *cpu_base = &per_cpu(hrtimer_bases, cpu);
         int i;
 
-        spin_lock_init(&cpu_base->lock);
+        raw_spin_lock_init(&cpu_base->lock);
 
         for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++)
                 cpu_base->clock_base[i].cpu_base = cpu_base;
@@ -1731,16 +1765,16 @@ static void migrate_hrtimers(int scpu)
          * The caller is globally serialized and nobody else
          * takes two locks at once, deadlock is not possible.
          */
-        spin_lock(&new_base->lock);
-        spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
+        raw_spin_lock(&new_base->lock);
+        raw_spin_lock_nested(&old_base->lock, SINGLE_DEPTH_NESTING);
 
         for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {
                 migrate_hrtimer_list(&old_base->clock_base[i],
                                      &new_base->clock_base[i]);
         }
 
-        spin_unlock(&old_base->lock);
-        spin_unlock(&new_base->lock);
+        raw_spin_unlock(&old_base->lock);
+        raw_spin_unlock(&new_base->lock);
 
         /* Check, if we got expired work to do */
         __hrtimer_peek_ahead_timers();