contrib/libevent/evthread.c

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