Messages in this thread Patch in this message | | | Date | Tue, 18 Aug 2020 12:51:12 +0200 | From | Peter Zijlstra <> | Subject | [RFC][PATCH v2 10/10] irq_work: Add a few comments |
| |
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org> --- include/linux/irq_work.h | 80 +++++++++++++++++++++++++++++++++++++++++------ kernel/irq_work.c | 10 +++++ 2 files changed, 80 insertions(+), 10 deletions(-)
--- a/include/linux/irq_work.h +++ b/include/linux/irq_work.h @@ -4,15 +4,6 @@ #include <linux/smp_types.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 - */ - struct irq_work { struct __call_single_node node; void (*func)(struct irq_work *); @@ -36,11 +27,19 @@ void init_irq_work(struct irq_work *work *work = IRQ_WORK_INIT(func); } +/* + * irq_work_is_pending(): if @work is already queued + */ static inline bool irq_work_is_pending(struct irq_work *work) { return atomic_read(&work->node.a_flags) & IRQ_WORK_PENDING; } +/* + * irq_work_is_busy(): true until after func() has run + * + * Does not work with irq_work_queue_remote_static(). + */ static inline bool irq_work_is_busy(struct irq_work *work) { return atomic_read(&work->node.a_flags) & IRQ_WORK_BUSY; @@ -48,12 +47,45 @@ static inline bool irq_work_is_busy(stru #ifdef CONFIG_IRQ_WORK +/* + * irq_work_queue(): run @work in IRQ context on this CPU + * @work: work to run + * + * Self-IPI, NMI-safe + * + * When the function returns false; @work is already queued and + * any eventual execution of it's func() is guaranteed to see + * any state before the failing enqueue. + */ bool irq_work_queue(struct irq_work *work); + +/* + * irq_work_queue_on(): run @work in IRQ context on @cpu + * @work: work to run + * @cpu: cpu to run @work on + * + * *NOT* NMI-safe + * + * When the function returns false; @work is already queued and + * any eventual execution of it's func() is guaranteed to see + * any state before the failing enqueue. + */ bool irq_work_queue_on(struct irq_work *work, int cpu); -void irq_work_tick(void); +/* + * irq_work_sync(): wait for completion of @work + * @work: + * + * Expects no concurrent irq_work_queue() + * + * Will return once @work is no longer 'busy'. + * + * Does not work with irq_work_queue_remote_static(). + */ void irq_work_sync(struct irq_work *work); +void irq_work_tick(void); + #include <asm/irq_work.h> void irq_work_run(void); @@ -67,8 +99,36 @@ static inline bool irq_work_needs_cpu(vo #endif /* CONFIG_IRQ_WORK */ #ifdef CONFIG_SMP + +/* + * irq_work_queue_remote(): run @work in IRQ context on @cpu + * @cpu: + * @work: + * + * like irq_work_queue_on(), except it requires @cpu != smp_processor_id() and + * is available for any SMP build. + * + * Return -EBUSY when already queued, 0 on success. + */ extern int irq_work_queue_remote(int cpu, struct irq_work *work); + +/* + * irq_work_queue_remote_state(): like irq_work_queue_remote() except dangerous + * @cpu: + * @work: + * + * DO NOT USE, this function is horrible/dangerous. + * + * The test-and-set-PENDING is not atomic, it also doesn't set + * the BUSY bit and with that breaks irq_work_sync(). + * + * This means that the caller needs external serialization; life-time, + * where relevant, also needs to be externally orchestated. + * + * There is no validation/debugging to help you if you get it wrong. + */ extern int irq_work_queue_remote_static(int cpu, struct irq_work *work); + extern void irq_work_single(void *arg); #endif --- a/kernel/irq_work.c +++ b/kernel/irq_work.c @@ -23,6 +23,15 @@ #if defined(CONFIG_IRQ_WORK) || defined(CONFIG_SMP) /* + * 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 + */ + +/* * Claim the entry so that no one else will poke at it. */ static bool irq_work_claim(struct irq_work *work) @@ -37,6 +46,7 @@ static bool irq_work_claim(struct irq_wo */ if (oflags & IRQ_WORK_PENDING) return false; + return true; }
| |