external/bsd/libevent/dist/evthread.c

   1 /*      $NetBSD: evthread.c,v 1.1.1.1 2013/04/11 16:43:25 christos Exp $        */
   2 /*
   3  * Copyright (c) 2008-2012 Niels Provos, Nick Mathewson
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. The name of the author may not be used to endorse or promote products
  14  *    derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "event2/event-config.h"
  29 #include <sys/cdefs.h>
  30 __RCSID("$NetBSD: evthread.c,v 1.1.1.1 2013/04/11 16:43:25 christos Exp $");
  31
  32 #ifndef _EVENT_DISABLE_THREAD_SUPPORT
  33
  34 #include "event2/thread.h"
  35
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #include "log-internal.h"
  40 #include "mm-internal.h"
  41 #include "util-internal.h"
  42 #include "evthread-internal.h"
  43
  44 #ifdef EVTHREAD_EXPOSE_STRUCTS
  45 #define GLOBAL
  46 #else
  47 #define GLOBAL static
  48 #endif
  49
  50 /* globals */
  51 GLOBAL int _evthread_lock_debugging_enabled = 0;
  52 GLOBAL struct evthread_lock_callbacks _evthread_lock_fns = {
  53         0, 0, NULL, NULL, NULL, NULL
  54 };
  55 GLOBAL unsigned long (*_evthread_id_fn)(void) = NULL;
  56 GLOBAL struct evthread_condition_callbacks _evthread_cond_fns = {
  57         0, NULL, NULL, NULL, NULL
  58 };
  59
  60 /* Used for debugging */
  61 static struct evthread_lock_callbacks _original_lock_fns = {
  62         0, 0, NULL, NULL, NULL, NULL
  63 };
  64 static struct evthread_condition_callbacks _original_cond_fns = {
  65         0, NULL, NULL, NULL, NULL
  66 };
  67
  68 void
  69 evthread_set_id_callback(unsigned long (*id_fn)(void))
  70 {
  71         _evthread_id_fn = id_fn;
  72 }
  73
  74 int
  75 evthread_set_lock_callbacks(const struct evthread_lock_callbacks *cbs)
  76 {
  77         struct evthread_lock_callbacks *target =
  78             _evthread_lock_debugging_enabled
  79             ? &_original_lock_fns : &_evthread_lock_fns;
  80
  81         if (!cbs) {
  82                 if (target->alloc)
  83                         event_warnx("Trying to disable lock functions after "
  84                             "they have been set up will probaby not work.");
  85                 memset(target, 0, sizeof(_evthread_lock_fns));
  86                 return 0;
  87         }
  88         if (target->alloc) {
  89                 /* Uh oh; we already had locking callbacks set up.*/
  90                 if (target->lock_api_version == cbs->lock_api_version &&
  91                         target->supported_locktypes == cbs->supported_locktypes &&
  92                         target->alloc == cbs->alloc &&
  93                         target->free == cbs->free &&
  94                         target->lock == cbs->lock &&
  95                         target->unlock == cbs->unlock) {
  96                         /* no change -- allow this. */
  97                         return 0;
  98                 }
  99                 event_warnx("Can't change lock callbacks once they have been "
 100                     "initialized.");
 101                 return -1;
 102         }
 103         if (cbs->alloc && cbs->free && cbs->lock && cbs->unlock) {
 104                 memcpy(target, cbs, sizeof(_evthread_lock_fns));
 105                 return event_global_setup_locks_(1);
 106         } else {
 107                 return -1;
 108         }
 109 }
 110
 111 int
 112 evthread_set_condition_callbacks(const struct evthread_condition_callbacks *cbs)
 113 {
 114         struct evthread_condition_callbacks *target =
 115             _evthread_lock_debugging_enabled
 116             ? &_original_cond_fns : &_evthread_cond_fns;
 117
 118         if (!cbs) {
 119                 if (target->alloc_condition)
 120                         event_warnx("Trying to disable condition functions "
 121                             "after they have been set up will probaby not "
 122                             "work.");
 123                 memset(target, 0, sizeof(_evthread_cond_fns));
 124                 return 0;
 125         }
 126         if (target->alloc_condition) {
 127                 /* Uh oh; we already had condition callbacks set up.*/
 128                 if (target->condition_api_version == cbs->condition_api_version &&
 129                         target->alloc_condition == cbs->alloc_condition &&
 130                         target->free_condition == cbs->free_condition &&
 131                         target->signal_condition == cbs->signal_condition &&
 132                         target->wait_condition == cbs->wait_condition) {
 133                         /* no change -- allow this. */
 134                         return 0;
 135                 }
 136                 event_warnx("Can't change condition callbacks once they "
 137                     "have been initialized.");
 138                 return -1;
 139         }
 140         if (cbs->alloc_condition && cbs->free_condition &&
 141             cbs->signal_condition && cbs->wait_condition) {
 142                 memcpy(target, cbs, sizeof(_evthread_cond_fns));
 143         }
 144         if (_evthread_lock_debugging_enabled) {
 145                 _evthread_cond_fns.alloc_condition = cbs->alloc_condition;
 146                 _evthread_cond_fns.free_condition = cbs->free_condition;
 147                 _evthread_cond_fns.signal_condition = cbs->signal_condition;
 148         }
 149         return 0;
 150 }
 151
 152 struct debug_lock {
 153         unsigned locktype;
 154         unsigned long held_by;
 155         /* XXXX if we ever use read-write locks, we will need a separate
 156          * lock to protect count. */
 157         int count;
 158         void *lock;
 159 };
 160
 161 static void *
 162 debug_lock_alloc(unsigned locktype)
 163 {
 164         struct debug_lock *result = mm_malloc(sizeof(struct debug_lock));
 165         if (!result)
 166                 return NULL;
 167         if (_original_lock_fns.alloc) {
 168                 if (!(result->lock = _original_lock_fns.alloc(
 169                                 locktype|EVTHREAD_LOCKTYPE_RECURSIVE))) {
 170                         mm_free(result);
 171                         return NULL;
 172                 }
 173         } else {
 174                 result->lock = NULL;
 175         }
 176         result->locktype = locktype;
 177         result->count = 0;
 178         result->held_by = 0;
 179         return result;
 180 }
 181
 182 static void
 183 debug_lock_free(void *lock_, unsigned locktype)
 184 {
 185         struct debug_lock *lock = lock_;
 186         EVUTIL_ASSERT(lock->count == 0);
 187         EVUTIL_ASSERT(locktype == lock->locktype);
 188         if (_original_lock_fns.free) {
 189                 _original_lock_fns.free(lock->lock,
 190                     lock->locktype|EVTHREAD_LOCKTYPE_RECURSIVE);
 191         }
 192         lock->lock = NULL;
 193         lock->count = -100;
 194         mm_free(lock);
 195 }
 196
 197 static void
 198 evthread_debug_lock_mark_locked(unsigned mode, struct debug_lock *lock)
 199 {
 200         ++lock->count;
 201         if (!(lock->locktype & EVTHREAD_LOCKTYPE_RECURSIVE))
 202                 EVUTIL_ASSERT(lock->count == 1);
 203         if (_evthread_id_fn) {
 204                 unsigned long me;
 205                 me = _evthread_id_fn();
 206                 if (lock->count > 1)
 207                         EVUTIL_ASSERT(lock->held_by == me);
 208                 lock->held_by = me;
 209         }
 210 }
 211
 212 static int
 213 debug_lock_lock(unsigned mode, void *lock_)
 214 {
 215         struct debug_lock *lock = lock_;
 216         int res = 0;
 217         if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE)
 218                 EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE));
 219         else
 220                 EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0);
 221         if (_original_lock_fns.lock)
 222                 res = _original_lock_fns.lock(mode, lock->lock);
 223         if (!res) {
 224                 evthread_debug_lock_mark_locked(mode, lock);
 225         }
 226         return res;
 227 }
 228
 229 static void
 230 evthread_debug_lock_mark_unlocked(unsigned mode, struct debug_lock *lock)
 231 {
 232         if (lock->locktype & EVTHREAD_LOCKTYPE_READWRITE)
 233                 EVUTIL_ASSERT(mode & (EVTHREAD_READ|EVTHREAD_WRITE));
 234         else
 235                 EVUTIL_ASSERT((mode & (EVTHREAD_READ|EVTHREAD_WRITE)) == 0);
 236         if (_evthread_id_fn) {
 237                 EVUTIL_ASSERT(lock->held_by == _evthread_id_fn());
 238                 if (lock->count == 1)
 239                         lock->held_by = 0;
 240         }
 241         --lock->count;
 242         EVUTIL_ASSERT(lock->count >= 0);
 243 }
 244
 245 static int
 246 debug_lock_unlock(unsigned mode, void *lock_)
 247 {
 248         struct debug_lock *lock = lock_;
 249         int res = 0;
 250         evthread_debug_lock_mark_unlocked(mode, lock);
 251         if (_original_lock_fns.unlock)
 252                 res = _original_lock_fns.unlock(mode, lock->lock);
 253         return res;
 254 }
 255
 256 static int
 257 debug_cond_wait(void *_cond, void *_lock, const struct timeval *tv)
 258 {
 259         int r;
 260         struct debug_lock *lock = _lock;
 261         EVUTIL_ASSERT(lock);
 262         EVLOCK_ASSERT_LOCKED(_lock);
 263         evthread_debug_lock_mark_unlocked(0, lock);
 264         r = _original_cond_fns.wait_condition(_cond, lock->lock, tv);
 265         evthread_debug_lock_mark_locked(0, lock);
 266         return r;
 267 }
 268
 269 void
 270 evthread_enable_lock_debuging(void)
 271 {
 272         struct evthread_lock_callbacks cbs = {
 273                 EVTHREAD_LOCK_API_VERSION,
 274                 EVTHREAD_LOCKTYPE_RECURSIVE,
 275                 debug_lock_alloc,
 276                 debug_lock_free,
 277                 debug_lock_lock,
 278                 debug_lock_unlock
 279         };
 280         if (_evthread_lock_debugging_enabled)
 281                 return;
 282         memcpy(&_original_lock_fns, &_evthread_lock_fns,
 283             sizeof(struct evthread_lock_callbacks));
 284         memcpy(&_evthread_lock_fns, &cbs,
 285             sizeof(struct evthread_lock_callbacks));
 286
 287         memcpy(&_original_cond_fns, &_evthread_cond_fns,
 288             sizeof(struct evthread_condition_callbacks));
 289         _evthread_cond_fns.wait_condition = debug_cond_wait;
 290         _evthread_lock_debugging_enabled = 1;
 291
 292         /* XXX return value should get checked. */
 293         event_global_setup_locks_(0);
 294 }
 295
 296 int
 297 _evthread_is_debug_lock_held(void *lock_)
 298 {
 299         struct debug_lock *lock = lock_;
 300         if (! lock->count)
 301                 return 0;
 302         if (_evthread_id_fn) {
 303                 unsigned long me = _evthread_id_fn();
 304                 if (lock->held_by != me)
 305                         return 0;
 306         }
 307         return 1;
 308 }
 309
 310 void *
 311 _evthread_debug_get_real_lock(void *lock_)
 312 {
 313         struct debug_lock *lock = lock_;
 314         return lock->lock;
 315 }
 316
 317 void *
 318 evthread_setup_global_lock_(void *lock_, unsigned locktype, int enable_locks)
 319 {
 320         /* there are four cases here:
 321            1) we're turning on debugging; locking is not on.
 322            2) we're turning on debugging; locking is on.
 323            3) we're turning on locking; debugging is not on.
 324            4) we're turning on locking; debugging is on. */
 325
 326         if (!enable_locks && _original_lock_fns.alloc == NULL) {
 327                 /* Case 1: allocate a debug lock. */
 328                 EVUTIL_ASSERT(lock_ == NULL);
 329                 return debug_lock_alloc(locktype);
 330         } else if (!enable_locks && _original_lock_fns.alloc != NULL) {
 331                 /* Case 2: wrap the lock in a debug lock. */
 332                 struct debug_lock *lock;
 333                 EVUTIL_ASSERT(lock_ != NULL);
 334
 335                 if (!(locktype & EVTHREAD_LOCKTYPE_RECURSIVE)) {
 336                         /* We can't wrap it: We need a recursive lock */
 337                         _original_lock_fns.free(lock_, locktype);
 338                         return debug_lock_alloc(locktype);
 339                 }
 340                 lock = mm_malloc(sizeof(struct debug_lock));
 341                 if (!lock) {
 342                         _original_lock_fns.free(lock_, locktype);
 343                         return NULL;
 344                 }
 345                 lock->lock = lock_;
 346                 lock->locktype = locktype;
 347                 lock->count = 0;
 348                 lock->held_by = 0;
 349                 return lock;
 350         } else if (enable_locks && ! _evthread_lock_debugging_enabled) {
 351                 /* Case 3: allocate a regular lock */
 352                 EVUTIL_ASSERT(lock_ == NULL);
 353                 return _evthread_lock_fns.alloc(locktype);
 354         } else {
 355                 /* Case 4: Fill in a debug lock with a real lock */
 356                 struct debug_lock *lock = lock_;
 357                 EVUTIL_ASSERT(enable_locks &&
 358                               _evthread_lock_debugging_enabled);
 359                 EVUTIL_ASSERT(lock->locktype == locktype);
 360                 EVUTIL_ASSERT(lock->lock == NULL);
 361                 lock->lock = _original_lock_fns.alloc(
 362                         locktype|EVTHREAD_LOCKTYPE_RECURSIVE);
 363                 if (!lock->lock) {
 364                         lock->count = -200;
 365                         mm_free(lock);
 366                         return NULL;
 367                 }
 368                 return lock;
 369         }
 370 }
 371
 372
 373 #ifndef EVTHREAD_EXPOSE_STRUCTS
 374 unsigned long
 375 _evthreadimpl_get_id()
 376 {
 377         return _evthread_id_fn ? _evthread_id_fn() : 1;
 378 }
 379 void *
 380 _evthreadimpl_lock_alloc(unsigned locktype)
 381 {
 382         return _evthread_lock_fns.alloc ?
 383             _evthread_lock_fns.alloc(locktype) : NULL;
 384 }
 385 void
 386 _evthreadimpl_lock_free(void *lock, unsigned locktype)
 387 {
 388         if (_evthread_lock_fns.free)
 389                 _evthread_lock_fns.free(lock, locktype);
 390 }
 391 int
 392 _evthreadimpl_lock_lock(unsigned mode, void *lock)
 393 {
 394         if (_evthread_lock_fns.lock)
 395                 return _evthread_lock_fns.lock(mode, lock);
 396         else
 397                 return 0;
 398 }
 399 int
 400 _evthreadimpl_lock_unlock(unsigned mode, void *lock)
 401 {
 402         if (_evthread_lock_fns.unlock)
 403                 return _evthread_lock_fns.unlock(mode, lock);
 404         else
 405                 return 0;
 406 }
 407 void *
 408 _evthreadimpl_cond_alloc(unsigned condtype)
 409 {
 410         return _evthread_cond_fns.alloc_condition ?
 411             _evthread_cond_fns.alloc_condition(condtype) : NULL;
 412 }
 413 void
 414 _evthreadimpl_cond_free(void *cond)
 415 {
 416         if (_evthread_cond_fns.free_condition)
 417                 _evthread_cond_fns.free_condition(cond);
 418 }
 419 int
 420 _evthreadimpl_cond_signal(void *cond, int broadcast)
 421 {
 422         if (_evthread_cond_fns.signal_condition)
 423                 return _evthread_cond_fns.signal_condition(cond, broadcast);
 424         else
 425                 return 0;
 426 }
 427 int
 428 _evthreadimpl_cond_wait(void *cond, void *lock, const struct timeval *tv)
 429 {
 430         if (_evthread_cond_fns.wait_condition)
 431                 return _evthread_cond_fns.wait_condition(cond, lock, tv);
 432         else
 433                 return 0;
 434 }
 435 int
 436 _evthreadimpl_is_lock_debugging_enabled(void)
 437 {
 438         return _evthread_lock_debugging_enabled;
 439 }
 440
 441 int
 442 _evthreadimpl_locking_enabled(void)
 443 {
 444         return _evthread_lock_fns.lock != NULL;
 445 }
 446 #endif
 447
 448 #endif