adb0ecb1767e31a00fb6f8bc36f22dead3713465
[idzebra-moved-to-github.git] / util / zebra-lock.c
1 /* $Id: zebra-lock.c,v 1.8 2005-01-15 19:38:42 adam Exp $
2    Copyright (C) 1995-2005
3    Index Data ApS
4
5 This file is part of the Zebra server.
6
7 Zebra is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.
21 */
22
23
24
25 #include <assert.h>
26 #include <stdio.h>
27
28 #include <zebra-lock.h>
29
30
31 int zebra_mutex_init (Zebra_mutex *p)
32 {
33     p->state = 1;
34 #if YAZ_POSIX_THREADS
35     pthread_mutex_init (&p->mutex, 0);
36 #endif
37 #ifdef WIN32
38     InitializeCriticalSection (&p->mutex);
39 #endif
40     return 0;
41 }
42
43 int zebra_mutex_destroy (Zebra_mutex *p)
44 {
45     --(p->state);
46     if (p->state != 0)
47     {
48         fprintf (stderr, "zebra_mutex_destroy. state = %d\n", p->state);
49     } 
50 #if YAZ_POSIX_THREADS
51     pthread_mutex_destroy (&p->mutex);
52 #endif
53 #ifdef WIN32
54     DeleteCriticalSection (&p->mutex);
55 #endif
56     return 0;
57 }
58
59 int zebra_mutex_lock (Zebra_mutex *p)
60 {
61     if (p->state != 1)
62     {
63         fprintf (stderr, "zebra_mutex_lock. state = %d\n", p->state);
64     }
65 #if YAZ_POSIX_THREADS
66     pthread_mutex_lock (&p->mutex);
67 #endif
68 #ifdef WIN32
69     EnterCriticalSection (&p->mutex);
70 #endif
71     return 0;
72 }
73
74 int zebra_mutex_unlock (Zebra_mutex *p)
75 {
76     if (p->state != 1)
77     {
78         fprintf (stderr, "zebra_mutex_unlock. state = %d\n", p->state);
79     }
80 #if YAZ_POSIX_THREADS
81     pthread_mutex_unlock (&p->mutex);
82 #endif
83 #ifdef WIN32
84     LeaveCriticalSection (&p->mutex);
85 #endif
86     return 0;
87 }
88
89 int zebra_lock_rdwr_init (Zebra_lock_rdwr *p)
90 {
91     p->readers_reading = 0;
92     p->writers_writing = 0;
93 #if YAZ_POSIX_THREADS
94     pthread_mutex_init (&p->mutex, 0);
95     pthread_cond_init (&p->lock_free, 0);
96 #endif
97     return 0;
98 }
99
100 int zebra_lock_rdwr_destroy (Zebra_lock_rdwr *p)
101 {
102     assert (p->readers_reading == 0);
103     assert (p->writers_writing == 0);
104 #if YAZ_POSIX_THREADS
105     pthread_mutex_destroy (&p->mutex);
106     pthread_cond_destroy (&p->lock_free);
107 #endif
108     return 0;
109 }
110
111 int zebra_lock_rdwr_rlock (Zebra_lock_rdwr *p)
112 {
113 #if YAZ_POSIX_THREADS
114     pthread_mutex_lock (& p->mutex);
115     while (p->writers_writing)
116         pthread_cond_wait (&p->lock_free, &p->mutex);
117     p->readers_reading++;
118     pthread_mutex_unlock(&p->mutex);
119 #endif
120     return 0;
121 }
122
123 int zebra_lock_rdwr_wlock (Zebra_lock_rdwr *p)
124 {
125 #if YAZ_POSIX_THREADS
126     pthread_mutex_lock (&p->mutex);
127     while (p->writers_writing || p->readers_reading)
128         pthread_cond_wait (&p->lock_free, &p->mutex);
129     p->writers_writing++;
130     pthread_mutex_unlock (&p->mutex);
131 #endif
132     return 0;
133 }
134
135 int zebra_lock_rdwr_runlock (Zebra_lock_rdwr *p)
136 {
137 #if YAZ_POSIX_THREADS
138     pthread_mutex_lock (&p->mutex);
139     if (p->readers_reading == 0)
140     {
141         pthread_mutex_unlock (&p->mutex);
142         return -1;
143     } 
144     else
145     {
146         p->readers_reading--;
147         if (p->readers_reading == 0)
148             pthread_cond_signal (&p->lock_free);
149         pthread_mutex_unlock (&p->mutex);
150     }
151 #endif
152     return 0;
153 }
154
155 int zebra_lock_rdwr_wunlock (Zebra_lock_rdwr *p)
156 {
157 #if YAZ_POSIX_THREADS
158     pthread_mutex_lock (&p->mutex);
159     if (p->writers_writing == 0)
160     {
161         pthread_mutex_unlock (&p->mutex);
162         return -1;
163     }
164     else
165     {
166         p->writers_writing--;
167         pthread_cond_broadcast(&p->lock_free);
168         pthread_mutex_unlock(&p->mutex);
169     }
170 #endif
171     return 0;
172 }
173
174 int zebra_mutex_cond_init (Zebra_mutex_cond *p)
175 {
176 #if YAZ_POSIX_THREADS
177     pthread_cond_init (&p->cond, 0);
178     pthread_mutex_init (&p->mutex, 0);
179 #endif
180     return 0;
181 }
182
183 int zebra_mutex_cond_destroy (Zebra_mutex_cond *p)
184 {
185 #if YAZ_POSIX_THREADS
186     pthread_cond_destroy (&p->cond);
187     pthread_mutex_destroy (&p->mutex);
188 #endif
189     return 0;
190 }
191
192 int zebra_mutex_cond_lock (Zebra_mutex_cond *p)
193 {
194 #if YAZ_POSIX_THREADS
195     return pthread_mutex_lock (&p->mutex);
196 #else
197     return 0;
198 #endif
199 }
200
201 int zebra_mutex_cond_unlock (Zebra_mutex_cond *p)
202 {
203 #if YAZ_POSIX_THREADS
204     return pthread_mutex_unlock (&p->mutex);
205 #else
206     return 0;
207 #endif
208 }
209
210 int zebra_mutex_cond_wait (Zebra_mutex_cond *p)
211 {
212 #if YAZ_POSIX_THREADS
213     return pthread_cond_wait (&p->cond, &p->mutex);
214 #else
215     return 0;
216 #endif
217 }
218
219 int zebra_mutex_cond_signal (Zebra_mutex_cond *p)
220 {
221 #if YAZ_POSIX_THREADS
222     return pthread_cond_signal (&p->cond);
223 #else
224     return 0;
225 #endif
226 }