1 #ifndef _LINUX_WAIT_H
2 #define _LINUX_WAIT_H
3
4 #define WNOHANG 0x00000001
5 #define WUNTRACED 0x00000002
6
7 #define __WNOTHREAD 0x20000000 /* Don't wait on children of other threads in this group */
8 #define __WALL 0x40000000 /* Wait on all children, regardless of type */
9 #define __WCLONE 0x80000000 /* Wait only on non-SIGCHLD children */
10
11 #ifdef __KERNEL__
12
13 #include <linux/kernel.h>
14 #include <linux/list.h>
15 #include <linux/stddef.h>
16 #include <linux/spinlock.h>
17
18 #include <asm/page.h>
19 #include <asm/processor.h>
20
21 /*
22 * Temporary debugging help until all code is converted to the new
23 * waitqueue usage.
24 */
25 #define WAITQUEUE_DEBUG 0
26
27 #if WAITQUEUE_DEBUG
28 extern int printk(const char *fmt, ...);
29 #define WQ_BUG() do { \
30 printk("wq bug, forcing oops.\n"); \
31 BUG(); \
32 } while (0)
33
34 #define CHECK_MAGIC(x) if (x != (long)&(x)) \
35 { printk("bad magic %lx (should be %lx), ", (long)x, (long)&(x)); WQ_BUG(); }
36
37 #define CHECK_MAGIC_WQHEAD(x) do { \
38 if (x->__magic != (long)&(x->__magic)) { \
39 printk("bad magic %lx (should be %lx, creator %lx), ", \
40 x->__magic, (long)&(x->__magic), x->__creator); \
41 WQ_BUG(); \
42 } \
43 } while (0)
44 #endif
45
46 struct __wait_queue {
47 unsigned int flags;
48 #define WQ_FLAG_EXCLUSIVE 0x01
49 struct task_struct * task;
50 struct list_head task_list;
51 #if WAITQUEUE_DEBUG
52 long __magic;
53 long __waker;
54 #endif
55 };
56 typedef struct __wait_queue wait_queue_t;
57
58 /*
59 * 'dual' spinlock architecture. Can be switched between spinlock_t and
60 * rwlock_t locks via changing this define. Since waitqueues are quite
61 * decoupled in the new architecture, lightweight 'simple' spinlocks give
62 * us slightly better latencies and smaller waitqueue structure size.
63 */
64 #define USE_RW_WAIT_QUEUE_SPINLOCK 0
65
66 #if USE_RW_WAIT_QUEUE_SPINLOCK
67 # define wq_lock_t rwlock_t
68 # define WAITQUEUE_RW_LOCK_UNLOCKED RW_LOCK_UNLOCKED
69
70 # define wq_read_lock read_lock
71 # define wq_read_lock_irqsave read_lock_irqsave
72 # define wq_read_unlock_irqrestore read_unlock_irqrestore
73 # define wq_read_unlock read_unlock
74 # define wq_write_lock_irq write_lock_irq
75 # define wq_write_lock_irqsave write_lock_irqsave
76 # define wq_write_unlock_irqrestore write_unlock_irqrestore
77 # define wq_write_unlock write_unlock
78 #else
79 # define wq_lock_t spinlock_t
80 # define WAITQUEUE_RW_LOCK_UNLOCKED SPIN_LOCK_UNLOCKED
81
82 # define wq_read_lock spin_lock
83 # define wq_read_lock_irqsave spin_lock_irqsave
84 # define wq_read_unlock spin_unlock
85 # define wq_read_unlock_irqrestore spin_unlock_irqrestore
86 # define wq_write_lock_irq spin_lock_irq
87 # define wq_write_lock_irqsave spin_lock_irqsave
88 # define wq_write_unlock_irqrestore spin_unlock_irqrestore
89 # define wq_write_unlock spin_unlock
90 #endif
91
92 struct __wait_queue_head {
93 wq_lock_t lock;
94 struct list_head task_list;
95 #if WAITQUEUE_DEBUG
96 long __magic;
97 long __creator;
98 #endif
99 };
100 typedef struct __wait_queue_head wait_queue_head_t;
101
102 #if WAITQUEUE_DEBUG
103 # define __WAITQUEUE_DEBUG_INIT(name) \
104 , (long)&(name).__magic, 0
105 # define __WAITQUEUE_HEAD_DEBUG_INIT(name) \
106 , (long)&(name).__magic, (long)&(name).__magic
107 #else
108 # define __WAITQUEUE_DEBUG_INIT(name)
109 # define __WAITQUEUE_HEAD_DEBUG_INIT(name)
110 #endif
111
112 #define __WAITQUEUE_INITIALIZER(name,task) \
113 { 0x0, task, { NULL, NULL } __WAITQUEUE_DEBUG_INIT(name)}
114 #define DECLARE_WAITQUEUE(name,task) \
115 wait_queue_t name = __WAITQUEUE_INITIALIZER(name,task)
116
117 #define __WAIT_QUEUE_HEAD_INITIALIZER(name) \
118 { WAITQUEUE_RW_LOCK_UNLOCKED, { &(name).task_list, &(name).task_list } \
119 __WAITQUEUE_HEAD_DEBUG_INIT(name)}
120
121 #define DECLARE_WAIT_QUEUE_HEAD(name) \
122 wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
123
124 static inline void init_waitqueue_head(wait_queue_head_t *q)
125 {
126 #if WAITQUEUE_DEBUG
127 if (!q)
128 WQ_BUG();
129 #endif
130 q->lock = WAITQUEUE_RW_LOCK_UNLOCKED;
131 INIT_LIST_HEAD(&q->task_list);
132 #if WAITQUEUE_DEBUG
133 q->__magic = (long)&q->__magic;
134 q->__creator = (long)current_text_addr();
135 #endif
136 }
137
138 static inline void init_waitqueue_entry(wait_queue_t *q,
139 struct task_struct *p)
140 {
141 #if WAITQUEUE_DEBUG
142 if (!q || !p)
143 WQ_BUG();
144 #endif
145 q->flags = 0;
146 q->task = p;
147 #if WAITQUEUE_DEBUG
148 q->__magic = (long)&q->__magic;
149 #endif
150 }
151
152 static inline int waitqueue_active(wait_queue_head_t *q)
153 {
154 #if WAITQUEUE_DEBUG
155 if (!q)
156 WQ_BUG();
157 CHECK_MAGIC_WQHEAD(q);
158 #endif
159
160 return !list_empty(&q->task_list);
161 }
162
163 static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
164 {
165 #if WAITQUEUE_DEBUG
166 if (!head || !new)
167 WQ_BUG();
168 CHECK_MAGIC_WQHEAD(head);
169 CHECK_MAGIC(new->__magic);
170 if (!head->task_list.next || !head->task_list.prev)
171 WQ_BUG();
172 #endif
173 list_add(&new->task_list, &head->task_list);
174 }
175
176 /*
177 * Used for wake-one threads:
178 */
179 static inline void __add_wait_queue_tail(wait_queue_head_t *head,
180 wait_queue_t *new)
181 {
182 #if WAITQUEUE_DEBUG
183 if (!head || !new)
184 WQ_BUG();
185 CHECK_MAGIC_WQHEAD(head);
186 CHECK_MAGIC(new->__magic);
187 if (!head->task_list.next || !head->task_list.prev)
188 WQ_BUG();
189 #endif
190 list_add_tail(&new->task_list, &head->task_list);
191 }
192
193 static inline void __remove_wait_queue(wait_queue_head_t *head,
194 wait_queue_t *old)
195 {
196 #if WAITQUEUE_DEBUG
197 if (!old)
198 WQ_BUG();
199 CHECK_MAGIC(old->__magic);
200 #endif
201 list_del(&old->task_list);
202 }
203
204 #endif /* __KERNEL__ */
205
206 #endif
207
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.