Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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#ifdef CONFIG_LOCKDEP_COMPLETIONS
13#include <linux/lockdep.h>
14#endif
15
16/*
17 * struct completion - structure used to maintain state for a "completion"
18 *
19 * This is the opaque structure used to maintain the state for a "completion".
20 * Completions currently use a FIFO to queue threads that have to wait for
21 * the "completion" event.
22 *
23 * See also: complete(), wait_for_completion() (and friends _timeout,
24 * _interruptible, _interruptible_timeout, and _killable), init_completion(),
25 * reinit_completion(), and macros DECLARE_COMPLETION(),
26 * DECLARE_COMPLETION_ONSTACK().
27 */
28struct completion {
29 unsigned int done;
30 wait_queue_head_t wait;
31#ifdef CONFIG_LOCKDEP_COMPLETIONS
32 struct lockdep_map_cross map;
33#endif
34};
35
36#ifdef CONFIG_LOCKDEP_COMPLETIONS
37static inline void complete_acquire(struct completion *x)
38{
39 lock_acquire_exclusive((struct lockdep_map *)&x->map, 0, 0, NULL, _RET_IP_);
40}
41
42static inline void complete_release(struct completion *x)
43{
44 lock_release((struct lockdep_map *)&x->map, 0, _RET_IP_);
45}
46
47static inline void complete_release_commit(struct completion *x)
48{
49 lock_commit_crosslock((struct lockdep_map *)&x->map);
50}
51
52#define init_completion(x) \
53do { \
54 static struct lock_class_key __key; \
55 lockdep_init_map_crosslock((struct lockdep_map *)&(x)->map, \
56 "(complete)" #x, \
57 &__key, 0); \
58 __init_completion(x); \
59} while (0)
60#else
61#define init_completion(x) __init_completion(x)
62static inline void complete_acquire(struct completion *x) {}
63static inline void complete_release(struct completion *x) {}
64static inline void complete_release_commit(struct completion *x) {}
65#endif
66
67#ifdef CONFIG_LOCKDEP_COMPLETIONS
68#define COMPLETION_INITIALIZER(work) \
69 { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait), \
70 STATIC_CROSS_LOCKDEP_MAP_INIT("(complete)" #work, &(work)) }
71#else
72#define COMPLETION_INITIALIZER(work) \
73 { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
74#endif
75
76#define COMPLETION_INITIALIZER_ONSTACK(work) \
77 (*({ init_completion(&work); &work; }))
78
79/**
80 * DECLARE_COMPLETION - declare and initialize a completion structure
81 * @work: identifier for the completion structure
82 *
83 * This macro declares and initializes a completion structure. Generally used
84 * for static declarations. You should use the _ONSTACK variant for automatic
85 * variables.
86 */
87#define DECLARE_COMPLETION(work) \
88 struct completion work = COMPLETION_INITIALIZER(work)
89
90/*
91 * Lockdep needs to run a non-constant initializer for on-stack
92 * completions - so we use the _ONSTACK() variant for those that
93 * are on the kernel stack:
94 */
95/**
96 * DECLARE_COMPLETION_ONSTACK - declare and initialize a completion structure
97 * @work: identifier for the completion structure
98 *
99 * This macro declares and initializes a completion structure on the kernel
100 * stack.
101 */
102#ifdef CONFIG_LOCKDEP
103# define DECLARE_COMPLETION_ONSTACK(work) \
104 struct completion work = COMPLETION_INITIALIZER_ONSTACK(work)
105#else
106# define DECLARE_COMPLETION_ONSTACK(work) DECLARE_COMPLETION(work)
107#endif
108
109/**
110 * init_completion - Initialize a dynamically allocated completion
111 * @x: pointer to completion structure that is to be initialized
112 *
113 * This inline function will initialize a dynamically created completion
114 * structure.
115 */
116static inline void __init_completion(struct completion *x)
117{
118 x->done = 0;
119 init_waitqueue_head(&x->wait);
120}
121
122/**
123 * reinit_completion - reinitialize a completion structure
124 * @x: pointer to completion structure that is to be reinitialized
125 *
126 * This inline function should be used to reinitialize a completion structure so it can
127 * be reused. This is especially important after complete_all() is used.
128 */
129static inline void reinit_completion(struct completion *x)
130{
131 x->done = 0;
132}
133
134extern void wait_for_completion(struct completion *);
135extern void wait_for_completion_io(struct completion *);
136extern int wait_for_completion_interruptible(struct completion *x);
137extern int wait_for_completion_killable(struct completion *x);
138extern unsigned long wait_for_completion_timeout(struct completion *x,
139 unsigned long timeout);
140extern unsigned long wait_for_completion_io_timeout(struct completion *x,
141 unsigned long timeout);
142extern long wait_for_completion_interruptible_timeout(
143 struct completion *x, unsigned long timeout);
144extern long wait_for_completion_killable_timeout(
145 struct completion *x, unsigned long timeout);
146extern bool try_wait_for_completion(struct completion *x);
147extern bool completion_done(struct completion *x);
148
149extern void complete(struct completion *);
150extern void complete_all(struct completion *);
151
152#endif