irq_work.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    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 <asm/processor.h>
   16 
   17 /*
   18  * An entry can be in one of four states:
   19  *
   20  * free      NULL, 0 -> {claimed}       : free to be used
   21  * claimed   NULL, 3 -> {pending}       : claimed to be enqueued
   22  * pending   next, 3 -> {busy}          : queued, pending callback
   23  * busy      NULL, 2 -> {free, claimed} : callback in progress, can be claimed
   24  */
   25 
   26 #define IRQ_WORK_PENDING        1UL
   27 #define IRQ_WORK_BUSY           2UL
   28 #define IRQ_WORK_FLAGS          3UL
   29 
   30 static DEFINE_PER_CPU(struct llist_head, irq_work_list);
   31 
   32 /*
   33  * Claim the entry so that no one else will poke at it.
   34  */
   35 static bool irq_work_claim(struct irq_work *work)
   36 {
   37         unsigned long flags, nflags;
   38 
   39         for (;;) {
   40                 flags = work->flags;
   41                 if (flags & IRQ_WORK_PENDING)
   42                         return false;
   43                 nflags = flags | IRQ_WORK_FLAGS;
   44                 if (cmpxchg(&work->flags, flags, nflags) == flags)
   45                         break;
   46                 cpu_relax();
   47         }
   48 
   49         return true;
   50 }
   51 
   52 void __weak arch_irq_work_raise(void)
   53 {
   54         /*
   55          * Lame architectures will get the timer tick callback
   56          */
   57 }
   58 
   59 /*
   60  * Queue the entry and raise the IPI if needed.
   61  */
   62 static void __irq_work_queue(struct irq_work *work)
   63 {
   64         bool empty;
   65 
   66         preempt_disable();
   67 
   68         empty = llist_add(&work->llnode, &__get_cpu_var(irq_work_list));
   69         /* The list was empty, raise self-interrupt to start processing. */
   70         if (empty)
   71                 arch_irq_work_raise();
   72 
   73         preempt_enable();
   74 }
   75 
   76 /*
   77  * Enqueue the irq_work @entry, returns true on success, failure when the
   78  * @entry was already enqueued by someone else.
   79  *
   80  * Can be re-enqueued while the callback is still in progress.
   81  */
   82 bool irq_work_queue(struct irq_work *work)
   83 {
   84         if (!irq_work_claim(work)) {
   85                 /*
   86                  * Already enqueued, can't do!
   87                  */
   88                 return false;
   89         }
   90 
   91         __irq_work_queue(work);
   92         return true;
   93 }
   94 EXPORT_SYMBOL_GPL(irq_work_queue);
   95 
   96 /*
   97  * Run the irq_work entries on this cpu. Requires to be ran from hardirq
   98  * context with local IRQs disabled.
   99  */
  100 void irq_work_run(void)
  101 {
  102         struct irq_work *work;
  103         struct llist_head *this_list;
  104         struct llist_node *llnode;
  105 
  106         this_list = &__get_cpu_var(irq_work_list);
  107         if (llist_empty(this_list))
  108                 return;
  109 
  110         BUG_ON(!in_irq());
  111         BUG_ON(!irqs_disabled());
  112 
  113         llnode = llist_del_all(this_list);
  114         while (llnode != NULL) {
  115                 work = llist_entry(llnode, struct irq_work, llnode);
  116 
  117                 llnode = llist_next(llnode);
  118 
  119                 /*
  120                  * Clear the PENDING bit, after this point the @work
  121                  * can be re-used.
  122                  */
  123                 work->flags = IRQ_WORK_BUSY;
  124                 work->func(work);
  125                 /*
  126                  * Clear the BUSY bit and return to the free state if
  127                  * no-one else claimed it meanwhile.
  128                  */
  129                 (void)cmpxchg(&work->flags, IRQ_WORK_BUSY, 0);
  130         }
  131 }
  132 EXPORT_SYMBOL_GPL(irq_work_run);
  133 
  134 /*
  135  * Synchronize against the irq_work @entry, ensures the entry is not
  136  * currently in use.
  137  */
  138 void irq_work_sync(struct irq_work *work)
  139 {
  140         WARN_ON_ONCE(irqs_disabled());
  141 
  142         while (work->flags & IRQ_WORK_BUSY)
  143                 cpu_relax();
  144 }
  145 EXPORT_SYMBOL_GPL(irq_work_sync);

Cache object: ac7742ed89a17e93f65bd0683a41c853

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/kernel/irq_work.c

FreeBSD/Linux Kernel Cross Reference
sys/kernel/irq_work.c