Annotation of embedaddon/strongswan/src/libstrongswan/threading/rwlock.c, revision 1.1.1.1
1.1 misho 1: /*
2: * Copyright (C) 2008-2012 Tobias Brunner
3: * Copyright (C) 2008 Martin Willi
4: * HSR Hochschule fuer Technik Rapperswil
5: *
6: * This program is free software; you can redistribute it and/or modify it
7: * under the terms of the GNU General Public License as published by the
8: * Free Software Foundation; either version 2 of the License, or (at your
9: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
10: *
11: * This program is distributed in the hope that it will be useful, but
12: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14: * for more details.
15: */
16:
17: #define _GNU_SOURCE
18: #include <pthread.h>
19:
20: #include <library.h>
21: #include <utils/debug.h>
22:
23: #include "rwlock.h"
24: #include "rwlock_condvar.h"
25: #include "thread.h"
26: #include "condvar.h"
27: #include "mutex.h"
28: #include "lock_profiler.h"
29:
30: #ifdef __APPLE__
31: /* while pthread_rwlock_rdlock(3) says that it supports multiple read locks,
32: * this does not seem to be true. After releasing a recursive rdlock,
33: * a subsequent wrlock fails... */
34: # undef HAVE_PTHREAD_RWLOCK_INIT
35: #endif
36:
37: typedef struct private_rwlock_t private_rwlock_t;
38: typedef struct private_rwlock_condvar_t private_rwlock_condvar_t;
39:
40: /**
41: * private data of rwlock
42: */
43: struct private_rwlock_t {
44:
45: /**
46: * public functions
47: */
48: rwlock_t public;
49:
50: #ifdef HAVE_PTHREAD_RWLOCK_INIT
51:
52: /**
53: * wrapped pthread rwlock
54: */
55: pthread_rwlock_t rwlock;
56:
57: #else
58:
59: /**
60: * mutex to emulate a native rwlock
61: */
62: mutex_t *mutex;
63:
64: /**
65: * condvar to handle writers
66: */
67: condvar_t *writers;
68:
69: /**
70: * condvar to handle readers
71: */
72: condvar_t *readers;
73:
74: /**
75: * number of waiting writers
76: */
77: u_int waiting_writers;
78:
79: /**
80: * number of readers holding the lock
81: */
82: u_int reader_count;
83:
84: /**
85: * TRUE, if a writer is holding the lock currently
86: */
87: bool writer;
88:
89: #endif /* HAVE_PTHREAD_RWLOCK_INIT */
90:
91: /**
92: * profiling info, if enabled
93: */
94: lock_profile_t profile;
95: };
96:
97: /**
98: * private data of condvar
99: */
100: struct private_rwlock_condvar_t {
101:
102: /**
103: * public interface
104: */
105: rwlock_condvar_t public;
106:
107: /**
108: * mutex used to implement rwlock condvar
109: */
110: mutex_t *mutex;
111:
112: /**
113: * regular condvar to implement rwlock condvar
114: */
115: condvar_t *condvar;
116: };
117:
118:
119: #ifdef HAVE_PTHREAD_RWLOCK_INIT
120:
121: METHOD(rwlock_t, read_lock, void,
122: private_rwlock_t *this)
123: {
124: int err;
125:
126: profiler_start(&this->profile);
127: err = pthread_rwlock_rdlock(&this->rwlock);
128: if (err != 0)
129: {
130: DBG1(DBG_LIB, "!!! RWLOCK READ LOCK ERROR: %s !!!", strerror(err));
131: }
132: profiler_end(&this->profile);
133: }
134:
135: METHOD(rwlock_t, write_lock, void,
136: private_rwlock_t *this)
137: {
138: int err;
139:
140: profiler_start(&this->profile);
141: err = pthread_rwlock_wrlock(&this->rwlock);
142: if (err != 0)
143: {
144: DBG1(DBG_LIB, "!!! RWLOCK WRITE LOCK ERROR: %s !!!", strerror(err));
145: }
146: profiler_end(&this->profile);
147: }
148:
149: METHOD(rwlock_t, try_write_lock, bool,
150: private_rwlock_t *this)
151: {
152: return pthread_rwlock_trywrlock(&this->rwlock) == 0;
153: }
154:
155: METHOD(rwlock_t, unlock, void,
156: private_rwlock_t *this)
157: {
158: int err;
159:
160: err = pthread_rwlock_unlock(&this->rwlock);
161: if (err != 0)
162: {
163: DBG1(DBG_LIB, "!!! RWLOCK UNLOCK ERROR: %s !!!", strerror(err));
164: }
165: }
166:
167: METHOD(rwlock_t, destroy, void,
168: private_rwlock_t *this)
169: {
170: pthread_rwlock_destroy(&this->rwlock);
171: profiler_cleanup(&this->profile);
172: free(this);
173: }
174:
175: /*
176: * see header file
177: */
178: rwlock_t *rwlock_create(rwlock_type_t type)
179: {
180: switch (type)
181: {
182: case RWLOCK_TYPE_DEFAULT:
183: default:
184: {
185: private_rwlock_t *this;
186:
187: INIT(this,
188: .public = {
189: .read_lock = _read_lock,
190: .write_lock = _write_lock,
191: .try_write_lock = _try_write_lock,
192: .unlock = _unlock,
193: .destroy = _destroy,
194: }
195: );
196:
197: pthread_rwlock_init(&this->rwlock, NULL);
198: profiler_init(&this->profile);
199:
200: return &this->public;
201: }
202: }
203: }
204:
205: #else /* HAVE_PTHREAD_RWLOCK_INIT */
206:
207: /**
208: * This implementation of the rwlock_t interface uses mutex_t and condvar_t
209: * primitives, if the pthread_rwlock_* group of functions is not available or
210: * don't allow recursive locking for readers.
211: *
212: * The following constraints are enforced:
213: * - Multiple readers can hold the lock at the same time.
214: * - Only a single writer can hold the lock at any given time.
215: * - A writer must block until all readers have released the lock before
216: * obtaining the lock exclusively.
217: * - Readers that don't hold any read lock and arrive while a writer is
218: * waiting to acquire the lock will block until after the writer has
219: * obtained and released the lock.
220: * These constraints allow for read sharing, prevent write sharing, prevent
221: * read-write sharing and (largely) prevent starvation of writers by a steady
222: * stream of incoming readers. Reader starvation is not prevented (this could
223: * happen if there are more writers than readers).
224: *
225: * The implementation supports recursive locking of the read lock but not of
226: * the write lock. Readers must not acquire the lock exclusively at the same
227: * time and vice-versa (this is not checked or enforced so behave yourself to
228: * prevent deadlocks).
229: *
230: * Since writers are preferred a thread currently holding the read lock that
231: * tries to acquire the read lock recursively while a writer is waiting would
232: * result in a deadlock. In order to avoid having to use a thread-specific
233: * value for each rwlock_t (or a list of threads) to keep track if a thread
234: * already acquired the read lock we use a single thread-specific value for all
235: * rwlock_t objects that keeps track of how many read locks a thread currently
236: * holds. Preferring readers that already hold ANY read locks prevents this
237: * deadlock while it still largely avoids writer starvation (for locks that can
238: * only be acquired while holding another read lock this will obviously not
239: * work).
240: */
241:
242: /**
243: * Keep track of how many read locks a thread holds.
244: */
245: static pthread_key_t is_reader;
246:
247: /**
248: * Only initialize the read lock counter once.
249: */
250: static pthread_once_t is_reader_initialized = PTHREAD_ONCE_INIT;
251:
252: /**
253: * Initialize the read lock counter.
254: */
255: static void initialize_is_reader()
256: {
257: pthread_key_create(&is_reader, NULL);
258: }
259:
260: METHOD(rwlock_t, read_lock, void,
261: private_rwlock_t *this)
262: {
263: uintptr_t reading;
264: bool old;
265:
266: reading = (uintptr_t)pthread_getspecific(is_reader);
267: profiler_start(&this->profile);
268: this->mutex->lock(this->mutex);
269: if (!this->writer && reading > 0)
270: {
271: /* directly allow threads that hold ANY read locks, to avoid a deadlock
272: * caused by preferring writers in the loop below */
273: }
274: else
275: {
276: old = thread_cancelability(FALSE);
277: while (this->writer || this->waiting_writers)
278: {
279: this->readers->wait(this->readers, this->mutex);
280: }
281: thread_cancelability(old);
282: }
283: this->reader_count++;
284: profiler_end(&this->profile);
285: this->mutex->unlock(this->mutex);
286: pthread_setspecific(is_reader, (void*)(reading + 1));
287: }
288:
289: METHOD(rwlock_t, write_lock, void,
290: private_rwlock_t *this)
291: {
292: bool old;
293:
294: profiler_start(&this->profile);
295: this->mutex->lock(this->mutex);
296: this->waiting_writers++;
297: old = thread_cancelability(FALSE);
298: while (this->writer || this->reader_count)
299: {
300: this->writers->wait(this->writers, this->mutex);
301: }
302: thread_cancelability(old);
303: this->waiting_writers--;
304: this->writer = TRUE;
305: profiler_end(&this->profile);
306: this->mutex->unlock(this->mutex);
307: }
308:
309: METHOD(rwlock_t, try_write_lock, bool,
310: private_rwlock_t *this)
311: {
312: bool res = FALSE;
313: this->mutex->lock(this->mutex);
314: if (!this->writer && !this->reader_count)
315: {
316: res = this->writer = TRUE;
317: }
318: this->mutex->unlock(this->mutex);
319: return res;
320: }
321:
322: METHOD(rwlock_t, unlock, void,
323: private_rwlock_t *this)
324: {
325: this->mutex->lock(this->mutex);
326: if (this->writer)
327: {
328: this->writer = FALSE;
329: }
330: else
331: {
332: uintptr_t reading;
333:
334: this->reader_count--;
335: reading = (uintptr_t)pthread_getspecific(is_reader);
336: pthread_setspecific(is_reader, (void*)(reading - 1));
337: }
338: if (!this->reader_count)
339: {
340: if (this->waiting_writers)
341: {
342: this->writers->signal(this->writers);
343: }
344: else
345: {
346: this->readers->broadcast(this->readers);
347: }
348: }
349: this->mutex->unlock(this->mutex);
350: }
351:
352: METHOD(rwlock_t, destroy, void,
353: private_rwlock_t *this)
354: {
355: this->mutex->destroy(this->mutex);
356: this->writers->destroy(this->writers);
357: this->readers->destroy(this->readers);
358: profiler_cleanup(&this->profile);
359: free(this);
360: }
361:
362: /*
363: * see header file
364: */
365: rwlock_t *rwlock_create(rwlock_type_t type)
366: {
367: pthread_once(&is_reader_initialized, initialize_is_reader);
368:
369: switch (type)
370: {
371: case RWLOCK_TYPE_DEFAULT:
372: default:
373: {
374: private_rwlock_t *this;
375:
376: INIT(this,
377: .public = {
378: .read_lock = _read_lock,
379: .write_lock = _write_lock,
380: .try_write_lock = _try_write_lock,
381: .unlock = _unlock,
382: .destroy = _destroy,
383: },
384: .mutex = mutex_create(MUTEX_TYPE_DEFAULT),
385: .writers = condvar_create(CONDVAR_TYPE_DEFAULT),
386: .readers = condvar_create(CONDVAR_TYPE_DEFAULT),
387: );
388:
389: profiler_init(&this->profile);
390:
391: return &this->public;
392: }
393: }
394: }
395:
396: #endif /* HAVE_PTHREAD_RWLOCK_INIT */
397:
398:
399: METHOD(rwlock_condvar_t, wait_, void,
400: private_rwlock_condvar_t *this, rwlock_t *lock)
401: {
402: /* at this point we have the write lock locked, to make signals more
403: * predictable we try to prevent other threads from signaling by acquiring
404: * the mutex while we still hold the write lock (this assumes they will
405: * hold the write lock themselves when signaling, which is not mandatory) */
406: this->mutex->lock(this->mutex);
407: /* unlock the rwlock and wait for a signal */
408: lock->unlock(lock);
409: /* if the calling thread enabled thread cancelability we want to replicate
410: * the behavior of the regular condvar, i.e. the lock will be held again
411: * before executing cleanup functions registered by the calling thread */
412: thread_cleanup_push((thread_cleanup_t)lock->write_lock, lock);
413: thread_cleanup_push((thread_cleanup_t)this->mutex->unlock, this->mutex);
414: this->condvar->wait(this->condvar, this->mutex);
415: /* we release the mutex to allow other threads into the condvar (might even
416: * be required so we can acquire the lock again below) */
417: thread_cleanup_pop(TRUE);
418: /* finally we reacquire the lock we held previously */
419: thread_cleanup_pop(TRUE);
420: }
421:
422: METHOD(rwlock_condvar_t, timed_wait_abs, bool,
423: private_rwlock_condvar_t *this, rwlock_t *lock, timeval_t time)
424: {
425: bool timed_out;
426:
427: /* see wait() above for details on what is going on here */
428: this->mutex->lock(this->mutex);
429: lock->unlock(lock);
430: thread_cleanup_push((thread_cleanup_t)lock->write_lock, lock);
431: thread_cleanup_push((thread_cleanup_t)this->mutex->unlock, this->mutex);
432: timed_out = this->condvar->timed_wait_abs(this->condvar, this->mutex, time);
433: thread_cleanup_pop(TRUE);
434: thread_cleanup_pop(TRUE);
435: return timed_out;
436: }
437:
438: METHOD(rwlock_condvar_t, timed_wait, bool,
439: private_rwlock_condvar_t *this, rwlock_t *lock, u_int timeout)
440: {
441: timeval_t tv;
442: u_int s, ms;
443:
444: time_monotonic(&tv);
445:
446: s = timeout / 1000;
447: ms = timeout % 1000;
448:
449: tv.tv_sec += s;
450: timeval_add_ms(&tv, ms);
451:
452: return timed_wait_abs(this, lock, tv);
453: }
454:
455: METHOD(rwlock_condvar_t, signal_, void,
456: private_rwlock_condvar_t *this)
457: {
458: this->mutex->lock(this->mutex);
459: this->condvar->signal(this->condvar);
460: this->mutex->unlock(this->mutex);
461: }
462:
463: METHOD(rwlock_condvar_t, broadcast, void,
464: private_rwlock_condvar_t *this)
465: {
466: this->mutex->lock(this->mutex);
467: this->condvar->broadcast(this->condvar);
468: this->mutex->unlock(this->mutex);
469: }
470:
471: METHOD(rwlock_condvar_t, condvar_destroy, void,
472: private_rwlock_condvar_t *this)
473: {
474: this->condvar->destroy(this->condvar);
475: this->mutex->destroy(this->mutex);
476: free(this);
477: }
478:
479: /*
480: * see header file
481: */
482: rwlock_condvar_t *rwlock_condvar_create()
483: {
484: private_rwlock_condvar_t *this;
485:
486: INIT(this,
487: .public = {
488: .wait = _wait_,
489: .timed_wait = _timed_wait,
490: .timed_wait_abs = _timed_wait_abs,
491: .signal = _signal_,
492: .broadcast = _broadcast,
493: .destroy = _condvar_destroy,
494: },
495: .mutex = mutex_create(MUTEX_TYPE_DEFAULT),
496: .condvar = condvar_create(CONDVAR_TYPE_DEFAULT),
497: );
498: return &this->public;
499: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rwlock.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / threading