2 files changed, 41 insertions, 20 deletions

diff --git a/include/linux/irq_work.h b/include/linux/irq_work.h
index a69704f37204..b28eb60c8bf6 100644
--- a/include/linux/irq_work.h
+++ b/include/linux/irq_work.h
@@ -3,6 +3,20 @@
 
 #include <linux/llist.h>
 
+/*
+ * An entry can be in one of four states:
+ *
+ * free      NULL, 0 -> {claimed}       : free to be used
+ * claimed   NULL, 3 -> {pending}       : claimed to be enqueued
+ * pending   next, 3 -> {busy}          : queued, pending callback
+ * busy      NULL, 2 -> {free, claimed} : callback in progress, can be claimed
+ */
+
+#define IRQ_WORK_PENDING        1UL
+#define IRQ_WORK_BUSY           2UL
+#define IRQ_WORK_FLAGS          3UL
+#define IRQ_WORK_LAZY           4UL /* Doesn't want IPI, wait for tick */
+
 struct irq_work {
         unsigned long flags;
         struct llist_node llnode;
diff --git a/kernel/irq_work.c b/kernel/irq_work.c
index 480f74715ba9..7f3a59bc8e3d 100644
--- a/kernel/irq_work.c
+++ b/kernel/irq_work.c
@@ -12,24 +12,15 @@
 #include <linux/percpu.h>
 #include <linux/hardirq.h>
 #include <linux/irqflags.h>
+#include <linux/sched.h>
+#include <linux/tick.h>
 #include <linux/cpu.h>
 #include <linux/notifier.h>
 #include <asm/processor.h>
 
-/*
- * An entry can be in one of four states:
- *
- * free      NULL, 0 -> {claimed}       : free to be used
- * claimed   NULL, 3 -> {pending}       : claimed to be enqueued
- * pending   next, 3 -> {busy}          : queued, pending callback
- * busy      NULL, 2 -> {free, claimed} : callback in progress, can be claimed
- */
-
-#define IRQ_WORK_PENDING        1UL
-#define IRQ_WORK_BUSY           2UL
-#define IRQ_WORK_FLAGS          3UL
 
 static DEFINE_PER_CPU(struct llist_head, irq_work_list);
+static DEFINE_PER_CPU(int, irq_work_raised);
 
 /*
  * Claim the entry so that no one else will poke at it.
@@ -69,14 +60,19 @@ void __weak arch_irq_work_raise(void)
  */
 static void __irq_work_queue(struct irq_work *work)
 {
-        bool empty;
-
         preempt_disable();
 
-        empty = llist_add(&work->llnode, &__get_cpu_var(irq_work_list));
-        /* The list was empty, raise self-interrupt to start processing. */
-        if (empty)
-                arch_irq_work_raise();
+        llist_add(&work->llnode, &__get_cpu_var(irq_work_list));
+
+        /*
+         * If the work is not "lazy" or the tick is stopped, raise the irq
+         * work interrupt (if supported by the arch), otherwise, just wait
+         * for the next tick.
+         */
+        if (!(work->flags & IRQ_WORK_LAZY) || tick_nohz_tick_stopped()) {
+                if (!this_cpu_cmpxchg(irq_work_raised, 0, 1))
+                        arch_irq_work_raise();
+        }
 
         preempt_enable();
 }
@@ -117,10 +113,19 @@ bool irq_work_needs_cpu(void)
 
 static void __irq_work_run(void)
 {
+        unsigned long flags;
         struct irq_work *work;
         struct llist_head *this_list;
         struct llist_node *llnode;
 
+
+        /*
+         * Reset the "raised" state right before we check the list because
+         * an NMI may enqueue after we find the list empty from the runner.
+         */
+        __this_cpu_write(irq_work_raised, 0);
+        barrier();
+
         this_list = &__get_cpu_var(irq_work_list);
         if (llist_empty(this_list))
                 return;
@@ -140,13 +145,15 @@ static void __irq_work_run(void)
                  * to claim that work don't rely on us to handle their data
                  * while we are in the middle of the func.
                  */
-                xchg(&work->flags, IRQ_WORK_BUSY);
+                flags = work->flags & ~IRQ_WORK_PENDING;
+                xchg(&work->flags, flags);
+
                 work->func(work);
                 /*
                  * Clear the BUSY bit and return to the free state if
                  * no-one else claimed it meanwhile.
                  */
-                (void)cmpxchg(&work->flags, IRQ_WORK_BUSY, 0);
+                (void)cmpxchg(&work->flags, flags, flags & ~IRQ_WORK_BUSY);
         }
 }