Pileus Git - ~andy/linux/blob - kernel/irq_work.c

   1 /*
   2  * Copyright (C) 2010 Red Hat, Inc., Peter Zijlstra <pzijlstr@redhat.com>
   3  *
   4  * Provides a framework for enqueueing and running callbacks from hardirq
   5  * context. The enqueueing is NMI-safe.
   6  */
   7
   8 #include <linux/bug.h>
   9 #include <linux/kernel.h>
  10 #include <linux/export.h>
  11 #include <linux/irq_work.h>
  12 #include <linux/percpu.h>
  13 #include <linux/hardirq.h>
  14 #include <linux/irqflags.h>
  15 #include <linux/cpu.h>
  16 #include <linux/notifier.h>
  17 #include <asm/processor.h>
  18
  19 /*
  20  * An entry can be in one of four states:
  21  *
  22  * free      NULL, 0 -> {claimed}       : free to be used
  23  * claimed   NULL, 3 -> {pending}       : claimed to be enqueued
  24  * pending   next, 3 -> {busy}          : queued, pending callback
  25  * busy      NULL, 2 -> {free, claimed} : callback in progress, can be claimed
  26  */
  27
  28 #define IRQ_WORK_PENDING        1UL
  29 #define IRQ_WORK_BUSY           2UL
  30 #define IRQ_WORK_FLAGS          3UL
  31
  32 static DEFINE_PER_CPU(struct llist_head, irq_work_list);
  33
  34 /*
  35  * Claim the entry so that no one else will poke at it.
  36  */
  37 static bool irq_work_claim(struct irq_work *work)
  38 {
  39         unsigned long flags, oflags, nflags;
  40
  41         /*
  42          * Start with our best wish as a premise but only trust any
  43          * flag value after cmpxchg() result.
  44          */
  45         flags = work->flags & ~IRQ_WORK_PENDING;
  46         for (;;) {
  47                 nflags = flags | IRQ_WORK_FLAGS;
  48                 oflags = cmpxchg(&work->flags, flags, nflags);
  49                 if (oflags == flags)
  50                         break;
  51                 if (oflags & IRQ_WORK_PENDING)
  52                         return false;
  53                 flags = oflags;
  54                 cpu_relax();
  55         }
  56
  57         return true;
  58 }
  59
  60 void __weak arch_irq_work_raise(void)
  61 {
  62         /*
  63          * Lame architectures will get the timer tick callback
  64          */
  65 }
  66
  67 /*
  68  * Queue the entry and raise the IPI if needed.
  69  */
  70 static void __irq_work_queue(struct irq_work *work)
  71 {
  72         bool empty;
  73
  74         preempt_disable();
  75
  76         empty = llist_add(&work->llnode, &__get_cpu_var(irq_work_list));
  77         /* The list was empty, raise self-interrupt to start processing. */
  78         if (empty)
  79                 arch_irq_work_raise();
  80
  81         preempt_enable();
  82 }
  83
  84 /*
  85  * Enqueue the irq_work @entry, returns true on success, failure when the
  86  * @entry was already enqueued by someone else.
  87  *
  88  * Can be re-enqueued while the callback is still in progress.
  89  */
  90 bool irq_work_queue(struct irq_work *work)
  91 {
  92         if (!irq_work_claim(work)) {
  93                 /*
  94                  * Already enqueued, can't do!
  95                  */
  96                 return false;
  97         }
  98
  99         __irq_work_queue(work);
 100         return true;
 101 }
 102 EXPORT_SYMBOL_GPL(irq_work_queue);
 103
 104 bool irq_work_needs_cpu(void)
 105 {
 106         struct llist_head *this_list;
 107
 108         this_list = &__get_cpu_var(irq_work_list);
 109         if (llist_empty(this_list))
 110                 return false;
 111
 112         return true;
 113 }
 114
 115 static void __irq_work_run(void)
 116 {
 117         struct irq_work *work;
 118         struct llist_head *this_list;
 119         struct llist_node *llnode;
 120
 121         this_list = &__get_cpu_var(irq_work_list);
 122         if (llist_empty(this_list))
 123                 return;
 124
 125         BUG_ON(!irqs_disabled());
 126
 127         llnode = llist_del_all(this_list);
 128         while (llnode != NULL) {
 129                 work = llist_entry(llnode, struct irq_work, llnode);
 130
 131                 llnode = llist_next(llnode);
 132
 133                 /*
 134                  * Clear the PENDING bit, after this point the @work
 135                  * can be re-used.
 136                  * Make it immediately visible so that other CPUs trying
 137                  * to claim that work don't rely on us to handle their data
 138                  * while we are in the middle of the func.
 139                  */
 140                 xchg(&work->flags, IRQ_WORK_BUSY);
 141                 work->func(work);
 142                 /*
 143                  * Clear the BUSY bit and return to the free state if
 144                  * no-one else claimed it meanwhile.
 145                  */
 146                 (void)cmpxchg(&work->flags, IRQ_WORK_BUSY, 0);
 147         }
 148 }
 149
 150 /*
 151  * Run the irq_work entries on this cpu. Requires to be ran from hardirq
 152  * context with local IRQs disabled.
 153  */
 154 void irq_work_run(void)
 155 {
 156         BUG_ON(!in_irq());
 157         __irq_work_run();
 158 }
 159 EXPORT_SYMBOL_GPL(irq_work_run);
 160
 161 /*
 162  * Synchronize against the irq_work @entry, ensures the entry is not
 163  * currently in use.
 164  */
 165 void irq_work_sync(struct irq_work *work)
 166 {
 167         WARN_ON_ONCE(irqs_disabled());
 168
 169         while (work->flags & IRQ_WORK_BUSY)
 170                 cpu_relax();
 171 }
 172 EXPORT_SYMBOL_GPL(irq_work_sync);
 173
 174 #ifdef CONFIG_HOTPLUG_CPU
 175 static int irq_work_cpu_notify(struct notifier_block *self,
 176                                unsigned long action, void *hcpu)
 177 {
 178         long cpu = (long)hcpu;
 179
 180         switch (action) {
 181         case CPU_DYING:
 182                 /* Called from stop_machine */
 183                 if (WARN_ON_ONCE(cpu != smp_processor_id()))
 184                         break;
 185                 __irq_work_run();
 186                 break;
 187         default:
 188                 break;
 189         }
 190         return NOTIFY_OK;
 191 }
 192
 193 static struct notifier_block cpu_notify;
 194
 195 static __init int irq_work_init_cpu_notifier(void)
 196 {
 197         cpu_notify.notifier_call = irq_work_cpu_notify;
 198         cpu_notify.priority = 0;
 199         register_cpu_notifier(&cpu_notify);
 200         return 0;
 201 }
 202 device_initcall(irq_work_init_cpu_notifier);
 203
 204 #endif /* CONFIG_HOTPLUG_CPU */