[PATCH] add sem_is_read/write_locked()
[linux-2.6.git] / include / asm-s390 / rwsem.h
1 #ifndef _S390_RWSEM_H
2 #define _S390_RWSEM_H
3
4 /*
5  *  include/asm-s390/rwsem.h
6  *
7  *  S390 version
8  *    Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
9  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
10  *
11  *  Based on asm-alpha/semaphore.h and asm-i386/rwsem.h
12  */
13
14 /*
15  *
16  * The MSW of the count is the negated number of active writers and waiting
17  * lockers, and the LSW is the total number of active locks
18  *
19  * The lock count is initialized to 0 (no active and no waiting lockers).
20  *
21  * When a writer subtracts WRITE_BIAS, it'll get 0xffff0001 for the case of an
22  * uncontended lock. This can be determined because XADD returns the old value.
23  * Readers increment by 1 and see a positive value when uncontended, negative
24  * if there are writers (and maybe) readers waiting (in which case it goes to
25  * sleep).
26  *
27  * The value of WAITING_BIAS supports up to 32766 waiting processes. This can
28  * be extended to 65534 by manually checking the whole MSW rather than relying
29  * on the S flag.
30  *
31  * The value of ACTIVE_BIAS supports up to 65535 active processes.
32  *
33  * This should be totally fair - if anything is waiting, a process that wants a
34  * lock will go to the back of the queue. When the currently active lock is
35  * released, if there's a writer at the front of the queue, then that and only
36  * that will be woken up; if there's a bunch of consequtive readers at the
37  * front, then they'll all be woken up, but no other readers will be.
38  */
39
40 #ifndef _LINUX_RWSEM_H
41 #error "please don't include asm/rwsem.h directly, use linux/rwsem.h instead"
42 #endif
43
44 #ifdef __KERNEL__
45
46 #include <linux/list.h>
47 #include <linux/spinlock.h>
48
49 struct rwsem_waiter;
50
51 extern struct rw_semaphore *rwsem_down_read_failed(struct rw_semaphore *);
52 extern struct rw_semaphore *rwsem_down_write_failed(struct rw_semaphore *);
53 extern struct rw_semaphore *rwsem_wake(struct rw_semaphore *);
54 extern struct rw_semaphore *rwsem_downgrade_wake(struct rw_semaphore *);
55 extern struct rw_semaphore *rwsem_downgrade_write(struct rw_semaphore *);
56
57 /*
58  * the semaphore definition
59  */
60 struct rw_semaphore {
61         signed long             count;
62         spinlock_t              wait_lock;
63         struct list_head        wait_list;
64 };
65
66 #ifndef __s390x__
67 #define RWSEM_UNLOCKED_VALUE    0x00000000
68 #define RWSEM_ACTIVE_BIAS       0x00000001
69 #define RWSEM_ACTIVE_MASK       0x0000ffff
70 #define RWSEM_WAITING_BIAS      (-0x00010000)
71 #else /* __s390x__ */
72 #define RWSEM_UNLOCKED_VALUE    0x0000000000000000L
73 #define RWSEM_ACTIVE_BIAS       0x0000000000000001L
74 #define RWSEM_ACTIVE_MASK       0x00000000ffffffffL
75 #define RWSEM_WAITING_BIAS      (-0x0000000100000000L)
76 #endif /* __s390x__ */
77 #define RWSEM_ACTIVE_READ_BIAS  RWSEM_ACTIVE_BIAS
78 #define RWSEM_ACTIVE_WRITE_BIAS (RWSEM_WAITING_BIAS + RWSEM_ACTIVE_BIAS)
79
80 /*
81  * initialisation
82  */
83 #define __RWSEM_INITIALIZER(name) \
84 { RWSEM_UNLOCKED_VALUE, SPIN_LOCK_UNLOCKED, LIST_HEAD_INIT((name).wait_list) }
85
86 #define DECLARE_RWSEM(name) \
87         struct rw_semaphore name = __RWSEM_INITIALIZER(name)
88
89 static inline void init_rwsem(struct rw_semaphore *sem)
90 {
91         sem->count = RWSEM_UNLOCKED_VALUE;
92         spin_lock_init(&sem->wait_lock);
93         INIT_LIST_HEAD(&sem->wait_list);
94 }
95
96 /*
97  * lock for reading
98  */
99 static inline void __down_read(struct rw_semaphore *sem)
100 {
101         signed long old, new;
102
103         __asm__ __volatile__(
104 #ifndef __s390x__
105                 "   l    %0,0(%3)\n"
106                 "0: lr   %1,%0\n"
107                 "   ahi  %1,%5\n"
108                 "   cs   %0,%1,0(%3)\n"
109                 "   jl   0b"
110 #else /* __s390x__ */
111                 "   lg   %0,0(%3)\n"
112                 "0: lgr  %1,%0\n"
113                 "   aghi %1,%5\n"
114                 "   csg  %0,%1,0(%3)\n"
115                 "   jl   0b"
116 #endif /* __s390x__ */
117                 : "=&d" (old), "=&d" (new), "=m" (sem->count)
118                 : "a" (&sem->count), "m" (sem->count),
119                   "i" (RWSEM_ACTIVE_READ_BIAS) : "cc", "memory" );
120         if (old < 0)
121                 rwsem_down_read_failed(sem);
122 }
123
124 /*
125  * trylock for reading -- returns 1 if successful, 0 if contention
126  */
127 static inline int __down_read_trylock(struct rw_semaphore *sem)
128 {
129         signed long old, new;
130
131         __asm__ __volatile__(
132 #ifndef __s390x__
133                 "   l    %0,0(%3)\n"
134                 "0: ltr  %1,%0\n"
135                 "   jm   1f\n"
136                 "   ahi  %1,%5\n"
137                 "   cs   %0,%1,0(%3)\n"
138                 "   jl   0b\n"
139                 "1:"
140 #else /* __s390x__ */
141                 "   lg   %0,0(%3)\n"
142                 "0: ltgr %1,%0\n"
143                 "   jm   1f\n"
144                 "   aghi %1,%5\n"
145                 "   csg  %0,%1,0(%3)\n"
146                 "   jl   0b\n"
147                 "1:"
148 #endif /* __s390x__ */
149                 : "=&d" (old), "=&d" (new), "=m" (sem->count)
150                 : "a" (&sem->count), "m" (sem->count),
151                   "i" (RWSEM_ACTIVE_READ_BIAS) : "cc", "memory" );
152         return old >= 0 ? 1 : 0;
153 }
154
155 /*
156  * lock for writing
157  */
158 static inline void __down_write(struct rw_semaphore *sem)
159 {
160         signed long old, new, tmp;
161
162         tmp = RWSEM_ACTIVE_WRITE_BIAS;
163         __asm__ __volatile__(
164 #ifndef __s390x__
165                 "   l    %0,0(%3)\n"
166                 "0: lr   %1,%0\n"
167                 "   a    %1,%5\n"
168                 "   cs   %0,%1,0(%3)\n"
169                 "   jl   0b"
170 #else /* __s390x__ */
171                 "   lg   %0,0(%3)\n"
172                 "0: lgr  %1,%0\n"
173                 "   ag   %1,%5\n"
174                 "   csg  %0,%1,0(%3)\n"
175                 "   jl   0b"
176 #endif /* __s390x__ */
177                 : "=&d" (old), "=&d" (new), "=m" (sem->count)
178                 : "a" (&sem->count), "m" (sem->count), "m" (tmp)
179                 : "cc", "memory" );
180         if (old != 0)
181                 rwsem_down_write_failed(sem);
182 }
183
184 /*
185  * trylock for writing -- returns 1 if successful, 0 if contention
186  */
187 static inline int __down_write_trylock(struct rw_semaphore *sem)
188 {
189         signed long old;
190
191         __asm__ __volatile__(
192 #ifndef __s390x__
193                 "   l    %0,0(%2)\n"
194                 "0: ltr  %0,%0\n"
195                 "   jnz  1f\n"
196                 "   cs   %0,%4,0(%2)\n"
197                 "   jl   0b\n"
198 #else /* __s390x__ */
199                 "   lg   %0,0(%2)\n"
200                 "0: ltgr %0,%0\n"
201                 "   jnz  1f\n"
202                 "   csg  %0,%4,0(%2)\n"
203                 "   jl   0b\n"
204 #endif /* __s390x__ */
205                 "1:"
206                 : "=&d" (old), "=m" (sem->count)
207                 : "a" (&sem->count), "m" (sem->count),
208                   "d" (RWSEM_ACTIVE_WRITE_BIAS) : "cc", "memory" );
209         return (old == RWSEM_UNLOCKED_VALUE) ? 1 : 0;
210 }
211
212 /*
213  * unlock after reading
214  */
215 static inline void __up_read(struct rw_semaphore *sem)
216 {
217         signed long old, new;
218
219         __asm__ __volatile__(
220 #ifndef __s390x__
221                 "   l    %0,0(%3)\n"
222                 "0: lr   %1,%0\n"
223                 "   ahi  %1,%5\n"
224                 "   cs   %0,%1,0(%3)\n"
225                 "   jl   0b"
226 #else /* __s390x__ */
227                 "   lg   %0,0(%3)\n"
228                 "0: lgr  %1,%0\n"
229                 "   aghi %1,%5\n"
230                 "   csg  %0,%1,0(%3)\n"
231                 "   jl   0b"
232 #endif /* __s390x__ */
233                 : "=&d" (old), "=&d" (new), "=m" (sem->count)
234                 : "a" (&sem->count), "m" (sem->count),
235                   "i" (-RWSEM_ACTIVE_READ_BIAS)
236                 : "cc", "memory" );
237         if (new < 0)
238                 if ((new & RWSEM_ACTIVE_MASK) == 0)
239                         rwsem_wake(sem);
240 }
241
242 /*
243  * unlock after writing
244  */
245 static inline void __up_write(struct rw_semaphore *sem)
246 {
247         signed long old, new, tmp;
248
249         tmp = -RWSEM_ACTIVE_WRITE_BIAS;
250         __asm__ __volatile__(
251 #ifndef __s390x__
252                 "   l    %0,0(%3)\n"
253                 "0: lr   %1,%0\n"
254                 "   a    %1,%5\n"
255                 "   cs   %0,%1,0(%3)\n"
256                 "   jl   0b"
257 #else /* __s390x__ */
258                 "   lg   %0,0(%3)\n"
259                 "0: lgr  %1,%0\n"
260                 "   ag   %1,%5\n"
261                 "   csg  %0,%1,0(%3)\n"
262                 "   jl   0b"
263 #endif /* __s390x__ */
264                 : "=&d" (old), "=&d" (new), "=m" (sem->count)
265                 : "a" (&sem->count), "m" (sem->count), "m" (tmp)
266                 : "cc", "memory" );
267         if (new < 0)
268                 if ((new & RWSEM_ACTIVE_MASK) == 0)
269                         rwsem_wake(sem);
270 }
271
272 /*
273  * downgrade write lock to read lock
274  */
275 static inline void __downgrade_write(struct rw_semaphore *sem)
276 {
277         signed long old, new, tmp;
278
279         tmp = -RWSEM_WAITING_BIAS;
280         __asm__ __volatile__(
281 #ifndef __s390x__
282                 "   l    %0,0(%3)\n"
283                 "0: lr   %1,%0\n"
284                 "   a    %1,%5\n"
285                 "   cs   %0,%1,0(%3)\n"
286                 "   jl   0b"
287 #else /* __s390x__ */
288                 "   lg   %0,0(%3)\n"
289                 "0: lgr  %1,%0\n"
290                 "   ag   %1,%5\n"
291                 "   csg  %0,%1,0(%3)\n"
292                 "   jl   0b"
293 #endif /* __s390x__ */
294                 : "=&d" (old), "=&d" (new), "=m" (sem->count)
295                 : "a" (&sem->count), "m" (sem->count), "m" (tmp)
296                 : "cc", "memory" );
297         if (new > 1)
298                 rwsem_downgrade_wake(sem);
299 }
300
301 /*
302  * implement atomic add functionality
303  */
304 static inline void rwsem_atomic_add(long delta, struct rw_semaphore *sem)
305 {
306         signed long old, new;
307
308         __asm__ __volatile__(
309 #ifndef __s390x__
310                 "   l    %0,0(%3)\n"
311                 "0: lr   %1,%0\n"
312                 "   ar   %1,%5\n"
313                 "   cs   %0,%1,0(%3)\n"
314                 "   jl   0b"
315 #else /* __s390x__ */
316                 "   lg   %0,0(%3)\n"
317                 "0: lgr  %1,%0\n"
318                 "   agr  %1,%5\n"
319                 "   csg  %0,%1,0(%3)\n"
320                 "   jl   0b"
321 #endif /* __s390x__ */
322                 : "=&d" (old), "=&d" (new), "=m" (sem->count)
323                 : "a" (&sem->count), "m" (sem->count), "d" (delta)
324                 : "cc", "memory" );
325 }
326
327 /*
328  * implement exchange and add functionality
329  */
330 static inline long rwsem_atomic_update(long delta, struct rw_semaphore *sem)
331 {
332         signed long old, new;
333
334         __asm__ __volatile__(
335 #ifndef __s390x__
336                 "   l    %0,0(%3)\n"
337                 "0: lr   %1,%0\n"
338                 "   ar   %1,%5\n"
339                 "   cs   %0,%1,0(%3)\n"
340                 "   jl   0b"
341 #else /* __s390x__ */
342                 "   lg   %0,0(%3)\n"
343                 "0: lgr  %1,%0\n"
344                 "   agr  %1,%5\n"
345                 "   csg  %0,%1,0(%3)\n"
346                 "   jl   0b"
347 #endif /* __s390x__ */
348                 : "=&d" (old), "=&d" (new), "=m" (sem->count)
349                 : "a" (&sem->count), "m" (sem->count), "d" (delta)
350                 : "cc", "memory" );
351         return new;
352 }
353
354 static inline int rwsem_is_locked(struct rw_semaphore *sem)
355 {
356         return (sem->count != 0);
357 }
358
359 #endif /* __KERNEL__ */
360 #endif /* _S390_RWSEM_H */