1/*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2005 David Xu <davidxu@freebsd.org> 5 * All rights reserved. 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 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD$ 29 */ 30 31#ifndef _THR_FBSD_UMTX_H_ 32#define _THR_FBSD_UMTX_H_ 33 34#include <strings.h> 35#include <sys/umtx.h> 36 37#ifdef __LP64__ 38#define DEFAULT_UMUTEX {0,0,{0,0},0,{0,0}} 39#else 40#define DEFAULT_UMUTEX {0,0,{0,0},0,0,{0,0}} 41#endif 42#define DEFAULT_URWLOCK {0,0,0,0,{0,0,0,0}} 43 44int _umtx_op_err(void *, int op, u_long, void *, void *) __hidden; 45int __thr_umutex_lock(struct umutex *mtx, uint32_t id) __hidden; 46int __thr_umutex_lock_spin(struct umutex *mtx, uint32_t id) __hidden; 47int __thr_umutex_timedlock(struct umutex *mtx, uint32_t id, 48 const struct timespec *timeout) __hidden; 49int __thr_umutex_unlock(struct umutex *mtx) __hidden; 50int __thr_umutex_trylock(struct umutex *mtx) __hidden; 51int __thr_umutex_set_ceiling(struct umutex *mtx, uint32_t ceiling, 52 uint32_t *oldceiling) __hidden; 53 54void _thr_umutex_init(struct umutex *mtx) __hidden; 55void _thr_urwlock_init(struct urwlock *rwl) __hidden; 56 57int _thr_umtx_wait(volatile long *mtx, long exp, 58 const struct timespec *timeout) __hidden; 59int _thr_umtx_wait_uint(volatile u_int *mtx, u_int exp, 60 const struct timespec *timeout, int shared) __hidden; 61int _thr_umtx_timedwait_uint(volatile u_int *mtx, u_int exp, int clockid, 62 const struct timespec *timeout, int shared) __hidden; 63int _thr_umtx_wake(volatile void *mtx, int count, int shared) __hidden; 64int _thr_ucond_wait(struct ucond *cv, struct umutex *m, 65 const struct timespec *timeout, int flags) __hidden; 66void _thr_ucond_init(struct ucond *cv) __hidden; 67int _thr_ucond_signal(struct ucond *cv) __hidden; 68int _thr_ucond_broadcast(struct ucond *cv) __hidden; 69 70int __thr_rwlock_rdlock(struct urwlock *rwlock, int flags, 71 const struct timespec *tsp) __hidden; 72int __thr_rwlock_wrlock(struct urwlock *rwlock, 73 const struct timespec *tsp) __hidden; 74int __thr_rwlock_unlock(struct urwlock *rwlock) __hidden; 75 76/* Internal used only */ 77void _thr_rwl_rdlock(struct urwlock *rwlock) __hidden; 78void _thr_rwl_wrlock(struct urwlock *rwlock) __hidden; 79void _thr_rwl_unlock(struct urwlock *rwlock) __hidden; 80 81static inline int 82_thr_umutex_trylock(struct umutex *mtx, uint32_t id) 83{ 84 85 if (atomic_cmpset_acq_32(&mtx->m_owner, UMUTEX_UNOWNED, id)) 86 return (0); 87 if (__predict_false((uint32_t)mtx->m_owner == UMUTEX_RB_OWNERDEAD) && 88 atomic_cmpset_acq_32(&mtx->m_owner, UMUTEX_RB_OWNERDEAD, 89 id | UMUTEX_CONTESTED)) 90 return (EOWNERDEAD); 91 if (__predict_false((uint32_t)mtx->m_owner == UMUTEX_RB_NOTRECOV)) 92 return (ENOTRECOVERABLE); 93 if ((mtx->m_flags & UMUTEX_PRIO_PROTECT) == 0) 94 return (EBUSY); 95 return (__thr_umutex_trylock(mtx)); 96} 97 98static inline int 99_thr_umutex_trylock2(struct umutex *mtx, uint32_t id) 100{ 101 102 if (atomic_cmpset_acq_32(&mtx->m_owner, UMUTEX_UNOWNED, id) != 0) 103 return (0); 104 if ((uint32_t)mtx->m_owner == UMUTEX_CONTESTED && 105 __predict_true((mtx->m_flags & (UMUTEX_PRIO_PROTECT | 106 UMUTEX_PRIO_INHERIT)) == 0) && 107 atomic_cmpset_acq_32(&mtx->m_owner, UMUTEX_CONTESTED, 108 id | UMUTEX_CONTESTED)) 109 return (0); 110 if (__predict_false((uint32_t)mtx->m_owner == UMUTEX_RB_OWNERDEAD) && 111 atomic_cmpset_acq_32(&mtx->m_owner, UMUTEX_RB_OWNERDEAD, 112 id | UMUTEX_CONTESTED)) 113 return (EOWNERDEAD); 114 if (__predict_false((uint32_t)mtx->m_owner == UMUTEX_RB_NOTRECOV)) 115 return (ENOTRECOVERABLE); 116 return (EBUSY); 117} 118 119static inline int 120_thr_umutex_lock(struct umutex *mtx, uint32_t id) 121{ 122 123 if (_thr_umutex_trylock2(mtx, id) == 0) 124 return (0); 125 return (__thr_umutex_lock(mtx, id)); 126} 127 128static inline int 129_thr_umutex_lock_spin(struct umutex *mtx, uint32_t id) 130{ 131 132 if (_thr_umutex_trylock2(mtx, id) == 0) 133 return (0); 134 return (__thr_umutex_lock_spin(mtx, id)); 135} 136 137static inline int 138_thr_umutex_timedlock(struct umutex *mtx, uint32_t id, 139 const struct timespec *timeout) 140{ 141 142 if (_thr_umutex_trylock2(mtx, id) == 0) 143 return (0); 144 return (__thr_umutex_timedlock(mtx, id, timeout)); 145} 146 147static inline int 148_thr_umutex_unlock2(struct umutex *mtx, uint32_t id, int *defer) 149{ 150 uint32_t flags, owner; 151 bool noncst; 152 153 flags = mtx->m_flags; 154 noncst = (flags & UMUTEX_NONCONSISTENT) != 0; 155 156 if ((flags & (UMUTEX_PRIO_PROTECT | UMUTEX_PRIO_INHERIT)) != 0) { 157 if (atomic_cmpset_rel_32(&mtx->m_owner, id, noncst ? 158 UMUTEX_RB_NOTRECOV : UMUTEX_UNOWNED)) 159 return (0); 160 return (__thr_umutex_unlock(mtx)); 161 } 162 163 do { 164 owner = mtx->m_owner; 165 if (__predict_false((owner & ~UMUTEX_CONTESTED) != id)) 166 return (EPERM); 167 } while (__predict_false(!atomic_cmpset_rel_32(&mtx->m_owner, owner, 168 noncst ? UMUTEX_RB_NOTRECOV : UMUTEX_UNOWNED))); 169 if ((owner & UMUTEX_CONTESTED) != 0) { 170 if (defer == NULL || noncst) 171 (void)_umtx_op_err(mtx, UMTX_OP_MUTEX_WAKE2, 172 flags, 0, 0); 173 else 174 *defer = 1; 175 } 176 return (0); 177} 178 179static inline int 180_thr_umutex_unlock(struct umutex *mtx, uint32_t id) 181{ 182 183 return (_thr_umutex_unlock2(mtx, id, NULL)); 184} 185 186static inline int 187_thr_rwlock_tryrdlock(struct urwlock *rwlock, int flags) 188{ 189 int32_t state, wrflags; 190 191 if ((flags & URWLOCK_PREFER_READER) != 0 || 192 (rwlock->rw_flags & URWLOCK_PREFER_READER) != 0) 193 wrflags = URWLOCK_WRITE_OWNER; 194 else 195 wrflags = URWLOCK_WRITE_OWNER | URWLOCK_WRITE_WAITERS; 196 state = rwlock->rw_state; 197 while (!(state & wrflags)) { 198 if (__predict_false(URWLOCK_READER_COUNT(state) == 199 URWLOCK_MAX_READERS)) 200 return (EAGAIN); 201 if (atomic_cmpset_acq_32(&rwlock->rw_state, state, state + 1)) 202 return (0); 203 state = rwlock->rw_state; 204 } 205 206 return (EBUSY); 207} 208 209static inline int 210_thr_rwlock_trywrlock(struct urwlock *rwlock) 211{ 212 int32_t state; 213 214 state = rwlock->rw_state; 215 while ((state & URWLOCK_WRITE_OWNER) == 0 && 216 URWLOCK_READER_COUNT(state) == 0) { 217 if (atomic_cmpset_acq_32(&rwlock->rw_state, state, 218 state | URWLOCK_WRITE_OWNER)) 219 return (0); 220 state = rwlock->rw_state; 221 } 222 223 return (EBUSY); 224} 225 226static inline int 227_thr_rwlock_rdlock(struct urwlock *rwlock, int flags, struct timespec *tsp) 228{ 229 230 if (_thr_rwlock_tryrdlock(rwlock, flags) == 0) 231 return (0); 232 return (__thr_rwlock_rdlock(rwlock, flags, tsp)); 233} 234 235static inline int 236_thr_rwlock_wrlock(struct urwlock *rwlock, struct timespec *tsp) 237{ 238 239 if (_thr_rwlock_trywrlock(rwlock) == 0) 240 return (0); 241 return (__thr_rwlock_wrlock(rwlock, tsp)); 242} 243 244static inline int 245_thr_rwlock_unlock(struct urwlock *rwlock) 246{ 247 int32_t state; 248 249 state = rwlock->rw_state; 250 if ((state & URWLOCK_WRITE_OWNER) != 0) { 251 if (atomic_cmpset_rel_32(&rwlock->rw_state, 252 URWLOCK_WRITE_OWNER, 0)) 253 return (0); 254 } else { 255 for (;;) { 256 if (__predict_false(URWLOCK_READER_COUNT(state) == 0)) 257 return (EPERM); 258 if (!((state & (URWLOCK_WRITE_WAITERS | 259 URWLOCK_READ_WAITERS)) != 0 && 260 URWLOCK_READER_COUNT(state) == 1)) { 261 if (atomic_cmpset_rel_32(&rwlock->rw_state, 262 state, state - 1)) 263 return (0); 264 state = rwlock->rw_state; 265 } else { 266 break; 267 } 268 } 269 } 270 return (__thr_rwlock_unlock(rwlock)); 271} 272#endif 273