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.c for details. 9 */ 10 11 #include <linux/wait.h> 12 13 struct completion { 14 unsigned int done; 15 wait_queue_head_t wait; 16 }; 17 18 #define COMPLETION_INITIALIZER(work) \ 19 { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) } 20 21 #define COMPLETION_INITIALIZER_ONSTACK(work) \ 22 ({ init_completion(&work); work; }) 23 24 #define DECLARE_COMPLETION(work) \ 25 struct completion work = COMPLETION_INITIALIZER(work) 26 27 /* 28 * Lockdep needs to run a non-constant initializer for on-stack 29 * completions - so we use the _ONSTACK() variant for those that 30 * are on the kernel stack: 31 */ 32 #ifdef CONFIG_LOCKDEP 33 # define DECLARE_COMPLETION_ONSTACK(work) \ 34 struct completion work = COMPLETION_INITIALIZER_ONSTACK(work) 35 #else 36 # define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work) 37 #endif 38 39 static inline void init_completion(struct completion *x) 40 { 41 x->done = 0; 42 init_waitqueue_head(&x->wait); 43 } 44 45 extern void wait_for_completion(struct completion *); 46 extern int wait_for_completion_interruptible(struct completion *x); 47 extern int wait_for_completion_killable(struct completion *x); 48 extern unsigned long wait_for_completion_timeout(struct completion *x, 49 unsigned long timeout); 50 extern unsigned long wait_for_completion_interruptible_timeout( 51 struct completion *x, unsigned long timeout); 52 53 extern void complete(struct completion *); 54 extern void complete_all(struct completion *); 55 56 #define INIT_COMPLETION(x) ((x).done = 0) 57 58 59 /** 60 * try_wait_for_completion - try to decrement a completion without blocking 61 * @x: completion structure 62 * 63 * Returns: 0 if a decrement cannot be done without blocking 64 * 1 if a decrement succeeded. 65 * 66 * If a completion is being used as a counting completion, 67 * attempt to decrement the counter without blocking. This 68 * enables us to avoid waiting if the resource the completion 69 * is protecting is not available. 70 */ 71 static inline bool try_wait_for_completion(struct completion *x) 72 { 73 int ret = 1; 74 75 spin_lock_irq(&x->wait.lock); 76 if (!x->done) 77 ret = 0; 78 else 79 x->done--; 80 spin_unlock_irq(&x->wait.lock); 81 return ret; 82 } 83 84 /** 85 * completion_done - Test to see if a completion has any waiters 86 * @x: completion structure 87 * 88 * Returns: 0 if there are waiters (wait_for_completion() in progress) 89 * 1 if there are no waiters. 90 * 91 */ 92 static inline bool completion_done(struct completion *x) 93 { 94 int ret = 1; 95 96 spin_lock_irq(&x->wait.lock); 97 if (!x->done) 98 ret = 0; 99 spin_unlock_irq(&x->wait.lock); 100 return ret; 101 } 102 103 #endif 104