2 * Copyright (c) 2008-2010 Niels Provos, Nick Mathewson
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 #include "event2/event-config.h"
29 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
31 #include "event2/thread.h"
36 #include "log-internal.h"
37 #include "mm-internal.h"
38 #include "util-internal.h"
39 #include "evthread-internal.h"
41 #ifdef EVTHREAD_EXPOSE_STRUCTS
48 GLOBAL int _evthread_lock_debugging_enabled = 0;
49 GLOBAL struct evthread_lock_callbacks _evthread_lock_fns = {
50 0, 0, NULL, NULL, NULL, NULL
52 GLOBAL unsigned long (*_evthread_id_fn)(void) = NULL;
53 GLOBAL struct evthread_condition_callbacks _evthread_cond_fns = {
54 0, NULL, NULL, NULL, NULL
57 /* Used for debugging */
58 static struct evthread_lock_callbacks _original_lock_fns = {
59 0, 0, NULL, NULL, NULL, NULL
61 static struct evthread_condition_callbacks _original_cond_fns = {
62 0, NULL, NULL, NULL, NULL
66 evthread_set_id_callback(unsigned long (*id_fn)(void))
68 _evthread_id_fn = id_fn;
72 evthread_set_lock_callbacks(const struct evthread_lock_callbacks *cbs)
74 struct evthread_lock_callbacks *target =
75 _evthread_lock_debugging_enabled
76 ? &_original_lock_fns : &_evthread_lock_fns;
79 memset(target, 0, sizeof(_evthread_lock_fns));
82 if (cbs->alloc && cbs->free && cbs->lock && cbs->unlock) {
83 memcpy(target, cbs, sizeof(_evthread_lock_fns));
91 evthread_set_condition_callbacks(const struct evthread_condition_callbacks *cbs)
93 struct evthread_condition_callbacks *target =
94 _evthread_lock_debugging_enabled
95 ? &_original_cond_fns : &_evthread_cond_fns;
98 memset(target, 0, sizeof(_evthread_cond_fns));
99 } else if (cbs->alloc_condition && cbs->free_condition &&
100 cbs->signal_condition && cbs->wait_condition) {
101 memcpy(target, cbs, sizeof(_evthread_cond_fns));
103 if (_evthread_lock_debugging_enabled) {
104 _evthread_cond_fns.alloc_condition = cbs->alloc_condition;
105 _evthread_cond_fns.free_condition = cbs->free_condition;
106 _evthread_cond_fns.signal_condition = cbs->signal_condition;
113 unsigned long held_by;
114 /* XXXX if we ever use read-write locks, we will need a separate
115 * lock to protect count. */
121 debug_lock_alloc(unsigned locktype)
123 struct debug_lock *result = mm_malloc(sizeof(struct debug_lock));
126 if (_original_lock_fns.alloc) {
127 if (!(result->lock = _original_lock_fns.alloc(
128 locktype|EVTHREAD_LOCKTYPE_RECURSIVE))) {
135 result->locktype = locktype;
142 debug_lock_free(void *lock_, unsigned locktype)
144 struct debug_lock *lock = lock_;
145 EVUTIL_ASSERT(lock->count == 0);
146 EVUTIL_ASSERT(locktype == lock->locktype);
147 if (_original_lock_fns.free) {
148 _original_lock_fns.free(lock->lock,
149 lock->locktype|EVTHREAD_LOCKTYPE_RECURSIVE);
157 evthread_debug_lock_mark_locked(unsigned mode, struct debug_lock *lock)
160 if (!(lock->locktype & EVTHREAD_LOCKTYPE_RECURSIVE))
161 EVUTIL_ASSERT(lock->count == 1);
162 if (_evthread_id_fn) {
164 me = _evthread_id_fn();
166 EVUTIL_ASSERT(lock->held_by == me);
172 debug_lock_lock(unsigned mode, void *lock_)
174 struct debug_lock *lock = lock_;
176 if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE)
177 EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE));
179 EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0);
180 if (_original_lock_fns.lock)
181 res = _original_lock_fns.lock(mode, lock->lock);
183 evthread_debug_lock_mark_locked(mode, lock);
189 evthread_debug_lock_mark_unlocked(unsigned mode, struct debug_lock *lock)
191 if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE)
192 EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE));
194 EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0);
195 if (_evthread_id_fn) {
196 EVUTIL_ASSERT(lock->held_by == _evthread_id_fn());
197 if (lock->count == 1)
201 EVUTIL_ASSERT(lock->count >= 0);
205 debug_lock_unlock(unsigned mode, void *lock_)
207 struct debug_lock *lock = lock_;
209 evthread_debug_lock_mark_unlocked(mode, lock);
210 if (_original_lock_fns.unlock)
211 res = _original_lock_fns.unlock(mode, lock->lock);
216 debug_cond_wait(void *_cond, void *_lock, const struct timeval *tv)
219 struct debug_lock *lock = _lock;
220 EVLOCK_ASSERT_LOCKED(_lock);
221 evthread_debug_lock_mark_unlocked(0, lock);
222 r = _original_cond_fns.wait_condition(_cond, lock->lock, tv);
223 evthread_debug_lock_mark_locked(0, lock);
228 evthread_enable_lock_debuging(void)
230 struct evthread_lock_callbacks cbs = {
231 EVTHREAD_LOCK_API_VERSION,
232 EVTHREAD_LOCKTYPE_RECURSIVE,
238 if (_evthread_lock_debugging_enabled)
240 memcpy(&_original_lock_fns, &_evthread_lock_fns,
241 sizeof(struct evthread_lock_callbacks));
242 memcpy(&_evthread_lock_fns, &cbs,
243 sizeof(struct evthread_lock_callbacks));
245 memcpy(&_original_cond_fns, &_evthread_cond_fns,
246 sizeof(struct evthread_condition_callbacks));
247 _evthread_cond_fns.wait_condition = debug_cond_wait;
248 _evthread_lock_debugging_enabled = 1;
252 _evthread_is_debug_lock_held(void *lock_)
254 struct debug_lock *lock = lock_;
257 if (_evthread_id_fn) {
258 unsigned long me = _evthread_id_fn();
259 if (lock->held_by != me)
266 _evthread_debug_get_real_lock(void *lock_)
268 struct debug_lock *lock = lock_;
272 #ifndef EVTHREAD_EXPOSE_STRUCTS
274 _evthreadimpl_get_id()
276 return _evthread_id_fn ? _evthread_id_fn() : 1;
279 _evthreadimpl_lock_alloc(unsigned locktype)
281 return _evthread_lock_fns.alloc ?
282 _evthread_lock_fns.alloc(locktype) : NULL;
285 _evthreadimpl_lock_free(void *lock, unsigned locktype)
287 if (_evthread_lock_fns.free)
288 _evthread_lock_fns.free(lock, locktype);
291 _evthreadimpl_lock_lock(unsigned mode, void *lock)
293 if (_evthread_lock_fns.lock)
294 return _evthread_lock_fns.lock(mode, lock);
299 _evthreadimpl_lock_unlock(unsigned mode, void *lock)
301 if (_evthread_lock_fns.unlock)
302 return _evthread_lock_fns.unlock(mode, lock);
307 _evthreadimpl_cond_alloc(unsigned condtype)
309 return _evthread_cond_fns.alloc_condition ?
310 _evthread_cond_fns.alloc_condition(condtype) : NULL;
313 _evthreadimpl_cond_free(void *cond)
315 if (_evthread_cond_fns.free_condition)
316 _evthread_cond_fns.free_condition(cond);
319 _evthreadimpl_cond_signal(void *cond, int broadcast)
321 if (_evthread_cond_fns.signal_condition)
322 return _evthread_cond_fns.signal_condition(cond, broadcast);
327 _evthreadimpl_cond_wait(void *cond, void *lock, const struct timeval *tv)
329 if (_evthread_cond_fns.wait_condition)
330 return _evthread_cond_fns.wait_condition(cond, lock, tv);
335 _evthreadimpl_is_lock_debugging_enabled(void)
337 return _evthread_lock_debugging_enabled;