1 /*
2 * linux/include/asm-arm/semaphore.h
3 */
4 #ifndef __ASM_ARM_SEMAPHORE_H
5 #define __ASM_ARM_SEMAPHORE_H
6
7 #include <linux/linkage.h>
8 #include <linux/spinlock.h>
9 #include <linux/wait.h>
10
11 #include <asm/atomic.h>
12 #include <asm/proc/locks.h>
13
14 struct semaphore {
15 atomic_t count;
16 int sleepers;
17 wait_queue_head_t wait;
18 #if WAITQUEUE_DEBUG
19 long __magic;
20 #endif
21 };
22
23 #if WAITQUEUE_DEBUG
24 # define __SEM_DEBUG_INIT(name) \
25 , (long)&(name).__magic
26 #else
27 # define __SEM_DEBUG_INIT(name)
28 #endif
29
30 #define __SEMAPHORE_INIT(name,count) \
31 { ATOMIC_INIT(count), 0, \
32 __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
33 __SEM_DEBUG_INIT(name) }
34
35 #define __MUTEX_INITIALIZER(name) \
36 __SEMAPHORE_INIT(name,1)
37
38 #define __DECLARE_SEMAPHORE_GENERIC(name,count) \
39 struct semaphore name = __SEMAPHORE_INIT(name,count)
40
41 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
42 #define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
43
44 extern inline void sema_init(struct semaphore *sem, int val)
45 {
46 atomic_set(&sem->count, val);
47 sem->sleepers = 0;
48 init_waitqueue_head(&sem->wait);
49 #if WAITQUEUE_DEBUG
50 sem->__magic = (long)&sem->__magic;
51 #endif
52 }
53
54 static inline void init_MUTEX(struct semaphore *sem)
55 {
56 sema_init(sem, 1);
57 }
58
59 static inline void init_MUTEX_LOCKED(struct semaphore *sem)
60 {
61 sema_init(sem, 0);
62 }
63
64 /*
65 * special register calling convention
66 */
67 asmlinkage void __down_failed(void);
68 asmlinkage int __down_interruptible_failed(void);
69 asmlinkage int __down_trylock_failed(void);
70 asmlinkage void __up_wakeup(void);
71
72 extern void __down(struct semaphore * sem);
73 extern int __down_interruptible(struct semaphore * sem);
74 extern int __down_trylock(struct semaphore * sem);
75 extern void __up(struct semaphore * sem);
76
77 /*
78 * This is ugly, but we want the default case to fall through.
79 * "__down" is the actual routine that waits...
80 */
81 extern inline void down(struct semaphore * sem)
82 {
83 #if WAITQUEUE_DEBUG
84 CHECK_MAGIC(sem->__magic);
85 #endif
86
87 __down_op(sem, __down_failed);
88 }
89
90 /*
91 * This is ugly, but we want the default case to fall through.
92 * "__down_interruptible" is the actual routine that waits...
93 */
94 extern inline int down_interruptible (struct semaphore * sem)
95 {
96 #if WAITQUEUE_DEBUG
97 CHECK_MAGIC(sem->__magic);
98 #endif
99
100 return __down_op_ret(sem, __down_interruptible_failed);
101 }
102
103 extern inline int down_trylock(struct semaphore *sem)
104 {
105 #if WAITQUEUE_DEBUG
106 CHECK_MAGIC(sem->__magic);
107 #endif
108
109 return __down_op_ret(sem, __down_trylock_failed);
110 }
111
112 /*
113 * Note! This is subtle. We jump to wake people up only if
114 * the semaphore was negative (== somebody was waiting on it).
115 * The default case (no contention) will result in NO
116 * jumps for both down() and up().
117 */
118 extern inline void up(struct semaphore * sem)
119 {
120 #if WAITQUEUE_DEBUG
121 CHECK_MAGIC(sem->__magic);
122 #endif
123
124 __up_op(sem, __up_wakeup);
125 }
126
127 /* rw mutexes (should that be mutices? =) -- throw rw
128 * spinlocks and semaphores together, and this is what we
129 * end up with...
130 *
131 * The lock is initialized to BIAS. This way, a writer
132 * subtracts BIAS ands gets 0 for the case of an uncontended
133 * lock. Readers decrement by 1 and see a positive value
134 * when uncontended, negative if there are writers waiting
135 * (in which case it goes to sleep).
136 *
137 * In terms of fairness, this should result in the lock
138 * flopping back and forth between readers and writers
139 * under heavy use.
140 *
141 * -ben
142 */
143 struct rw_semaphore {
144 atomic_t count;
145 volatile unsigned char write_bias_granted;
146 volatile unsigned char read_bias_granted;
147 volatile unsigned char pad1;
148 volatile unsigned char pad2;
149 wait_queue_head_t wait;
150 wait_queue_head_t write_bias_wait;
151 #if WAITQUEUE_DEBUG
152 long __magic;
153 atomic_t readers;
154 atomic_t writers;
155 #endif
156 };
157
158 #if WAITQUEUE_DEBUG
159 #define __RWSEM_DEBUG_INIT , ATOMIC_INIT(0), ATOMIC_INIT(0)
160 #else
161 #define __RWSEM_DEBUG_INIT /* */
162 #endif
163
164 #define __RWSEM_INITIALIZER(name,count) \
165 { ATOMIC_INIT(count), 0, 0, 0, 0, __WAIT_QUEUE_HEAD_INITIALIZER((name).wait), \
166 __WAIT_QUEUE_HEAD_INITIALIZER((name).write_bias_wait) \
167 __SEM_DEBUG_INIT(name) __RWSEM_DEBUG_INIT }
168
169 #define __DECLARE_RWSEM_GENERIC(name,count) \
170 struct rw_semaphore name = __RWSEM_INITIALIZER(name,count)
171
172 #define DECLARE_RWSEM(name) __DECLARE_RWSEM_GENERIC(name,RW_LOCK_BIAS)
173 #define DECLARE_RWSEM_READ_LOCKED(name) __DECLARE_RWSEM_GENERIC(name,RW_LOCK_BIAS-1)
174 #define DECLARE_RWSEM_WRITE_LOCKED(name) __DECLARE_RWSEM_GENERIC(name,0)
175
176 extern inline void init_rwsem(struct rw_semaphore *sem)
177 {
178 atomic_set(&sem->count, RW_LOCK_BIAS);
179 sem->read_bias_granted = 0;
180 sem->write_bias_granted = 0;
181 init_waitqueue_head(&sem->wait);
182 init_waitqueue_head(&sem->write_bias_wait);
183 #if WAITQUEUE_DEBUG
184 sem->__magic = (long)&sem->__magic;
185 atomic_set(&sem->readers, 0);
186 atomic_set(&sem->writers, 0);
187 #endif
188 }
189
190 extern struct rw_semaphore *__down_read_failed(struct rw_semaphore *sem);
191 extern struct rw_semaphore *__down_write_failed(struct rw_semaphore *sem);
192 extern struct rw_semaphore *__rwsem_wake(struct rw_semaphore *sem);
193
194 extern inline void down_read(struct rw_semaphore *sem)
195 {
196 #if WAITQUEUE_DEBUG
197 CHECK_MAGIC(sem->__magic);
198 #endif
199 __down_op_read(sem, __down_read_failed);
200 #if WAITQUEUE_DEBUG
201 if (sem->write_bias_granted)
202 BUG();
203 if (atomic_read(&sem->writers))
204 BUG();
205 atomic_inc(&sem->readers);
206 #endif
207 }
208
209 extern inline void down_write(struct rw_semaphore *sem)
210 {
211 #if WAITQUEUE_DEBUG
212 CHECK_MAGIC(sem->__magic);
213 #endif
214 __down_op_write(sem, __down_write_failed);
215 #if WAITQUEUE_DEBUG
216 if (atomic_read(&sem->writers))
217 BUG();
218 if (atomic_read(&sem->readers))
219 BUG();
220 if (sem->read_bias_granted)
221 BUG();
222 if (sem->write_bias_granted)
223 BUG();
224 atomic_inc(&sem->writers);
225 #endif
226 }
227
228 extern inline void up_read(struct rw_semaphore *sem)
229 {
230 #if WAITQUEUE_DEBUG
231 if (sem->write_bias_granted)
232 BUG();
233 if (atomic_read(&sem->writers))
234 BUG();
235 atomic_dec(&sem->readers);
236 #endif
237 __up_op_read(sem, __rwsem_wake);
238 }
239
240 extern inline void up_write(struct rw_semaphore *sem)
241 {
242 #if WAITQUEUE_DEBUG
243 if (sem->read_bias_granted)
244 BUG();
245 if (sem->write_bias_granted)
246 BUG();
247 if (atomic_read(&sem->readers))
248 BUG();
249 if (atomic_read(&sem->writers) != 1)
250 BUG();
251 atomic_dec(&sem->writers);
252 #endif
253 __up_op_write(sem, __rwsem_wake);
254 }
255
256 #endif
257
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.