From b5f8ee61a7f7e9bd291dd26b0585d03eb686c941 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 5 May 2024 13:19:16 +0200 Subject: Adding upstream version 1.46.3. Signed-off-by: Daniel Baumann --- .../lib/monkey/mk_core/deps/libevent/evthread.c | 509 --------------------- 1 file changed, 509 deletions(-) delete mode 100644 fluent-bit/lib/monkey/mk_core/deps/libevent/evthread.c (limited to 'fluent-bit/lib/monkey/mk_core/deps/libevent/evthread.c') diff --git a/fluent-bit/lib/monkey/mk_core/deps/libevent/evthread.c b/fluent-bit/lib/monkey/mk_core/deps/libevent/evthread.c deleted file mode 100644 index f3f1eddc8..000000000 --- a/fluent-bit/lib/monkey/mk_core/deps/libevent/evthread.c +++ /dev/null @@ -1,509 +0,0 @@ -/* - * 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 -#include - -#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 */ -GLOBAL int evthread_lock_debugging_enabled_ = 0; -GLOBAL struct evthread_lock_callbacks evthread_lock_fns_ = { - 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 */ -static struct evthread_lock_callbacks original_lock_fns_ = { - 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)) -{ - evthread_id_fn_ = id_fn; -} - -struct evthread_lock_callbacks *evthread_get_lock_callbacks() -{ - return evthread_lock_debugging_enabled_ - ? &original_lock_fns_ : &evthread_lock_fns_; -} -struct evthread_condition_callbacks *evthread_get_condition_callbacks() -{ - return evthread_lock_debugging_enabled_ - ? &original_cond_fns_ : &evthread_cond_fns_; -} -void evthreadimpl_disable_lock_debugging_(void) -{ - evthread_lock_debugging_enabled_ = 0; -} - -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_) { - event_errx(1, "evthread initialization must be called BEFORE anything else!"); - } - } -#endif - - 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) { - 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) -{ - 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_) { - event_errx(1, "evthread initialization must be called BEFORE anything else!"); - } - } -#endif - - 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) { - 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; -} - -#define DEBUG_LOCK_SIG 0xdeb0b10c - -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; - 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; - } - 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); - 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->signature = 0x12300fda; - 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); - if (evthread_id_fn_) { - 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 (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) -{ - 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 (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 (original_lock_fns_.unlock) - res = original_lock_fns_.unlock(mode, lock->lock); - return res; -} - -static int -debug_cond_wait(void *cond_, void *lock_, const struct timeval *tv) -{ - int r; - struct debug_lock *lock = lock_; - EVUTIL_ASSERT(lock); - EVUTIL_ASSERT(DEBUG_LOCK_SIG == lock->signature); - EVLOCK_ASSERT_LOCKED(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; -} - -/* misspelled version for backward compatibility */ -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 - }; - if (evthread_lock_debugging_enabled_) - return; - memcpy(&original_lock_fns_, &evthread_lock_fns_, - sizeof(struct evthread_lock_callbacks)); - memcpy(&evthread_lock_fns_, &cbs, - sizeof(struct evthread_lock_callbacks)); - - memcpy(&original_cond_fns_, &evthread_cond_fns_, - 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 -evthread_is_debug_lock_held_(void *lock_) -{ - 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 * -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. */ - - if (!enable_locks && original_lock_fns_.alloc == NULL) { - /* 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 */ - original_lock_fns_.free(lock_, locktype); - 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; - } else if (enable_locks && ! evthread_lock_debugging_enabled_) { - /* 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 */ - struct debug_lock *lock = lock_ ? lock_ : debug_lock_alloc(locktype); - EVUTIL_ASSERT(enable_locks && - evthread_lock_debugging_enabled_); - EVUTIL_ASSERT(lock->locktype == locktype); - if (!lock->lock) { - lock->lock = original_lock_fns_.alloc( - locktype|EVTHREAD_LOCKTYPE_RECURSIVE); - if (!lock->lock) { - lock->count = -200; - mm_free(lock); - return NULL; - } - } - return lock; - } -} - - -#ifndef EVTHREAD_EXPOSE_STRUCTS -unsigned long -evthreadimpl_get_id_() -{ - return evthread_id_fn_ ? evthread_id_fn_() : 1; -} -void * -evthreadimpl_lock_alloc_(unsigned locktype) -{ -#ifndef EVENT__DISABLE_DEBUG_MODE - if (event_debug_mode_on_) { - event_debug_created_threadable_ctx_ = 1; - } -#endif - - return evthread_lock_fns_.alloc ? - evthread_lock_fns_.alloc(locktype) : NULL; -} -void -evthreadimpl_lock_free_(void *lock, unsigned locktype) -{ - if (evthread_lock_fns_.free) - evthread_lock_fns_.free(lock, locktype); -} -int -evthreadimpl_lock_lock_(unsigned mode, void *lock) -{ - if (evthread_lock_fns_.lock) - return evthread_lock_fns_.lock(mode, lock); - 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 * -evthreadimpl_cond_alloc_(unsigned condtype) -{ -#ifndef EVENT__DISABLE_DEBUG_MODE - if (event_debug_mode_on_) { - event_debug_created_threadable_ctx_ = 1; - } -#endif - - return evthread_cond_fns_.alloc_condition ? - evthread_cond_fns_.alloc_condition(condtype) : NULL; -} -void -evthreadimpl_cond_free_(void *cond) -{ - if (evthread_cond_fns_.free_condition) - evthread_cond_fns_.free_condition(cond); -} -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 -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 -evthreadimpl_is_lock_debugging_enabled_(void) -{ - return evthread_lock_debugging_enabled_; -} - -int -evthreadimpl_locking_enabled_(void) -{ - return evthread_lock_fns_.lock != NULL; -} -#endif - -#endif -- cgit v1.2.3