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 * $FreeBSD: src/lib/libpthread/thread/thr_rwlock.c,v 1.14 2004/01/08 15:37:09 deischen Exp $
39 #include <machine/atomic.h>
40 #include <machine/tls.h>
43 #include "sysvipc_utils.h"
44 #include "sysvipc_lock.h"
45 #include "sysvipc_lock_generic.h"
51 #define MAX_READ_LOCKS (INT_MAX - 1)
53 static int rdlock_count;
56 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)
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)
110 return (umtx_wakeup(val, 0));
114 sysv_rwlock_init(struct sysv_rwlock *rwlock)
121 /* Initialize the lock. */
122 sysv_mutex_init(&rwlock->lock);
124 rwlock->blocked_writers = 0;
130 sysv_rwlock_unlock(struct sysv_rwlock *rwlock)
137 /* Grab the monitor lock. */
138 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
141 if (rwlock->state > 0) {
144 if (rwlock->state == 0 && rwlock->blocked_writers) {
145 ret = sysv_cond_signal(&rwlock->write_signal);
147 } else if (rwlock->state < 0) {
150 if (rwlock->blocked_writers) {
151 ret = sysv_cond_signal(&rwlock->write_signal);
154 ret = sysv_cond_signal(&rwlock->read_signal);
159 sysv_mutex_unlock(&rwlock->lock);
165 sysv_rwlock_wrlock(struct sysv_rwlock *rwlock)
172 /* Grab the monitor lock. */
173 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
176 while (rwlock->state != 0) {
177 rwlock->blocked_writers++;
179 ret = sysv_cond_wait(&rwlock->write_signal, &rwlock->lock);
181 rwlock->blocked_writers--;
182 /* No unlock is required because only the lock
183 * operation can return error.
185 //sysv_mutex_unlock(&rwlock->lock);
189 rwlock->blocked_writers--;
192 /* Indicate that we are locked for writing. */
195 sysv_mutex_unlock(&rwlock->lock);
201 sysv_rwlock_rdlock(struct sysv_rwlock *rwlock)
205 // sysv_print("try get rd lock\n");
209 /* Grab the monitor lock. */
210 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
213 /* Check the lock count. */
214 if (rwlock->state == MAX_READ_LOCKS) {
215 sysv_mutex_unlock(&rwlock->lock);
219 if ((rdlock_count > 0) && (rwlock->state > 0)) {
221 * Taken from the pthread implementation with only
222 * one change; rdlock_count is per process not per
225 * To avoid having to track all the rdlocks held by
226 * a thread or all of the threads that hold a rdlock,
227 * we keep a simple count of all the rdlocks held by
228 * a thread. If a thread holds any rdlocks it is
229 * possible that it is attempting to take a recursive
230 * rdlock. If there are blocked writers and precedence
231 * is given to them, then that would result in the thread
232 * deadlocking. So allowing a thread to take the rdlock
233 * when it already has one or more rdlocks avoids the
234 * deadlock. I hope the reader can follow that logic ;-)
236 ; /* nothing needed */
238 /* Give writers priority over readers. */
239 while (rwlock->blocked_writers || rwlock->state < 0) {
240 ret = sysv_cond_wait(&rwlock->read_signal,
243 /* No unlock necessary because only lock
244 * operation can return error.
246 //sysv_mutex_unlock(&rwlock->lock);
253 rwlock->state++; /* Indicate we are locked for reading. */
256 * Something is really wrong if this call fails. Returning
257 * error won't do because we've already obtained the read
258 * lock. Decrementing 'state' is no good because we probably
259 * don't have the monitor lock.
261 sysv_mutex_unlock(&rwlock->lock);