File: /Users/paulross/dev/linux/linux-3.13/include/linux/completion.h

Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.

       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:  */
      25: struct 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:  */
      73: static 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:  */
      86: static inline void reinit_completion(struct completion *x)
      87: {
      88:     x->done = 0;
      89: }
      90: 
      91: extern void wait_for_completion(struct completion *);
      92: extern void wait_for_completion_io(struct completion *);
      93: extern int wait_for_completion_interruptible(struct completion *x);
      94: extern int wait_for_completion_killable(struct completion *x);
      95: extern unsigned long wait_for_completion_timeout(struct completion *x,
      96:                            unsigned long timeout);
      97: extern unsigned long wait_for_completion_io_timeout(struct completion *x,
      98:                             unsigned long timeout);
      99: extern long wait_for_completion_interruptible_timeout(
     100:     struct completion *x, unsigned long timeout);
     101: extern long wait_for_completion_killable_timeout(
     102:     struct completion *x, unsigned long timeout);
     103: extern bool try_wait_for_completion(struct completion *x);
     104: extern bool completion_done(struct completion *x);
     105: 
     106: extern void complete(struct completion *);
     107: extern void complete_all(struct completion *);
     108: 
     109: #endif
     110: