Merge branch 'irq-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'irq-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  genirq: Clear CPU mask in affinity_hint when none is provided
  genirq: Add CPU mask affinity hint
  genirq: Remove IRQF_DISABLED from core code
  genirq: Run irq handlers with interrupts disabled
  genirq: Introduce request_any_context_irq()
  genirq: Expose irq_desc->node in proc/irq

Fixed up trivial conflicts in Documentation/feature-removal-schedule.txt

3 files changed, 119 insertions, 33 deletions

diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 76d5a671bfe1..27e5c6911223 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -370,9 +370,6 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
         irqreturn_t ret, retval = IRQ_NONE;
         unsigned int status = 0;
 
-        if (!(action->flags & IRQF_DISABLED))
-                local_irq_enable_in_hardirq();
-
         do {
                 trace_irq_handler_entry(irq, action);
                 ret = action->handler(irq, action->dev_id);
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 704e488730a5..3164ba7ce151 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -138,6 +138,22 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
         return 0;
 }
 
+int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        unsigned long flags;
+
+        if (!desc)
+                return -EINVAL;
+
+        raw_spin_lock_irqsave(&desc->lock, flags);
+        desc->affinity_hint = m;
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(irq_set_affinity_hint);
+
 #ifndef CONFIG_AUTO_IRQ_AFFINITY
 /*
  * Generic version of the affinity autoselector.
@@ -757,16 +773,6 @@ __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;
@@ -916,6 +922,12 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
                         desc->chip->disable(irq);
         }
 
+#ifdef CONFIG_SMP
+        /* make sure affinity_hint is cleaned up */
+        if (WARN_ON_ONCE(desc->affinity_hint))
+                desc->affinity_hint = NULL;
+#endif
+
         raw_spin_unlock_irqrestore(&desc->lock, flags);
 
         unregister_handler_proc(irq, action);
@@ -1027,7 +1039,6 @@ EXPORT_SYMBOL(free_irq);
  *      Flags:
  *
  *      IRQF_SHARED             Interrupt is shared
- *      IRQF_DISABLED   Disable local interrupts while processing
  *      IRQF_SAMPLE_RANDOM      The interrupt can be used for entropy
  *      IRQF_TRIGGER_*          Specify active edge(s) or level
  *
@@ -1041,25 +1052,6 @@ int request_threaded_irq(unsigned int irq, irq_handler_t handler,
         int retval;
 
         /*
-         * handle_IRQ_event() always ignores IRQF_DISABLED except for
-         * the _first_ irqaction (sigh).  That can cause oopsing, but
-         * the behavior is classified as "will not fix" so we need to
-         * start nudging drivers away from using that idiom.
-         */
-        if ((irqflags & (IRQF_SHARED|IRQF_DISABLED)) ==
-                                        (IRQF_SHARED|IRQF_DISABLED)) {
-                pr_warning(
-                  "IRQ %d/%s: IRQF_DISABLED is not guaranteed on shared IRQs\n",
-                        irq, devname);
-        }
-
-#ifdef CONFIG_LOCKDEP
-        /*
-         * Lockdep wants atomic interrupt handlers:
-         */
-        irqflags |= IRQF_DISABLED;
-#endif
-        /*
          * Sanity-check: shared interrupts must pass in a real dev-ID,
          * otherwise we'll have trouble later trying to figure out
          * which interrupt is which (messes up the interrupt freeing
@@ -1120,3 +1112,40 @@ int request_threaded_irq(unsigned int irq, irq_handler_t handler,
         return retval;
 }
 EXPORT_SYMBOL(request_threaded_irq);
+
+/**
+ *      request_any_context_irq - allocate an interrupt line
+ *      @irq: Interrupt line to allocate
+ *      @handler: Function to be called when the IRQ occurs.
+ *                Threaded handler for threaded interrupts.
+ *      @flags: Interrupt type flags
+ *      @name: An ascii name for the claiming device
+ *      @dev_id: A cookie passed back to the handler function
+ *
+ *      This call allocates interrupt resources and enables the
+ *      interrupt line and IRQ handling. It selects either a
+ *      hardirq or threaded handling method depending on the
+ *      context.
+ *
+ *      On failure, it returns a negative value. On success,
+ *      it returns either IRQC_IS_HARDIRQ or IRQC_IS_NESTED.
+ */
+int request_any_context_irq(unsigned int irq, irq_handler_t handler,
+                            unsigned long flags, const char *name, void *dev_id)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        int ret;
+
+        if (!desc)
+                return -EINVAL;
+
+        if (desc->status & IRQ_NESTED_THREAD) {
+                ret = request_threaded_irq(irq, NULL, handler,
+                                           flags, name, dev_id);
+                return !ret ? IRQC_IS_NESTED : ret;
+        }
+
+        ret = request_irq(irq, handler, flags, name, dev_id);
+        return !ret ? IRQC_IS_HARDIRQ : ret;
+}
+EXPORT_SYMBOL_GPL(request_any_context_irq);
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 7a6eb04ef6b5..09a2ee540bd2 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -32,6 +32,27 @@ static int irq_affinity_proc_show(struct seq_file *m, void *v)
         return 0;
 }
 
+static int irq_affinity_hint_proc_show(struct seq_file *m, void *v)
+{
+        struct irq_desc *desc = irq_to_desc((long)m->private);
+        unsigned long flags;
+        cpumask_var_t mask;
+
+        if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
+                return -ENOMEM;
+
+        raw_spin_lock_irqsave(&desc->lock, flags);
+        if (desc->affinity_hint)
+                cpumask_copy(mask, desc->affinity_hint);
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
+
+        seq_cpumask(m, mask);
+        seq_putc(m, '\n');
+        free_cpumask_var(mask);
+
+        return 0;
+}
+
 #ifndef is_affinity_mask_valid
 #define is_affinity_mask_valid(val) 1
 #endif
@@ -84,6 +105,11 @@ static int irq_affinity_proc_open(struct inode *inode, struct file *file)
         return single_open(file, irq_affinity_proc_show, PDE(inode)->data);
 }
 
+static int irq_affinity_hint_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, irq_affinity_hint_proc_show, PDE(inode)->data);
+}
+
 static const struct file_operations irq_affinity_proc_fops = {
         .open           = irq_affinity_proc_open,
         .read           = seq_read,
@@ -92,6 +118,13 @@ static const struct file_operations irq_affinity_proc_fops = {
         .write          = irq_affinity_proc_write,
 };
 
+static const struct file_operations irq_affinity_hint_proc_fops = {
+        .open           = irq_affinity_hint_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 static int default_affinity_show(struct seq_file *m, void *v)
 {
         seq_cpumask(m, irq_default_affinity);
@@ -147,6 +180,26 @@ static const struct file_operations default_affinity_proc_fops = {
         .release        = single_release,
         .write          = default_affinity_write,
 };
+
+static int irq_node_proc_show(struct seq_file *m, void *v)
+{
+        struct irq_desc *desc = irq_to_desc((long) m->private);
+
+        seq_printf(m, "%d\n", desc->node);
+        return 0;
+}
+
+static int irq_node_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, irq_node_proc_show, PDE(inode)->data);
+}
+
+static const struct file_operations irq_node_proc_fops = {
+        .open           = irq_node_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
 #endif
 
 static int irq_spurious_proc_show(struct seq_file *m, void *v)
@@ -231,6 +284,13 @@ void register_irq_proc(unsigned int irq, struct irq_desc *desc)
         /* create /proc/irq/<irq>/smp_affinity */
         proc_create_data("smp_affinity", 0600, desc->dir,
                          &irq_affinity_proc_fops, (void *)(long)irq);
+
+        /* create /proc/irq/<irq>/affinity_hint */
+        proc_create_data("affinity_hint", 0400, desc->dir,
+                         &irq_affinity_hint_proc_fops, (void *)(long)irq);
+
+        proc_create_data("node", 0444, desc->dir,
+                         &irq_node_proc_fops, (void *)(long)irq);
 #endif
 
         proc_create_data("spurious", 0444, desc->dir,