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 $
41 #include <machine/atomic.h>
42 #include <machine/tls.h>
45 #include "sysvipc_utils.h"
46 #include "sysvipc_lock.h"
47 #include "sysvipc_lock_generic.h"
53 #define MAX_READ_LOCKS (INT_MAX - 1)
55 static int rdlock_count;
58 sysv_mutex_init(struct sysv_mutex *mutex) {
61 mutex->_mutex_static_lock = 0;
62 mutex->pid_owner = -1;
63 mutex->tid_owner = -1;
68 sysv_mutex_lock(struct sysv_mutex *mutex)
70 if (mutex->pid_owner == getpid() &&
71 mutex->tid_owner == lwp_gettid()) {
72 sysv_print_err("deadlock: mutex aleady acquired by the thread\n");
75 _sysv_umtx_lock(&mutex->_mutex_static_lock);
76 mutex->pid_owner = getpid();
77 mutex->tid_owner = lwp_gettid();
82 sysv_mutex_unlock(struct sysv_mutex *mutex)
84 if (mutex->pid_owner != getpid() ||
85 mutex->tid_owner != lwp_gettid()) {
86 sysv_print_err("eperm try unlock a mutex that is not acquired\n");
90 mutex->tid_owner = -1;
91 mutex->pid_owner = -1;
92 _sysv_umtx_unlock(&mutex->_mutex_static_lock);
97 sysv_cond_wait(int *val, struct sysv_mutex *mutex) {
98 sysv_mutex_unlock(mutex);
100 /* I use SYSV_TIMEOUT to avoid lossing a wakeup
101 * sent before going to sleep and remain blocked.
103 umtx_sleep(val, *val, SYSV_TIMEOUT);
104 return (sysv_mutex_lock(mutex));
108 sysv_cond_signal(int *val) {
109 return (umtx_wakeup(val, 0));
113 sysv_rwlock_init(struct sysv_rwlock *rwlock)
120 /* Initialize the lock. */
121 sysv_mutex_init(&rwlock->lock);
123 rwlock->blocked_writers = 0;
129 sysv_rwlock_unlock (struct sysv_rwlock *rwlock)
136 /* Grab the monitor lock. */
137 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
140 if (rwlock->state > 0) {
143 if (rwlock->state == 0 && rwlock->blocked_writers) {
144 ret = sysv_cond_signal(&rwlock->write_signal);
146 } else if (rwlock->state < 0) {
149 if (rwlock->blocked_writers) {
150 ret = sysv_cond_signal(&rwlock->write_signal);
153 ret = sysv_cond_signal(&rwlock->read_signal);
158 sysv_mutex_unlock(&rwlock->lock);
164 sysv_rwlock_wrlock (struct sysv_rwlock *rwlock)
171 /* Grab the monitor lock. */
172 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
175 while (rwlock->state != 0) {
176 rwlock->blocked_writers++;
178 ret = sysv_cond_wait(&rwlock->write_signal, &rwlock->lock);
180 rwlock->blocked_writers--;
181 /* No unlock is required because only the lock
182 * operation can return error.
184 //sysv_mutex_unlock(&rwlock->lock);
188 rwlock->blocked_writers--;
191 /* Indicate that we are locked for writing. */
194 sysv_mutex_unlock(&rwlock->lock);
200 sysv_rwlock_rdlock(struct sysv_rwlock *rwlock)
204 // sysv_print("try get rd lock\n");
208 /* Grab the monitor lock. */
209 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
212 /* Check the lock count. */
213 if (rwlock->state == MAX_READ_LOCKS) {
214 sysv_mutex_unlock(&rwlock->lock);
218 if ((rdlock_count > 0) && (rwlock->state > 0)) {
220 * Taken from the pthread implementation with only
221 * one change; rdlock_count is per process not per
224 * To avoid having to track all the rdlocks held by
225 * a thread or all of the threads that hold a rdlock,
226 * we keep a simple count of all the rdlocks held by
227 * a thread. If a thread holds any rdlocks it is
228 * possible that it is attempting to take a recursive
229 * rdlock. If there are blocked writers and precedence
230 * is given to them, then that would result in the thread
231 * deadlocking. So allowing a thread to take the rdlock
232 * when it already has one or more rdlocks avoids the
233 * deadlock. I hope the reader can follow that logic ;-)
235 ; /* nothing needed */
237 /* Give writers priority over readers. */
238 while (rwlock->blocked_writers || rwlock->state < 0) {
239 ret = sysv_cond_wait(&rwlock->read_signal,
242 /* No unlock necessary because only lock
243 * operation can return error.
245 //sysv_mutex_unlock(&rwlock->lock);
252 rwlock->state++; /* Indicate we are locked for reading. */
255 * Something is really wrong if this call fails. Returning
256 * error won't do because we've already obtained the read
257 * lock. Decrementing 'state' is no good because we probably
258 * don't have the monitor lock.
260 sysv_mutex_unlock(&rwlock->lock);