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

1 files changed, 58 insertions, 26 deletions

diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index bde4c667d24d..704e488730a5 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -46,9 +46,9 @@ void synchronize_irq(unsigned int irq)
                         cpu_relax();
 
                 /* Ok, that indicated we're done: double-check carefully. */
-                spin_lock_irqsave(&desc->lock, flags);
+                raw_spin_lock_irqsave(&desc->lock, flags);
                 status = desc->status;
-                spin_unlock_irqrestore(&desc->lock, flags);
+                raw_spin_unlock_irqrestore(&desc->lock, flags);
 
                 /* Oops, that failed? */
         } while (status & IRQ_INPROGRESS);
@@ -114,7 +114,7 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
         if (!desc->chip->set_affinity)
                 return -EINVAL;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
 
 #ifdef CONFIG_GENERIC_PENDING_IRQ
         if (desc->status & IRQ_MOVE_PCNTXT) {
@@ -134,7 +134,7 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
         }
 #endif
         desc->status |= IRQ_AFFINITY_SET;
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         return 0;
 }
 
@@ -181,11 +181,11 @@ int irq_select_affinity_usr(unsigned int irq)
         unsigned long flags;
         int ret;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         ret = setup_affinity(irq, desc);
         if (!ret)
                 irq_set_thread_affinity(desc);
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         return ret;
 }
@@ -231,9 +231,9 @@ void disable_irq_nosync(unsigned int irq)
                 return;
 
         chip_bus_lock(irq, desc);
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         __disable_irq(desc, irq, false);
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(disable_irq_nosync);
@@ -308,9 +308,9 @@ void enable_irq(unsigned int irq)
                 return;
 
         chip_bus_lock(irq, desc);
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         __enable_irq(desc, irq, false);
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(enable_irq);
@@ -347,7 +347,7 @@ int set_irq_wake(unsigned int irq, unsigned int on)
         /* wakeup-capable irqs can be shared between drivers that
          * don't need to have the same sleep mode behaviors.
          */
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         if (on) {
                 if (desc->wake_depth++ == 0) {
                         ret = set_irq_wake_real(irq, on);
@@ -368,7 +368,7 @@ int set_irq_wake(unsigned int irq, unsigned int on)
                 }
         }
 
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         return ret;
 }
 EXPORT_SYMBOL(set_irq_wake);
@@ -382,6 +382,7 @@ int can_request_irq(unsigned int irq, unsigned long irqflags)
 {
         struct irq_desc *desc = irq_to_desc(irq);
         struct irqaction *action;
+        unsigned long flags;
 
         if (!desc)
                 return 0;
@@ -389,11 +390,14 @@ int can_request_irq(unsigned int irq, unsigned long irqflags)
         if (desc->status & IRQ_NOREQUEST)
                 return 0;
 
+        raw_spin_lock_irqsave(&desc->lock, flags);
         action = desc->action;
         if (action)
                 if (irqflags & action->flags & IRQF_SHARED)
                         action = NULL;
 
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
+
         return !action;
 }
 
@@ -483,13 +487,31 @@ static int irq_wait_for_interrupt(struct irqaction *action)
  */
 static void irq_finalize_oneshot(unsigned int irq, struct irq_desc *desc)
 {
+again:
         chip_bus_lock(irq, desc);
-        spin_lock_irq(&desc->lock);
+        raw_spin_lock_irq(&desc->lock);
+
+        /*
+         * Implausible though it may be we need to protect us against
+         * the following scenario:
+         *
+         * The thread is faster done than the hard interrupt handler
+         * on the other CPU. If we unmask the irq line then the
+         * interrupt can come in again and masks the line, leaves due
+         * to IRQ_INPROGRESS and the irq line is masked forever.
+         */
+        if (unlikely(desc->status & IRQ_INPROGRESS)) {
+                raw_spin_unlock_irq(&desc->lock);
+                chip_bus_sync_unlock(irq, desc);
+                cpu_relax();
+                goto again;
+        }
+
         if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
                 desc->status &= ~IRQ_MASKED;
                 desc->chip->unmask(irq);
         }
-        spin_unlock_irq(&desc->lock);
+        raw_spin_unlock_irq(&desc->lock);
         chip_bus_sync_unlock(irq, desc);
 }
 
@@ -514,9 +536,9 @@ irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
                 return;
         }
 
-        spin_lock_irq(&desc->lock);
+        raw_spin_lock_irq(&desc->lock);
         cpumask_copy(mask, desc->affinity);
-        spin_unlock_irq(&desc->lock);
+        raw_spin_unlock_irq(&desc->lock);
 
         set_cpus_allowed_ptr(current, mask);
         free_cpumask_var(mask);
@@ -545,7 +567,7 @@ static int irq_thread(void *data)
 
                 atomic_inc(&desc->threads_active);
 
-                spin_lock_irq(&desc->lock);
+                raw_spin_lock_irq(&desc->lock);
                 if (unlikely(desc->status & IRQ_DISABLED)) {
                         /*
                          * CHECKME: We might need a dedicated
@@ -555,9 +577,9 @@ static int irq_thread(void *data)
                          * retriggers the interrupt itself --- tglx
                          */
                         desc->status |= IRQ_PENDING;
-                        spin_unlock_irq(&desc->lock);
+                        raw_spin_unlock_irq(&desc->lock);
                 } else {
-                        spin_unlock_irq(&desc->lock);
+                        raw_spin_unlock_irq(&desc->lock);
 
                         action->thread_fn(action->irq, action->dev_id);
 
@@ -679,7 +701,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
         /*
          * The following block of code has to be executed atomically
          */
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
         old_ptr = &desc->action;
         old = *old_ptr;
         if (old) {
@@ -735,6 +757,16 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 if (new->flags & IRQF_ONESHOT)
                         desc->status |= IRQ_ONESHOT;
 
+                /*
+                 * Force MSI interrupts to run with interrupts
+                 * disabled. The multi vector cards can cause stack
+                 * overflows due to nested interrupts when enough of
+                 * them are directed to a core and fire at the same
+                 * time.
+                 */
+                if (desc->msi_desc)
+                        new->flags |= IRQF_DISABLED;
+
                 if (!(desc->status & IRQ_NOAUTOEN)) {
                         desc->depth = 0;
                         desc->status &= ~IRQ_DISABLED;
@@ -775,7 +807,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                 __enable_irq(desc, irq, false);
         }
 
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         /*
          * Strictly no need to wake it up, but hung_task complains
@@ -802,7 +834,7 @@ mismatch:
         ret = -EBUSY;
 
 out_thread:
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
         if (new->thread) {
                 struct task_struct *t = new->thread;
 
@@ -844,7 +876,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
         if (!desc)
                 return NULL;
 
-        spin_lock_irqsave(&desc->lock, flags);
+        raw_spin_lock_irqsave(&desc->lock, flags);
 
         /*
          * There can be multiple actions per IRQ descriptor, find the right
@@ -856,7 +888,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
 
                 if (!action) {
                         WARN(1, "Trying to free already-free IRQ %d\n", irq);
-                        spin_unlock_irqrestore(&desc->lock, flags);
+                        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
                         return NULL;
                 }
@@ -884,7 +916,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
                         desc->chip->disable(irq);
         }
 
-        spin_unlock_irqrestore(&desc->lock, flags);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         unregister_handler_proc(irq, action);
 
@@ -1067,7 +1099,7 @@ int request_threaded_irq(unsigned int irq, irq_handler_t handler,
                 kfree(action);
 
 #ifdef CONFIG_DEBUG_SHIRQ
-        if (irqflags & IRQF_SHARED) {
+        if (!retval && (irqflags & IRQF_SHARED)) {
                 /*
                  * It's a shared IRQ -- the driver ought to be prepared for it
                  * to happen immediately, so let's make sure....