6 files changed, 80 insertions, 18 deletions

diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 57d86d07221e..cbd97ce0b000 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -90,27 +90,41 @@ int irq_set_handler_data(unsigned int irq, void *data)
 EXPORT_SYMBOL(irq_set_handler_data);
 
 /**
- *      irq_set_msi_desc - set MSI descriptor data for an irq
- *      @irq:   Interrupt number
- *      @entry: Pointer to MSI descriptor data
+ *      irq_set_msi_desc_off - set MSI descriptor data for an irq at offset
+ *      @irq_base:      Interrupt number base
+ *      @irq_offset:    Interrupt number offset
+ *      @entry:         Pointer to MSI descriptor data
  *
- *      Set the MSI descriptor entry for an irq
+ *      Set the MSI descriptor entry for an irq at offset
  */
-int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry)
+int irq_set_msi_desc_off(unsigned int irq_base, unsigned int irq_offset,
+                         struct msi_desc *entry)
 {
         unsigned long flags;
-        struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
+        struct irq_desc *desc = irq_get_desc_lock(irq_base + irq_offset, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
 
         if (!desc)
                 return -EINVAL;
         desc->irq_data.msi_desc = entry;
-        if (entry)
-                entry->irq = irq;
+        if (entry && !irq_offset)
+                entry->irq = irq_base;
         irq_put_desc_unlock(desc, flags);
         return 0;
 }
 
 /**
+ *      irq_set_msi_desc - set MSI descriptor data for an irq
+ *      @irq:   Interrupt number
+ *      @entry: Pointer to MSI descriptor data
+ *
+ *      Set the MSI descriptor entry for an irq
+ */
+int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry)
+{
+        return irq_set_msi_desc_off(irq, 0, entry);
+}
+
+/**
  *      irq_set_chip_data - set irq chip data for an irq
  *      @irq:   Interrupt number
  *      @data:  Pointer to chip specific data
@@ -272,6 +286,7 @@ void handle_nested_irq(unsigned int irq)
 
         raw_spin_lock_irq(&desc->lock);
 
+        desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
         kstat_incr_irqs_this_cpu(irq, desc);
 
         action = desc->action;
diff --git a/kernel/irq/irqdomain.c b/kernel/irq/irqdomain.c
index 4e69e24d3d7d..96f3a1d9c379 100644
--- a/kernel/irq/irqdomain.c
+++ b/kernel/irq/irqdomain.c
@@ -177,8 +177,8 @@ struct irq_domain *irq_domain_add_simple(struct device_node *of_node,
                         irq_base = irq_alloc_descs(first_irq, first_irq, size,
                                                    of_node_to_nid(of_node));
                         if (irq_base < 0) {
-                                WARN(1, "Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
-                                     first_irq);
+                                pr_info("Cannot allocate irq_descs @ IRQ%d, assuming pre-allocated\n",
+                                        first_irq);
                                 irq_base = first_irq;
                         }
                 } else
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 4c69326aa773..fa17855ca65a 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -16,6 +16,7 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
+#include <linux/sched/rt.h>
 #include <linux/task_work.h>
 
 #include "internals.h"
@@ -616,6 +617,22 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
         return ret;
 }
 
+#ifdef CONFIG_HARDIRQS_SW_RESEND
+int irq_set_parent(int irq, int parent_irq)
+{
+        unsigned long flags;
+        struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
+
+        if (!desc)
+                return -EINVAL;
+
+        desc->parent_irq = parent_irq;
+
+        irq_put_desc_unlock(desc, flags);
+        return 0;
+}
+#endif
+
 /*
  * Default primary interrupt handler for threaded interrupts. Is
  * assigned as primary handler when request_threaded_irq is called
@@ -716,6 +733,7 @@ static void
 irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
 {
         cpumask_var_t mask;
+        bool valid = true;
 
         if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags))
                 return;
@@ -730,10 +748,18 @@ irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
         }
 
         raw_spin_lock_irq(&desc->lock);
-        cpumask_copy(mask, desc->irq_data.affinity);
+        /*
+         * This code is triggered unconditionally. Check the affinity
+         * mask pointer. For CPU_MASK_OFFSTACK=n this is optimized out.
+         */
+        if (desc->irq_data.affinity)
+                cpumask_copy(mask, desc->irq_data.affinity);
+        else
+                valid = false;
         raw_spin_unlock_irq(&desc->lock);
 
-        set_cpus_allowed_ptr(current, mask);
+        if (valid)
+                set_cpus_allowed_ptr(current, mask);
         free_cpumask_var(mask);
 }
 #else
@@ -793,7 +819,7 @@ static void irq_thread_dtor(struct callback_head *unused)
         action = kthread_data(tsk);
 
         pr_err("exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n",
-               tsk->comm ? tsk->comm : "", tsk->pid, action->irq);
+               tsk->comm, tsk->pid, action->irq);
 
 
         desc = irq_to_desc(action->irq);
@@ -833,6 +859,8 @@ static int irq_thread(void *data)
         init_task_work(&on_exit_work, irq_thread_dtor);
         task_work_add(current, &on_exit_work, false);
 
+        irq_thread_check_affinity(desc, action);
+
         while (!irq_wait_for_interrupt(action)) {
                 irqreturn_t action_ret;
 
@@ -936,6 +964,16 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                  */
                 get_task_struct(t);
                 new->thread = t;
+                /*
+                 * Tell the thread to set its affinity. This is
+                 * important for shared interrupt handlers as we do
+                 * not invoke setup_affinity() for the secondary
+                 * handlers as everything is already set up. Even for
+                 * interrupts marked with IRQF_NO_BALANCE this is
+                 * correct as we want the thread to move to the cpu(s)
+                 * on which the requesting code placed the interrupt.
+                 */
+                set_bit(IRQTF_AFFINITY, &new->thread_flags);
         }
 
         if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
@@ -1487,6 +1525,7 @@ void enable_percpu_irq(unsigned int irq, unsigned int type)
 out:
         irq_put_desc_unlock(desc, flags);
 }
+EXPORT_SYMBOL_GPL(enable_percpu_irq);
 
 void disable_percpu_irq(unsigned int irq)
 {
@@ -1500,6 +1539,7 @@ void disable_percpu_irq(unsigned int irq)
         irq_percpu_disable(desc, cpu);
         irq_put_desc_unlock(desc, flags);
 }
+EXPORT_SYMBOL_GPL(disable_percpu_irq);
 
 /*
  * Internal function to unregister a percpu irqaction.
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 4bd4faa6323a..397db02209ed 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -76,7 +76,7 @@ static int irq_affinity_list_proc_show(struct seq_file *m, void *v)
 static ssize_t write_irq_affinity(int type, struct file *file,
                 const char __user *buffer, size_t count, loff_t *pos)
 {
-        unsigned int irq = (int)(long)PDE(file->f_path.dentry->d_inode)->data;
+        unsigned int irq = (int)(long)PDE(file_inode(file))->data;
         cpumask_var_t new_value;
         int err;
 
diff --git a/kernel/irq/resend.c b/kernel/irq/resend.c
index 6454db7b6a4d..9065107f083e 100644
--- a/kernel/irq/resend.c
+++ b/kernel/irq/resend.c
@@ -74,6 +74,14 @@ void check_irq_resend(struct irq_desc *desc, unsigned int irq)
                 if (!desc->irq_data.chip->irq_retrigger ||
                     !desc->irq_data.chip->irq_retrigger(&desc->irq_data)) {
 #ifdef CONFIG_HARDIRQS_SW_RESEND
+                        /*
+                         * If the interrupt has a parent irq and runs
+                         * in the thread context of the parent irq,
+                         * retrigger the parent.
+                         */
+                        if (desc->parent_irq &&
+                            irq_settings_is_nested_thread(desc))
+                                irq = desc->parent_irq;
                         /* Set it pending and activate the softirq: */
                         set_bit(irq, irqs_resend);
                         tasklet_schedule(&resend_tasklet);
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index 611cd6003c45..7b5f012bde9d 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -80,13 +80,11 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force)
 
         /*
          * All handlers must agree on IRQF_SHARED, so we test just the
-         * first. Check for action->next as well.
+         * first.
          */
         action = desc->action;
         if (!action || !(action->flags & IRQF_SHARED) ||
-            (action->flags & __IRQF_TIMER) ||
-            (action->handler(irq, action->dev_id) == IRQ_HANDLED) ||
-            !action->next)
+            (action->flags & __IRQF_TIMER))
                 goto out;
 
         /* Already running on another processor */
@@ -104,6 +102,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force)
         do {
                 if (handle_irq_event(desc) == IRQ_HANDLED)
                         ret = IRQ_HANDLED;
+                /* Make sure that there is still a valid action */
                 action = desc->action;
         } while ((desc->istate & IRQS_PENDING) && action);
         desc->istate &= ~IRQS_POLL_INPROGRESS;