aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/libs/libevent/evthread.c
diff options
context:
space:
mode:
authordldmitry <dldmitry@yandex-team.ru>2022-02-10 16:47:18 +0300
committerDaniil Cherednik <dcherednik@yandex-team.ru>2022-02-10 16:47:18 +0300
commit7b11682e84e98d5d48de2807faa6fd392685ae7e (patch)
tree9814fbd1c3effac9b8377c5d604b367b14e2db55 /contrib/libs/libevent/evthread.c
parent10129030876638368b8965c627671fe44be079bc (diff)
downloadydb-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.c706
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