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 }
  55
  56 /*
  57  * Deinitialize a mutex
  58  */
  59 static __inline void
  60 mtx_uninit(mtx_t mtx)
  61 {
  62         /* empty */
  63 }
  64
  65 /*
  66  * Exclusive-lock a mutex, block until acquired.  Recursion is allowed.
  67  *
  68  * Returns 0 on success, or the tsleep() return code on failure.
  69  * An error can only be returned if PCATCH is specified in the flags.
  70  */
  71 static __inline int
  72 mtx_lock_ex(mtx_t mtx, const char *ident, int flags, int to)
  73 {
  74         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
  75                 return(_mtx_lock_ex(mtx, ident, flags, to));
  76         mtx->mtx_owner = curthread;
  77         return(0);
  78 }
  79
  80 static __inline int
  81 mtx_lock_ex_quick(mtx_t mtx, const char *ident)
  82 {
  83         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
  84                 return(_mtx_lock_ex_quick(mtx, ident));
  85         mtx->mtx_owner = curthread;
  86         return(0);
  87 }
  88
  89 /*
  90  * Share-lock a mutex, block until acquired.  Recursion is allowed.
  91  *
  92  * Returns 0 on success, or the tsleep() return code on failure.
  93  * An error can only be returned if PCATCH is specified in the flags.
  94  */
  95 static __inline int
  96 mtx_lock_sh(mtx_t mtx, const char *ident, int flags, int to)
  97 {
  98         if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
  99                 return(_mtx_lock_sh(mtx, ident, flags, to));
 100         return(0);
 101 }
 102
 103 static __inline int
 104 mtx_lock_sh_quick(mtx_t mtx, const char *ident)
 105 {
 106         if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
 107                 return(_mtx_lock_sh_quick(mtx, ident));
 108         return(0);
 109 }
 110
 111 /*
 112  * Exclusive-lock a mutex, spin until acquired.  Recursion is allowed.
 113  */
 114 static __inline void
 115 mtx_spinlock_ex(mtx_t mtx)
 116 {
 117         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
 118                 _mtx_spinlock_ex(mtx);
 119 }
 120
 121 /*
 122  * Share-lock a mutex, spin until acquired.  Recursion is allowed.
 123  */
 124 static __inline void
 125 mtx_spinlock_sh(mtx_t mtx)
 126 {
 127         if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
 128                 _mtx_spinlock_sh(mtx);
 129 }
 130
 131 /*
 132  * Attempt to exclusive-lock a mutex, return 0 on success and
 133  * EAGAIN on failure.
 134  */
 135 static __inline int
 136 mtx_lock_ex_try(mtx_t mtx)
 137 {
 138         if (atomic_cmpset_int(&mtx->mtx_lock, 0, MTX_EXCLUSIVE | 1) == 0)
 139                 return (_mtx_lock_ex_try(mtx));
 140         mtx->mtx_owner = curthread;
 141         return (0);
 142 }
 143
 144 /*
 145  * Attempt to share-lock a mutex, return 0 on success and
 146  * EAGAIN on failure.
 147  */
 148 static __inline int
 149 mtx_lock_sh_try(mtx_t mtx)
 150 {
 151         if (atomic_cmpset_int(&mtx->mtx_lock, 0, 1) == 0)
 152                 return (_mtx_lock_sh_try(mtx));
 153         return (0);
 154 }
 155
 156 /*
 157  * If the lock is held exclusively it must be owned by the caller.  If the
 158  * lock is already a shared lock this operation is a NOP.    A panic will
 159  * occur if the lock is not held either shared or exclusive.
 160  *
 161  * The exclusive count is converted to a shared count.
 162  */
 163 static __inline void
 164 mtx_downgrade(mtx_t mtx)
 165 {
 166         mtx->mtx_owner = NULL;
 167         if (atomic_cmpset_int(&mtx->mtx_lock, MTX_EXCLUSIVE | 1, 0) == 0)
 168                 _mtx_downgrade(mtx);
 169 }
 170
 171 /*
 172  * Upgrade a shared lock to an exclusive lock.  The upgrade will fail if
 173  * the shared lock has a count other then 1.  Optimize the most likely case
 174  * but note that a single cmpset can fail due to WANTED races.
 175  *
 176  * If the lock is held exclusively it must be owned by the caller and
 177  * this function will simply return without doing anything.  A panic will
 178  * occur if the lock is held exclusively by someone other then the caller.
 179  *
 180  * Returns 0 on success, EDEADLK on failure.
 181  */
 182 static __inline int
 183 mtx_upgrade_try(mtx_t mtx)
 184 {
 185         if (atomic_cmpset_int(&mtx->mtx_lock, 1, MTX_EXCLUSIVE | 1))
 186                 return(0);
 187         return (_mtx_upgrade_try(mtx));
 188 }
 189
 190 /*
 191  * Optimized unlock cases.
 192  */
 193 static __inline void
 194 mtx_unlock(mtx_t mtx)
 195 {
 196         u_int lock = mtx->mtx_lock;
 197
 198         if (lock == (MTX_EXCLUSIVE | 1)) {
 199                 mtx->mtx_owner = NULL;
 200                 if (atomic_cmpset_int(&mtx->mtx_lock, lock, 0) == 0)
 201                         _mtx_unlock(mtx);
 202         } else if (lock == 1) {
 203                 if (atomic_cmpset_int(&mtx->mtx_lock, lock, 0) == 0)
 204                         _mtx_unlock(mtx);
 205         } else {
 206                 _mtx_unlock(mtx);
 207         }
 208 }
 209
 210 static __inline void
 211 mtx_unlock_ex(mtx_t mtx)
 212 {
 213         u_int lock = mtx->mtx_lock;
 214
 215         if (lock == (MTX_EXCLUSIVE | 1)) {
 216                 mtx->mtx_owner = NULL;
 217                 if (atomic_cmpset_int(&mtx->mtx_lock, lock, 0) == 0)
 218                         _mtx_unlock(mtx);
 219         } else {
 220                 _mtx_unlock(mtx);
 221         }
 222 }
 223
 224 static __inline void
 225 mtx_unlock_sh(mtx_t mtx)
 226 {
 227         if (atomic_cmpset_int(&mtx->mtx_lock, 1, 0) == 0)
 228                 _mtx_unlock(mtx);
 229 }
 230
 231 /*
 232  * Return TRUE (non-zero) if the mutex is locked shared or exclusive by
 233  * anyone, including the owner.
 234  */
 235 static __inline int
 236 mtx_islocked(mtx_t mtx)
 237 {
 238         return(mtx->mtx_lock != 0);
 239 }
 240
 241 /*
 242  * Return TRUE (non-zero) if the mutex is locked exclusively by anyone,
 243  * including the owner.
 244  *
 245  * The mutex may in an unlocked or shared lock state.
 246  */
 247 static __inline int
 248 mtx_islocked_ex(mtx_t mtx)
 249 {
 250         return((mtx->mtx_lock & MTX_EXCLUSIVE) != 0);
 251 }
 252
 253 /*
 254  * Return TRUE (non-zero) if the mutex is not locked.
 255  */
 256 static __inline int
 257 mtx_notlocked(mtx_t mtx)
 258 {
 259         return(mtx->mtx_lock == 0);
 260 }
 261
 262 /*
 263  * Return TRUE (non-zero) if the mutex is not locked exclusively.
 264  * The mutex may in an unlocked or shared lock state.
 265  */
 266 static __inline int
 267 mtx_notlocked_ex(mtx_t mtx)
 268 {
 269         return((mtx->mtx_lock & MTX_EXCLUSIVE) != 0);
 270 }
 271
 272 /*
 273  * Return TRUE (non-zero) if the mutex is exclusively locked by
 274  * the caller.
 275  */
 276 static __inline int
 277 mtx_owned(mtx_t mtx)
 278 {
 279         return((mtx->mtx_lock & MTX_EXCLUSIVE) && mtx->mtx_owner == curthread);
 280 }
 281
 282 /*
 283  * Return TRUE (non-zero) if the mutex is not exclusively locked by
 284  * the caller.
 285  */
 286 static __inline int
 287 mtx_notowned(mtx_t mtx)
 288 {
 289         return((mtx->mtx_lock & MTX_EXCLUSIVE) == 0 ||
 290                mtx->mtx_owner != curthread);
 291 }
 292
 293 /*
 294  * Return the shared or exclusive lock count.  A return value of 0
 295  * indicate that the mutex is not locked.
 296  *
 297  * NOTE: If the mutex is held exclusively by someone other then the
 298  *       caller the lock count for the other owner is still returned.
 299  */
 300 static __inline int
 301 mtx_lockrefs(mtx_t mtx)
 302 {
 303         return(mtx->mtx_lock & MTX_MASK);
 304 }
 305
 306 /*
 307  * Bump the lock's ref count.  This field is independent of the lock.
 308  */
 309 static __inline void
 310 mtx_hold(mtx_t mtx)
 311 {
 312         atomic_add_acq_int(&mtx->mtx_refs, 1);
 313 }
 314
 315 /*
 316  * Drop the lock's ref count.  This field is independent of the lock.
 317  *
 318  * Returns the previous ref count, interlocked so testing against
 319  * 1 means you won the 1->0 transition
 320  */
 321 static __inline int
 322 mtx_drop(mtx_t mtx)
 323 {
 324         return (atomic_fetchadd_int(&mtx->mtx_refs, -1));
 325 }
 326
 327 #endif