libevent/dist/evthread.c

/*        $NetBSD: evthread.c,v 1.3 2021/04/07 03:36:48 christos Exp $          */

/*
 * 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 <sys/cdefs.h>
__RCSID("$NetBSD: evthread.c,v 1.3 2021/04/07 03:36:48 christos Exp $");
#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

#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 probably 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 probably 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