1 /*
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>.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
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.
22 *
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
33 * SUCH DAMAGE.
34 *
35 * $FreeBSD: src/lib/libpthread/thread/thr_rwlock.c,v 1.14 2004/01/08 15:37:09 deischen Exp $
36 */
37
38 #include <sys/lwp.h>
39 #include <machine/atomic.h>
40 #include <machine/tls.h>
41 #include <errno.h>
42
43 #include "sysvipc_utils.h"
44 #include "sysvipc_lock.h"
45 #include "sysvipc_lock_generic.h"
46
47 #include <limits.h>
48 #include <stdio.h>
49 #include <unistd.h>
50
51 #define MAX_READ_LOCKS (INT_MAX - 1)
52
53 static int rdlock_count;
54
55 int
sysv_mutex_init(struct sysv_mutex * mutex)56 sysv_mutex_init(struct sysv_mutex *mutex)
57 {
58 if(mutex == NULL)
59 return (EINVAL);
60 mutex->_mutex_static_lock = 0;
61 mutex->pid_owner = -1;
62 mutex->tid_owner = -1;
63 return (0);
64 }
65
66 int
sysv_mutex_lock(struct sysv_mutex * mutex)67 sysv_mutex_lock(struct sysv_mutex *mutex)
68 {
69 if (mutex->pid_owner == getpid() &&
70 mutex->tid_owner == lwp_gettid()) {
71 sysv_print_err("deadlock: mutex aleady acquired by the thread\n");
72 return (EDEADLK);
73 }
74 _sysv_umtx_lock(&mutex->_mutex_static_lock);
75 mutex->pid_owner = getpid();
76 mutex->tid_owner = lwp_gettid();
77 return (0);
78 }
79
80 int
sysv_mutex_unlock(struct sysv_mutex * mutex)81 sysv_mutex_unlock(struct sysv_mutex *mutex)
82 {
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");
86 return (EPERM);
87 }
88
89 mutex->tid_owner = -1;
90 mutex->pid_owner = -1;
91 _sysv_umtx_unlock(&mutex->_mutex_static_lock);
92 return (0);
93 }
94
95 static int
sysv_cond_wait(int * val,struct sysv_mutex * mutex)96 sysv_cond_wait(int *val, struct sysv_mutex *mutex)
97 {
98 sysv_mutex_unlock(mutex);
99
100 /* I use SYSV_TIMEOUT to avoid lossing a wakeup
101 * sent before going to sleep and remain blocked.
102 */
103 umtx_sleep(val, *val, SYSV_TIMEOUT);
104 return (sysv_mutex_lock(mutex));
105 }
106
107 static int
sysv_cond_signal(int * val)108 sysv_cond_signal(int *val)
109 {
110 return (umtx_wakeup(val, 0));
111 }
112
113 int
sysv_rwlock_init(struct sysv_rwlock * rwlock)114 sysv_rwlock_init(struct sysv_rwlock *rwlock)
115 {
116 int ret = 0;
117
118 if (rwlock == NULL)
119 return (EINVAL);
120
121 /* Initialize the lock. */
122 sysv_mutex_init(&rwlock->lock);
123 rwlock->state = 0;
124 rwlock->blocked_writers = 0;
125
126 return (ret);
127 }
128
129 int
sysv_rwlock_unlock(struct sysv_rwlock * rwlock)130 sysv_rwlock_unlock(struct sysv_rwlock *rwlock)
131 {
132 int ret;
133
134 if (rwlock == NULL)
135 return (EINVAL);
136
137 /* Grab the monitor lock. */
138 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
139 return (ret);
140
141 if (rwlock->state > 0) {
142 rdlock_count--;
143 rwlock->state--;
144 if (rwlock->state == 0 && rwlock->blocked_writers) {
145 ret = sysv_cond_signal(&rwlock->write_signal);
146 }
147 } else if (rwlock->state < 0) {
148 rwlock->state = 0;
149
150 if (rwlock->blocked_writers) {
151 ret = sysv_cond_signal(&rwlock->write_signal);
152 }
153 else {
154 ret = sysv_cond_signal(&rwlock->read_signal);
155 }
156 } else
157 ret = EINVAL;
158
159 sysv_mutex_unlock(&rwlock->lock);
160
161 return (ret);
162 }
163
164 int
sysv_rwlock_wrlock(struct sysv_rwlock * rwlock)165 sysv_rwlock_wrlock(struct sysv_rwlock *rwlock)
166 {
167 int ret;
168
169 if (rwlock == NULL)
170 return (EINVAL);
171
172 /* Grab the monitor lock. */
173 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
174 return (ret);
175
176 while (rwlock->state != 0) {
177 rwlock->blocked_writers++;
178
179 ret = sysv_cond_wait(&rwlock->write_signal, &rwlock->lock);
180 if (ret != 0) {
181 rwlock->blocked_writers--;
182 /* No unlock is required because only the lock
183 * operation can return error.
184 */
185 //sysv_mutex_unlock(&rwlock->lock);
186 return (ret);
187 }
188
189 rwlock->blocked_writers--;
190 }
191
192 /* Indicate that we are locked for writing. */
193 rwlock->state = -1;
194
195 sysv_mutex_unlock(&rwlock->lock);
196
197 return (ret);
198 }
199
200 int
sysv_rwlock_rdlock(struct sysv_rwlock * rwlock)201 sysv_rwlock_rdlock(struct sysv_rwlock *rwlock)
202 {
203 int ret;
204
205 // sysv_print("try get rd lock\n");
206 if (rwlock == NULL)
207 return (EINVAL);
208
209 /* Grab the monitor lock. */
210 if ((ret = sysv_mutex_lock(&rwlock->lock)) != 0)
211 return (ret);
212
213 /* Check the lock count. */
214 if (rwlock->state == MAX_READ_LOCKS) {
215 sysv_mutex_unlock(&rwlock->lock);
216 return (EAGAIN);
217 }
218
219 if ((rdlock_count > 0) && (rwlock->state > 0)) {
220 /*
221 * Taken from the pthread implementation with only
222 * one change; rdlock_count is per process not per
223 * thread;
224 * Original comment:
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 ;-)
235 */
236 ; /* nothing needed */
237 } else {
238 /* Give writers priority over readers. */
239 while (rwlock->blocked_writers || rwlock->state < 0) {
240 ret = sysv_cond_wait(&rwlock->read_signal,
241 &rwlock->lock);
242 if (ret != 0) {
243 /* No unlock necessary because only lock
244 * operation can return error.
245 */
246 //sysv_mutex_unlock(&rwlock->lock);
247 return (ret);
248 }
249 }
250 }
251
252 rdlock_count++;
253 rwlock->state++; /* Indicate we are locked for reading. */
254
255 /*
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.
260 */
261 sysv_mutex_unlock(&rwlock->lock);
262
263 return (ret);
264 }
265