2 * Copyright (c) 1995 John Birrell <jb@cimlogic.com.au>.
3 * Copyright (c) 1998 Alex Nash
4 * Copyright (c) 2006 David Xu <yfxu@corp.netease.com>.
5 * Copyright (c) 2013 Larisa Grigore <larisagrigore@gmail.com>.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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 the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by John Birrell.
19 * 4. Neither the name of the author nor the names of any co-contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * $DragonFly: src/lib/libthread_xu/thread/thr_mutex.c,v 1.15 2008/05/09 16:03:27 dillon Exp $
36 * $FreeBSD: src/lib/libpthread/thread/thr_rwlock.c,v 1.14 2004/01/08 15:37:09 deischen Exp $
37 * $DragonFly: src/lib/libthread_xu/thread/thr_rwlock.c,v 1.7 2006/04/06 13:03:09 davidxu Exp $
40 #include <machine/atomic.h>
41 #include <machine/tls.h>
44 #include "sysvipc_utils.h"
45 #include "sysvipc_lock.h"
46 #include "sysvipc_lock_generic.h"
52 #define MAX_READ_LOCKS (INT_MAX - 1)
54 static int rdlock_count;
57 sysv_mutex_init(struct sysv_mutex *mutex) {
60 mutex->_mutex_static_lock = 0;
61 mutex->pid_owner = -1;
62 mutex->tid_owner = -1;
67 sysv_mutex_lock(struct sysv_mutex *mutex)
69 if (mutex->pid_owner == getpid() &&
70 mutex->tid_owner == lwp_gettid()) {
71 sysv_print_err("deadlock: mutex aleady acquired by the thread\n");
74 _sysv_umtx_lock(&mutex->_mutex_static_lock);
75 mutex->pid_owner = getpid();
76 mutex->tid_owner = lwp_gettid();
81 sysv_mutex_unlock(struct sysv_mutex *mutex)
83 if (mutex->pid_owner != getpid() ||
84 mutex->tid_owner != lwp_gettid()) {
85 sysv_print_err("eperm try unlock a mutex that is not acquired\n");
89 mutex->tid_owner = -1;
90 mutex->pid_owner = -1;
91 _sysv_umtx_unlock(&mutex->_mutex_static_lock);
96 sysv_cond_wait(int *val, struct sysv_mutex *mutex) {
97 sysv_mutex_unlock(mutex);
99 /* I use SYSV_TIMEOUT to avoid lossing a wakeup
100 * sent before going to sleep and remain blocked.
102 umtx_sleep(val, *val, SYSV_TIMEOUT);
103 return (sysv_mutex_lock(mutex));
107 sysv_cond_signal(int *val) {
108 return (umtx_wakeup(val, 0));
112 sysv_rwlock_init(struct sysv_rwlock *rwlock)
119 /* Initialize the lock. */
120 sysv_mutex_init(&rwlock->lock);
122 rwlock->blocked_writers = 0;
128 sysv_rwlock_unlock (struct sysv_rwlock *rwlock)
135 /* Grab the monitor lock. */
136 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
139 if (rwlock->state > 0) {
142 if (rwlock->state == 0 && rwlock->blocked_writers) {
143 ret = sysv_cond_signal(&rwlock->write_signal);
145 } else if (rwlock->state < 0) {
148 if (rwlock->blocked_writers) {
149 ret = sysv_cond_signal(&rwlock->write_signal);
152 ret = sysv_cond_signal(&rwlock->read_signal);
157 sysv_mutex_unlock(&rwlock->lock);
163 sysv_rwlock_wrlock (struct sysv_rwlock *rwlock)
170 /* Grab the monitor lock. */
171 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
174 while (rwlock->state != 0) {
175 rwlock->blocked_writers++;
177 ret = sysv_cond_wait(&rwlock->write_signal, &rwlock->lock);
179 rwlock->blocked_writers--;
180 /* No unlock is required because only the lock
181 * operation can return error.
183 //sysv_mutex_unlock(&rwlock->lock);
187 rwlock->blocked_writers--;
190 /* Indicate that we are locked for writing. */
193 sysv_mutex_unlock(&rwlock->lock);
199 sysv_rwlock_rdlock(struct sysv_rwlock *rwlock)
203 // sysv_print("try get rd lock\n");
207 /* Grab the monitor lock. */
208 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
211 /* Check the lock count. */
212 if (rwlock->state == MAX_READ_LOCKS) {
213 sysv_mutex_unlock(&rwlock->lock);
217 if ((rdlock_count > 0) && (rwlock->state > 0)) {
219 * Taken from the pthread implementation with only
220 * one change; rdlock_count is per process not per
223 * To avoid having to track all the rdlocks held by
224 * a thread or all of the threads that hold a rdlock,
225 * we keep a simple count of all the rdlocks held by
226 * a thread. If a thread holds any rdlocks it is
227 * possible that it is attempting to take a recursive
228 * rdlock. If there are blocked writers and precedence
229 * is given to them, then that would result in the thread
230 * deadlocking. So allowing a thread to take the rdlock
231 * when it already has one or more rdlocks avoids the
232 * deadlock. I hope the reader can follow that logic ;-)
234 ; /* nothing needed */
236 /* Give writers priority over readers. */
237 while (rwlock->blocked_writers || rwlock->state < 0) {
238 ret = sysv_cond_wait(&rwlock->read_signal,
241 /* No unlock necessary because only lock
242 * operation can return error.
244 //sysv_mutex_unlock(&rwlock->lock);
251 rwlock->state++; /* Indicate we are locked for reading. */
254 * Something is really wrong if this call fails. Returning
255 * error won't do because we've already obtained the read
256 * lock. Decrementing 'state' is no good because we probably
257 * don't have the monitor lock.
259 sysv_mutex_unlock(&rwlock->lock);