diff options
author | dldmitry <dldmitry@yandex-team.ru> | 2022-02-10 16:47:18 +0300 |
---|---|---|
committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:47:18 +0300 |
commit | 7b11682e84e98d5d48de2807faa6fd392685ae7e (patch) | |
tree | 9814fbd1c3effac9b8377c5d604b367b14e2db55 /contrib/libs/libevent/evthread.c | |
parent | 10129030876638368b8965c627671fe44be079bc (diff) | |
download | ydb-7b11682e84e98d5d48de2807faa6fd392685ae7e.tar.gz |
Restoring authorship annotation for <dldmitry@yandex-team.ru>. Commit 2 of 2.
Diffstat (limited to 'contrib/libs/libevent/evthread.c')
-rw-r--r-- | contrib/libs/libevent/evthread.c | 706 |
1 files changed, 353 insertions, 353 deletions
diff --git a/contrib/libs/libevent/evthread.c b/contrib/libs/libevent/evthread.c index 5d8e914a48..3eac594d64 100644 --- a/contrib/libs/libevent/evthread.c +++ b/contrib/libs/libevent/evthread.c @@ -1,79 +1,79 @@ -/* - * Copyright (c) 2008-2012 Niels Provos, Nick Mathewson - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "event2/event-config.h" +/* + * Copyright (c) 2008-2012 Niels Provos, Nick Mathewson + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "event2/event-config.h" #include "evconfig-private.h" - + #ifndef EVENT__DISABLE_THREAD_SUPPORT - -#include "event2/thread.h" - -#include <stdlib.h> -#include <string.h> - -#include "log-internal.h" -#include "mm-internal.h" -#include "util-internal.h" -#include "evthread-internal.h" - -#ifdef EVTHREAD_EXPOSE_STRUCTS -#define GLOBAL -#else -#define GLOBAL static -#endif - + +#include "event2/thread.h" + +#include <stdlib.h> +#include <string.h> + +#include "log-internal.h" +#include "mm-internal.h" +#include "util-internal.h" +#include "evthread-internal.h" + +#ifdef EVTHREAD_EXPOSE_STRUCTS +#define GLOBAL +#else +#define GLOBAL static +#endif + #ifndef EVENT__DISABLE_DEBUG_MODE extern int event_debug_created_threadable_ctx_; extern int event_debug_mode_on_; #endif -/* globals */ +/* globals */ GLOBAL int evthread_lock_debugging_enabled_ = 0; GLOBAL struct evthread_lock_callbacks evthread_lock_fns_ = { - 0, 0, NULL, NULL, NULL, NULL -}; + 0, 0, NULL, NULL, NULL, NULL +}; GLOBAL unsigned long (*evthread_id_fn_)(void) = NULL; GLOBAL struct evthread_condition_callbacks evthread_cond_fns_ = { - 0, NULL, NULL, NULL, NULL -}; - -/* Used for debugging */ + 0, NULL, NULL, NULL, NULL +}; + +/* Used for debugging */ static struct evthread_lock_callbacks original_lock_fns_ = { - 0, 0, NULL, NULL, NULL, NULL -}; + 0, 0, NULL, NULL, NULL, NULL +}; static struct evthread_condition_callbacks original_cond_fns_ = { - 0, NULL, NULL, NULL, NULL -}; - -void -evthread_set_id_callback(unsigned long (*id_fn)(void)) -{ + 0, NULL, NULL, NULL, NULL +}; + +void +evthread_set_id_callback(unsigned long (*id_fn)(void)) +{ evthread_id_fn_ = id_fn; -} - +} + struct evthread_lock_callbacks *evthread_get_lock_callbacks() { return evthread_lock_debugging_enabled_ @@ -89,11 +89,11 @@ void evthreadimpl_disable_lock_debugging_(void) evthread_lock_debugging_enabled_ = 0; } -int -evthread_set_lock_callbacks(const struct evthread_lock_callbacks *cbs) -{ +int +evthread_set_lock_callbacks(const struct evthread_lock_callbacks *cbs) +{ struct evthread_lock_callbacks *target = evthread_get_lock_callbacks(); - + #ifndef EVENT__DISABLE_DEBUG_MODE if (event_debug_mode_on_) { if (event_debug_created_threadable_ctx_) { @@ -102,41 +102,41 @@ evthread_set_lock_callbacks(const struct evthread_lock_callbacks *cbs) } #endif - if (!cbs) { - if (target->alloc) - event_warnx("Trying to disable lock functions after " - "they have been set up will probaby not work."); + if (!cbs) { + if (target->alloc) + event_warnx("Trying to disable lock functions after " + "they have been set up will probaby not work."); memset(target, 0, sizeof(evthread_lock_fns_)); - return 0; - } - if (target->alloc) { - /* Uh oh; we already had locking callbacks set up.*/ - if (target->lock_api_version == cbs->lock_api_version && - target->supported_locktypes == cbs->supported_locktypes && - target->alloc == cbs->alloc && - target->free == cbs->free && - target->lock == cbs->lock && - target->unlock == cbs->unlock) { - /* no change -- allow this. */ - return 0; - } - event_warnx("Can't change lock callbacks once they have been " - "initialized."); - return -1; - } - if (cbs->alloc && cbs->free && cbs->lock && cbs->unlock) { + return 0; + } + if (target->alloc) { + /* Uh oh; we already had locking callbacks set up.*/ + if (target->lock_api_version == cbs->lock_api_version && + target->supported_locktypes == cbs->supported_locktypes && + target->alloc == cbs->alloc && + target->free == cbs->free && + target->lock == cbs->lock && + target->unlock == cbs->unlock) { + /* no change -- allow this. */ + return 0; + } + event_warnx("Can't change lock callbacks once they have been " + "initialized."); + return -1; + } + if (cbs->alloc && cbs->free && cbs->lock && cbs->unlock) { memcpy(target, cbs, sizeof(evthread_lock_fns_)); - return event_global_setup_locks_(1); - } else { - return -1; - } -} - -int -evthread_set_condition_callbacks(const struct evthread_condition_callbacks *cbs) -{ + return event_global_setup_locks_(1); + } else { + return -1; + } +} + +int +evthread_set_condition_callbacks(const struct evthread_condition_callbacks *cbs) +{ struct evthread_condition_callbacks *target = evthread_get_condition_callbacks(); - + #ifndef EVENT__DISABLE_DEBUG_MODE if (event_debug_mode_on_) { if (event_debug_created_threadable_ctx_) { @@ -145,267 +145,267 @@ evthread_set_condition_callbacks(const struct evthread_condition_callbacks *cbs) } #endif - if (!cbs) { - if (target->alloc_condition) - event_warnx("Trying to disable condition functions " - "after they have been set up will probaby not " - "work."); + if (!cbs) { + if (target->alloc_condition) + event_warnx("Trying to disable condition functions " + "after they have been set up will probaby not " + "work."); memset(target, 0, sizeof(evthread_cond_fns_)); - return 0; - } - if (target->alloc_condition) { - /* Uh oh; we already had condition callbacks set up.*/ - if (target->condition_api_version == cbs->condition_api_version && - target->alloc_condition == cbs->alloc_condition && - target->free_condition == cbs->free_condition && - target->signal_condition == cbs->signal_condition && - target->wait_condition == cbs->wait_condition) { - /* no change -- allow this. */ - return 0; - } - event_warnx("Can't change condition callbacks once they " - "have been initialized."); - return -1; - } - if (cbs->alloc_condition && cbs->free_condition && - cbs->signal_condition && cbs->wait_condition) { + return 0; + } + if (target->alloc_condition) { + /* Uh oh; we already had condition callbacks set up.*/ + if (target->condition_api_version == cbs->condition_api_version && + target->alloc_condition == cbs->alloc_condition && + target->free_condition == cbs->free_condition && + target->signal_condition == cbs->signal_condition && + target->wait_condition == cbs->wait_condition) { + /* no change -- allow this. */ + return 0; + } + event_warnx("Can't change condition callbacks once they " + "have been initialized."); + return -1; + } + if (cbs->alloc_condition && cbs->free_condition && + cbs->signal_condition && cbs->wait_condition) { memcpy(target, cbs, sizeof(evthread_cond_fns_)); - } + } if (evthread_lock_debugging_enabled_) { evthread_cond_fns_.alloc_condition = cbs->alloc_condition; evthread_cond_fns_.free_condition = cbs->free_condition; evthread_cond_fns_.signal_condition = cbs->signal_condition; - } - return 0; -} - + } + return 0; +} + #define DEBUG_LOCK_SIG 0xdeb0b10c -struct debug_lock { +struct debug_lock { unsigned signature; - unsigned locktype; - unsigned long held_by; - /* XXXX if we ever use read-write locks, we will need a separate - * lock to protect count. */ - int count; - void *lock; -}; - -static void * -debug_lock_alloc(unsigned locktype) -{ - struct debug_lock *result = mm_malloc(sizeof(struct debug_lock)); - if (!result) - return NULL; + unsigned locktype; + unsigned long held_by; + /* XXXX if we ever use read-write locks, we will need a separate + * lock to protect count. */ + int count; + void *lock; +}; + +static void * +debug_lock_alloc(unsigned locktype) +{ + struct debug_lock *result = mm_malloc(sizeof(struct debug_lock)); + if (!result) + return NULL; if (original_lock_fns_.alloc) { if (!(result->lock = original_lock_fns_.alloc( - locktype|EVTHREAD_LOCKTYPE_RECURSIVE))) { - mm_free(result); - return NULL; - } - } else { - result->lock = NULL; - } + locktype|EVTHREAD_LOCKTYPE_RECURSIVE))) { + mm_free(result); + return NULL; + } + } else { + result->lock = NULL; + } result->signature = DEBUG_LOCK_SIG; - result->locktype = locktype; - result->count = 0; - result->held_by = 0; - return result; -} - -static void -debug_lock_free(void *lock_, unsigned locktype) -{ - struct debug_lock *lock = lock_; - EVUTIL_ASSERT(lock->count == 0); - EVUTIL_ASSERT(locktype == lock->locktype); + result->locktype = locktype; + result->count = 0; + result->held_by = 0; + return result; +} + +static void +debug_lock_free(void *lock_, unsigned locktype) +{ + struct debug_lock *lock = lock_; + EVUTIL_ASSERT(lock->count == 0); + EVUTIL_ASSERT(locktype == lock->locktype); EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature); if (original_lock_fns_.free) { original_lock_fns_.free(lock->lock, - lock->locktype|EVTHREAD_LOCKTYPE_RECURSIVE); - } - lock->lock = NULL; - lock->count = -100; + lock->locktype|EVTHREAD_LOCKTYPE_RECURSIVE); + } + lock->lock = NULL; + lock->count = -100; lock->signature = 0x12300fda; - mm_free(lock); -} - -static void -evthread_debug_lock_mark_locked(unsigned mode, struct debug_lock *lock) -{ + mm_free(lock); +} + +static void +evthread_debug_lock_mark_locked(unsigned mode, struct debug_lock *lock) +{ EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature); - ++lock->count; - if (!(lock->locktype & EVTHREAD_LOCKTYPE_RECURSIVE)) - EVUTIL_ASSERT(lock->count == 1); + ++lock->count; + if (!(lock->locktype & EVTHREAD_LOCKTYPE_RECURSIVE)) + EVUTIL_ASSERT(lock->count == 1); if (evthread_id_fn_) { - unsigned long me; + unsigned long me; me = evthread_id_fn_(); - if (lock->count > 1) - EVUTIL_ASSERT(lock->held_by == me); - lock->held_by = me; - } -} - -static int -debug_lock_lock(unsigned mode, void *lock_) -{ - struct debug_lock *lock = lock_; - int res = 0; - if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE) - EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE)); - else - EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0); + if (lock->count > 1) + EVUTIL_ASSERT(lock->held_by == me); + lock->held_by = me; + } +} + +static int +debug_lock_lock(unsigned mode, void *lock_) +{ + struct debug_lock *lock = lock_; + int res = 0; + if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE) + EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE)); + else + EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0); if (original_lock_fns_.lock) res = original_lock_fns_.lock(mode, lock->lock); - if (!res) { - evthread_debug_lock_mark_locked(mode, lock); - } - return res; -} - -static void -evthread_debug_lock_mark_unlocked(unsigned mode, struct debug_lock *lock) -{ + if (!res) { + evthread_debug_lock_mark_locked(mode, lock); + } + return res; +} + +static void +evthread_debug_lock_mark_unlocked(unsigned mode, struct debug_lock *lock) +{ EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature); - if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE) - EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE)); - else - EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0); + if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE) + EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE)); + else + EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0); if (evthread_id_fn_) { unsigned long me; me = evthread_id_fn_(); EVUTIL_ASSERT(lock->held_by == me); - if (lock->count == 1) - lock->held_by = 0; - } - --lock->count; - EVUTIL_ASSERT(lock->count >= 0); -} - -static int -debug_lock_unlock(unsigned mode, void *lock_) -{ - struct debug_lock *lock = lock_; - int res = 0; - evthread_debug_lock_mark_unlocked(mode, lock); + if (lock->count == 1) + lock->held_by = 0; + } + --lock->count; + EVUTIL_ASSERT(lock->count >= 0); +} + +static int +debug_lock_unlock(unsigned mode, void *lock_) +{ + struct debug_lock *lock = lock_; + int res = 0; + evthread_debug_lock_mark_unlocked(mode, lock); if (original_lock_fns_.unlock) res = original_lock_fns_.unlock(mode, lock->lock); - return res; -} - -static int + return res; +} + +static int debug_cond_wait(void *cond_, void *lock_, const struct timeval *tv) -{ - int r; +{ + int r; struct debug_lock *lock = lock_; - EVUTIL_ASSERT(lock); + EVUTIL_ASSERT(lock); EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature); EVLOCK_ASSERT_LOCKED(lock_); - evthread_debug_lock_mark_unlocked(0, lock); + evthread_debug_lock_mark_unlocked(0, lock); r = original_cond_fns_.wait_condition(cond_, lock->lock, tv); - evthread_debug_lock_mark_locked(0, lock); - return r; -} - + evthread_debug_lock_mark_locked(0, lock); + return r; +} + /* misspelled version for backward compatibility */ -void -evthread_enable_lock_debuging(void) -{ +void +evthread_enable_lock_debuging(void) +{ evthread_enable_lock_debugging(); } void evthread_enable_lock_debugging(void) { - struct evthread_lock_callbacks cbs = { - EVTHREAD_LOCK_API_VERSION, - EVTHREAD_LOCKTYPE_RECURSIVE, - debug_lock_alloc, - debug_lock_free, - debug_lock_lock, - debug_lock_unlock - }; + struct evthread_lock_callbacks cbs = { + EVTHREAD_LOCK_API_VERSION, + EVTHREAD_LOCKTYPE_RECURSIVE, + debug_lock_alloc, + debug_lock_free, + debug_lock_lock, + debug_lock_unlock + }; if (evthread_lock_debugging_enabled_) - return; + return; memcpy(&original_lock_fns_, &evthread_lock_fns_, - sizeof(struct evthread_lock_callbacks)); + sizeof(struct evthread_lock_callbacks)); memcpy(&evthread_lock_fns_, &cbs, - sizeof(struct evthread_lock_callbacks)); - + sizeof(struct evthread_lock_callbacks)); + memcpy(&original_cond_fns_, &evthread_cond_fns_, - sizeof(struct evthread_condition_callbacks)); + sizeof(struct evthread_condition_callbacks)); evthread_cond_fns_.wait_condition = debug_cond_wait; evthread_lock_debugging_enabled_ = 1; - - /* XXX return value should get checked. */ - event_global_setup_locks_(0); -} - -int + + /* XXX return value should get checked. */ + event_global_setup_locks_(0); +} + +int evthread_is_debug_lock_held_(void *lock_) -{ - struct debug_lock *lock = lock_; - if (! lock->count) - return 0; +{ + struct debug_lock *lock = lock_; + if (! lock->count) + return 0; if (evthread_id_fn_) { unsigned long me = evthread_id_fn_(); - if (lock->held_by != me) - return 0; - } - return 1; -} - -void * + if (lock->held_by != me) + return 0; + } + return 1; +} + +void * evthread_debug_get_real_lock_(void *lock_) -{ - struct debug_lock *lock = lock_; - return lock->lock; -} - -void * -evthread_setup_global_lock_(void *lock_, unsigned locktype, int enable_locks) -{ - /* there are four cases here: - 1) we're turning on debugging; locking is not on. - 2) we're turning on debugging; locking is on. - 3) we're turning on locking; debugging is not on. - 4) we're turning on locking; debugging is on. */ - +{ + struct debug_lock *lock = lock_; + return lock->lock; +} + +void * +evthread_setup_global_lock_(void *lock_, unsigned locktype, int enable_locks) +{ + /* there are four cases here: + 1) we're turning on debugging; locking is not on. + 2) we're turning on debugging; locking is on. + 3) we're turning on locking; debugging is not on. + 4) we're turning on locking; debugging is on. */ + if (!enable_locks && original_lock_fns_.alloc == NULL) { - /* Case 1: allocate a debug lock. */ - EVUTIL_ASSERT(lock_ == NULL); - return debug_lock_alloc(locktype); + /* Case 1: allocate a debug lock. */ + EVUTIL_ASSERT(lock_ == NULL); + return debug_lock_alloc(locktype); } else if (!enable_locks && original_lock_fns_.alloc != NULL) { - /* Case 2: wrap the lock in a debug lock. */ - struct debug_lock *lock; - EVUTIL_ASSERT(lock_ != NULL); - - if (!(locktype & EVTHREAD_LOCKTYPE_RECURSIVE)) { - /* We can't wrap it: We need a recursive lock */ + /* Case 2: wrap the lock in a debug lock. */ + struct debug_lock *lock; + EVUTIL_ASSERT(lock_ != NULL); + + if (!(locktype & EVTHREAD_LOCKTYPE_RECURSIVE)) { + /* We can't wrap it: We need a recursive lock */ original_lock_fns_.free(lock_, locktype); - return debug_lock_alloc(locktype); - } - lock = mm_malloc(sizeof(struct debug_lock)); - if (!lock) { + return debug_lock_alloc(locktype); + } + lock = mm_malloc(sizeof(struct debug_lock)); + if (!lock) { original_lock_fns_.free(lock_, locktype); - return NULL; - } - lock->lock = lock_; - lock->locktype = locktype; - lock->count = 0; - lock->held_by = 0; - return lock; + return NULL; + } + lock->lock = lock_; + lock->locktype = locktype; + lock->count = 0; + lock->held_by = 0; + return lock; } else if (enable_locks && ! evthread_lock_debugging_enabled_) { - /* Case 3: allocate a regular lock */ - EVUTIL_ASSERT(lock_ == NULL); + /* Case 3: allocate a regular lock */ + EVUTIL_ASSERT(lock_ == NULL); return evthread_lock_fns_.alloc(locktype); - } else { - /* Case 4: Fill in a debug lock with a real lock */ + } else { + /* Case 4: Fill in a debug lock with a real lock */ struct debug_lock *lock = lock_ ? lock_ : debug_lock_alloc(locktype); - EVUTIL_ASSERT(enable_locks && + EVUTIL_ASSERT(enable_locks && evthread_lock_debugging_enabled_); - EVUTIL_ASSERT(lock->locktype == locktype); - if (!lock->lock) { + EVUTIL_ASSERT(lock->locktype == locktype); + if (!lock->lock) { lock->lock = original_lock_fns_.alloc( locktype|EVTHREAD_LOCKTYPE_RECURSIVE); if (!lock->lock) { @@ -413,21 +413,21 @@ evthread_setup_global_lock_(void *lock_, unsigned locktype, int enable_locks) mm_free(lock); return NULL; } - } - return lock; - } -} - - -#ifndef EVTHREAD_EXPOSE_STRUCTS -unsigned long + } + return lock; + } +} + + +#ifndef EVTHREAD_EXPOSE_STRUCTS +unsigned long evthreadimpl_get_id_() -{ +{ return evthread_id_fn_ ? evthread_id_fn_() : 1; -} -void * +} +void * evthreadimpl_lock_alloc_(unsigned locktype) -{ +{ #ifndef EVENT__DISABLE_DEBUG_MODE if (event_debug_mode_on_) { event_debug_created_threadable_ctx_ = 1; @@ -436,32 +436,32 @@ evthreadimpl_lock_alloc_(unsigned locktype) return evthread_lock_fns_.alloc ? evthread_lock_fns_.alloc(locktype) : NULL; -} -void +} +void evthreadimpl_lock_free_(void *lock, unsigned locktype) -{ +{ if (evthread_lock_fns_.free) evthread_lock_fns_.free(lock, locktype); -} -int +} +int evthreadimpl_lock_lock_(unsigned mode, void *lock) -{ +{ if (evthread_lock_fns_.lock) return evthread_lock_fns_.lock(mode, lock); - else - return 0; -} -int + else + return 0; +} +int evthreadimpl_lock_unlock_(unsigned mode, void *lock) -{ +{ if (evthread_lock_fns_.unlock) return evthread_lock_fns_.unlock(mode, lock); - else - return 0; -} -void * + else + return 0; +} +void * evthreadimpl_cond_alloc_(unsigned condtype) -{ +{ #ifndef EVENT__DISABLE_DEBUG_MODE if (event_debug_mode_on_) { event_debug_created_threadable_ctx_ = 1; @@ -470,40 +470,40 @@ evthreadimpl_cond_alloc_(unsigned condtype) return evthread_cond_fns_.alloc_condition ? evthread_cond_fns_.alloc_condition(condtype) : NULL; -} -void +} +void evthreadimpl_cond_free_(void *cond) -{ +{ if (evthread_cond_fns_.free_condition) evthread_cond_fns_.free_condition(cond); -} -int +} +int evthreadimpl_cond_signal_(void *cond, int broadcast) -{ +{ if (evthread_cond_fns_.signal_condition) return evthread_cond_fns_.signal_condition(cond, broadcast); - else - return 0; -} -int + else + return 0; +} +int evthreadimpl_cond_wait_(void *cond, void *lock, const struct timeval *tv) -{ +{ if (evthread_cond_fns_.wait_condition) return evthread_cond_fns_.wait_condition(cond, lock, tv); - else - return 0; -} -int + else + return 0; +} +int evthreadimpl_is_lock_debugging_enabled_(void) -{ +{ return evthread_lock_debugging_enabled_; -} - -int +} + +int evthreadimpl_locking_enabled_(void) -{ +{ return evthread_lock_fns_.lock != NULL; -} -#endif - -#endif +} +#endif + +#endif |