00676047d328949484dd86b772e2c73aad5b3f89
[dragonfly.git] / sys / sys / mutex2.h
1 /*
2  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34
35 #ifndef _SYS_MUTEX2_H_
36 #define _SYS_MUTEX2_H_
37
38 #ifndef _SYS_MUTEX_H_
39 #include <sys/mutex.h>
40 #endif
41 #ifndef _MACHINE_ATOMIC_H_
42 #include <machine/atomic.h>
43 #endif
44
45 /*
46  * Initialize a new mutex, placing it in an unlocked state with no refs.
47  */
48 static __inline void
49 mtx_init(mtx_t mtx)
50 {
51         mtx->mtx_lock = 0;
52         mtx->mtx_refs = 0;
53         mtx->mtx_owner = NULL;
54         mtx->mtx_link = NULL;
55 }
56
57 static __inline void
58 mtx_link_init(mtx_link_t link)
59 {
60         link->state = MTX_LINK_IDLE;
61 }
62
63 /*
64  * Deinitialize a mutex
65  */
66 static __inline void
67 mtx_uninit(mtx_t mtx)
68 {
69         /* empty */
70 }
71
72 /*
73  * Exclusive-lock a mutex, block until acquired or aborted.  Recursion
74  * is allowed.
75  *
76  * This version of the function allows the mtx_link to be passed in, thus
77  * giving the caller visibility for the link structure which is required
78  * when calling mtx_abort_ex_link().
79  *
80  * The mutex may be aborted at any time while the passed link structure
81  * is valid.
82  */
83 static __inline int
84 mtx_lock_ex_link(mtx_t mtx, struct mtx_link *link,
85                  const char *ident, int flags, int to)
86 {
87         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
88                 return(_mtx_lock_ex_link(mtx, link, ident, flags, to));
89         mtx->mtx_owner = curthread;
90         return(0);
91 }
92
93 /*
94  * Short-form exclusive-lock a mutex, block until acquired.  Recursion is
95  * allowed.  This is equivalent to mtx_lock_ex(mtx, "mtxex", 0, 0).
96  */
97 static __inline void
98 mtx_lock(mtx_t mtx)
99 {
100         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0) {
101                 _mtx_lock_ex(mtx, "mtxex", 0, 0);
102                 return;
103         }
104         mtx->mtx_owner = curthread;
105 }
106
107 /*
108  * Exclusive-lock a mutex, block until acquired.  Recursion is allowed.
109  *
110  * Returns 0 on success, or the tsleep() return code on failure.
111  * An error can only be returned if PCATCH is specified in the flags.
112  */
113 static __inline int
114 mtx_lock_ex(mtx_t mtx, const char *ident, int flags, int to)
115 {
116         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
117                 return(_mtx_lock_ex(mtx, ident, flags, to));
118         mtx->mtx_owner = curthread;
119         return(0);
120 }
121
122 static __inline int
123 mtx_lock_ex_quick(mtx_t mtx, const char *ident)
124 {
125         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
126                 return(_mtx_lock_ex_quick(mtx, ident));
127         mtx->mtx_owner = curthread;
128         return(0);
129 }
130
131 /*
132  * Share-lock a mutex, block until acquired.  Recursion is allowed.
133  *
134  * Returns 0 on success, or the tsleep() return code on failure.
135  * An error can only be returned if PCATCH is specified in the flags.
136  */
137 static __inline int
138 mtx_lock_sh(mtx_t mtx, const char *ident, int flags, int to)
139 {
140         if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
141                 return(_mtx_lock_sh(mtx, ident, flags, to));
142         return(0);
143 }
144
145 static __inline int
146 mtx_lock_sh_quick(mtx_t mtx, const char *ident)
147 {
148         if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
149                 return(_mtx_lock_sh_quick(mtx, ident));
150         return(0);
151 }
152
153 /*
154  * Short-form exclusive-lock a mutex, spin until acquired.  Recursion is
155  * allowed.  This form is identical to mtx_spinlock_ex().
156  */
157 static __inline void
158 mtx_spinlock(mtx_t mtx)
159 {
160         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
161                 _mtx_spinlock_ex(mtx);
162 }
163
164 /*
165  * Exclusive-lock a mutex, spin until acquired.  Recursion is allowed.
166  */
167 static __inline void
168 mtx_spinlock_ex(mtx_t mtx)
169 {
170         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
171                 _mtx_spinlock_ex(mtx);
172 }
173
174 /*
175  * Share-lock a mutex, spin until acquired.  Recursion is allowed.
176  */
177 static __inline void
178 mtx_spinlock_sh(mtx_t mtx)
179 {
180         if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
181                 _mtx_spinlock_sh(mtx);
182 }
183
184 /*
185  * Attempt to exclusive-lock a mutex, return 0 on success and
186  * EAGAIN on failure.
187  */
188 static __inline int
189 mtx_lock_ex_try(mtx_t mtx)
190 {
191         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
192                 return (_mtx_lock_ex_try(mtx));
193         mtx->mtx_owner = curthread;
194         return (0);
195 }
196
197 /*
198  * Attempt to share-lock a mutex, return 0 on success and
199  * EAGAIN on failure.
200  */
201 static __inline int
202 mtx_lock_sh_try(mtx_t mtx)
203 {
204         if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
205                 return (_mtx_lock_sh_try(mtx));
206         return (0);
207 }
208
209 /*
210  * If the lock is held exclusively it must be owned by the caller.  If the
211  * lock is already a shared lock this operation is a NOP.    A panic will
212  * occur if the lock is not held either shared or exclusive.
213  *
214  * The exclusive count is converted to a shared count.
215  */
216 static __inline void
217 mtx_downgrade(mtx_t mtx)
218 {
219         mtx->mtx_owner = NULL;
220         if (atomic_cmpset_int(&mtx->mtx_lock, MTX_EXCLUSIVE | 1, 0) == 0)
221                 _mtx_downgrade(mtx);
222 }
223
224 /*
225  * Upgrade a shared lock to an exclusive lock.  The upgrade will fail if
226  * the shared lock has a count other then 1.  Optimize the most likely case
227  * but note that a single cmpset can fail due to WANTED races.
228  *
229  * If the lock is held exclusively it must be owned by the caller and
230  * this function will simply return without doing anything.  A panic will
231  * occur if the lock is held exclusively by someone other then the caller.
232  *
233  * Returns 0 on success, EDEADLK on failure.
234  */
235 static __inline int
236 mtx_upgrade_try(mtx_t mtx)
237 {
238         if (atomic_cmpset_int(&mtx->mtx_lock, 1, MTX_EXCLUSIVE | 1))
239                 return(0);
240         return (_mtx_upgrade_try(mtx));
241 }
242
243 /*
244  * Optimized unlock cases.
245  *
246  * NOTE: mtx_unlock() handles any type of mutex: exclusive, shared, and
247  *       both blocking and spin methods.
248  *
249  *       The mtx_unlock_ex/sh() forms are optimized for exclusive or shared
250  *       mutexes and produce less code, but it is ok for code to just use
251  *       mtx_unlock() and, in fact, if code uses the short-form mtx_lock()
252  *       or mtx_spinlock() to lock it should also use mtx_unlock() to unlock.
253  */
254 static __inline void
255 mtx_unlock(mtx_t mtx)
256 {
257         u_int lock = mtx->mtx_lock;
258
259         if (lock == (MTX_EXCLUSIVE | 1)) {
260                 mtx->mtx_owner = NULL;
261                 if (atomic_cmpset_int(&mtx->mtx_lock, lock, 0) == 0)
262                         _mtx_unlock(mtx);
263         } else if (lock == 1) {
264                 if (atomic_cmpset_int(&mtx->mtx_lock, lock, 0) == 0)
265                         _mtx_unlock(mtx);
266         } else {
267                 _mtx_unlock(mtx);
268         }
269 }
270
271 static __inline void
272 mtx_unlock_ex(mtx_t mtx)
273 {
274         u_int lock = mtx->mtx_lock;
275
276         if (lock == (MTX_EXCLUSIVE | 1)) {
277                 mtx->mtx_owner = NULL;
278                 if (atomic_cmpset_int(&mtx->mtx_lock, lock, 0) == 0)
279                         _mtx_unlock(mtx);
280         } else {
281                 _mtx_unlock(mtx);
282         }
283 }
284
285 static __inline void
286 mtx_unlock_sh(mtx_t mtx)
287 {
288         if (atomic_cmpset_int(&mtx->mtx_lock, 1, 0) == 0)
289                 _mtx_unlock(mtx);
290 }
291
292 /*
293  * Return TRUE (non-zero) if the mutex is locked shared or exclusive by
294  * anyone, including the owner.
295  */
296 static __inline int
297 mtx_islocked(mtx_t mtx)
298 {
299         return(mtx->mtx_lock != 0);
300 }
301
302 /*
303  * Return TRUE (non-zero) if the mutex is locked exclusively by anyone,
304  * including the owner.
305  *
306  * The mutex may in an unlocked or shared lock state.
307  */
308 static __inline int
309 mtx_islocked_ex(mtx_t mtx)
310 {
311         return((mtx->mtx_lock & MTX_EXCLUSIVE) != 0);
312 }
313
314 /*
315  * Return TRUE (non-zero) if the mutex is not locked.
316  */
317 static __inline int
318 mtx_notlocked(mtx_t mtx)
319 {
320         return(mtx->mtx_lock == 0);
321 }
322
323 /*
324  * Return TRUE (non-zero) if the mutex is not locked exclusively.
325  * The mutex may in an unlocked or shared lock state.
326  */
327 static __inline int
328 mtx_notlocked_ex(mtx_t mtx)
329 {
330         return((mtx->mtx_lock & MTX_EXCLUSIVE) != 0);
331 }
332
333 /*
334  * Return TRUE (non-zero) if the mutex is exclusively locked by
335  * the caller.
336  */
337 static __inline int
338 mtx_owned(mtx_t mtx)
339 {
340         return((mtx->mtx_lock & MTX_EXCLUSIVE) && mtx->mtx_owner == curthread);
341 }
342
343 /*
344  * Return TRUE (non-zero) if the mutex is not exclusively locked by
345  * the caller.
346  */
347 static __inline int
348 mtx_notowned(mtx_t mtx)
349 {
350         return((mtx->mtx_lock & MTX_EXCLUSIVE) == 0 ||
351                mtx->mtx_owner != curthread);
352 }
353
354 /*
355  * Return the shared or exclusive lock count.  A return value of 0
356  * indicate that the mutex is not locked.
357  *
358  * NOTE: If the mutex is held exclusively by someone other then the
359  *       caller the lock count for the other owner is still returned.
360  */
361 static __inline int
362 mtx_lockrefs(mtx_t mtx)
363 {
364         return(mtx->mtx_lock & MTX_MASK);
365 }
366
367 /*
368  * Bump the lock's ref count.  This field is independent of the lock.
369  */
370 static __inline void
371 mtx_hold(mtx_t mtx)
372 {
373         atomic_add_acq_int(&mtx->mtx_refs, 1);
374 }
375
376 /*
377  * Drop the lock's ref count.  This field is independent of the lock.
378  *
379  * Returns the previous ref count, interlocked so testing against
380  * 1 means you won the 1->0 transition
381  */
382 static __inline int
383 mtx_drop(mtx_t mtx)
384 {
385         return (atomic_fetchadd_int(&mtx->mtx_refs, -1));
386 }
387
388 #endif