1#ifndef __LINUX_COMPLETION_H 2#define __LINUX_COMPLETION_H 3 4/* 5 * (C) Copyright 2001 Linus Torvalds 6 * 7 * Atomic wait-for-completion handler data structures. 8 * See kernel/sched/completion.c for details. 9 */ 10 11#include <linux/wait.h> 12 13/* 14 * struct completion - structure used to maintain state for a "completion" 15 * 16 * This is the opaque structure used to maintain the state for a "completion". 17 * Completions currently use a FIFO to queue threads that have to wait for 18 * the "completion" event. 19 * 20 * See also: complete(), wait_for_completion() (and friends _timeout, 21 * _interruptible, _interruptible_timeout, and _killable), init_completion(), 22 * reinit_completion(), and macros DECLARE_COMPLETION(), 23 * DECLARE_COMPLETION_ONSTACK(). 24 */ 25struct completion { 26 unsigned int done; 27 wait_queue_head_t wait; 28}; 29 30#define COMPLETION_INITIALIZER(work) \ 31 { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) } 32 33#define COMPLETION_INITIALIZER_ONSTACK(work) \ 34 ({ init_completion(&work); work; }) 35 36/** 37 * DECLARE_COMPLETION - declare and initialize a completion structure 38 * @work: identifier for the completion structure 39 * 40 * This macro declares and initializes a completion structure. Generally used 41 * for static declarations. You should use the _ONSTACK variant for automatic 42 * variables. 43 */ 44#define DECLARE_COMPLETION(work) \ 45 struct completion work = COMPLETION_INITIALIZER(work) 46 47/* 48 * Lockdep needs to run a non-constant initializer for on-stack 49 * completions - so we use the _ONSTACK() variant for those that 50 * are on the kernel stack: 51 */ 52/** 53 * DECLARE_COMPLETION_ONSTACK - declare and initialize a completion structure 54 * @work: identifier for the completion structure 55 * 56 * This macro declares and initializes a completion structure on the kernel 57 * stack. 58 */ 59#ifdef CONFIG_LOCKDEP 60# define DECLARE_COMPLETION_ONSTACK(work) \ 61 struct completion work = COMPLETION_INITIALIZER_ONSTACK(work) 62#else 63# define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work) 64#endif 65 66/** 67 * init_completion - Initialize a dynamically allocated completion 68 * @x: pointer to completion structure that is to be initialized 69 * 70 * This inline function will initialize a dynamically created completion 71 * structure. 72 */ 73static inline void init_completion(struct completion *x) 74{ 75 x->done = 0; 76 init_waitqueue_head(&x->wait); 77} 78 79/** 80 * reinit_completion - reinitialize a completion structure 81 * @x: pointer to completion structure that is to be reinitialized 82 * 83 * This inline function should be used to reinitialize a completion structure so it can 84 * be reused. This is especially important after complete_all() is used. 85 */ 86static inline void reinit_completion(struct completion *x) 87{ 88 x->done = 0; 89} 90 91extern void wait_for_completion(struct completion *); 92extern void wait_for_completion_io(struct completion *); 93extern int wait_for_completion_interruptible(struct completion *x); 94extern int wait_for_completion_killable(struct completion *x); 95extern unsigned long wait_for_completion_timeout(struct completion *x, 96 unsigned long timeout); 97extern unsigned long wait_for_completion_io_timeout(struct completion *x, 98 unsigned long timeout); 99extern long wait_for_completion_interruptible_timeout( 100 struct completion *x, unsigned long timeout); 101extern long wait_for_completion_killable_timeout( 102 struct completion *x, unsigned long timeout); 103extern bool try_wait_for_completion(struct completion *x); 104extern bool completion_done(struct completion *x); 105 106extern void complete(struct completion *); 107extern void complete_all(struct completion *); 108 109#endif 110