include/asterisk/lock.h

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2006, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  * \brief General Asterisk channel locking definitions.
  21  *
  22  * - See \ref LockDef
  23  */
  24
  25 /* \page LockDef Asterisk thread locking models
  26  *
  27  * This file provides different implementation of the functions,
  28  * depending on the platform, the use of DEBUG_THREADS, and the way
  29  * module-level mutexes are initialized.
  30  *
  31  *  - \b static: the mutex is assigned the value AST_MUTEX_INIT_VALUE
  32  *        this is done at compile time, and is the way used on Linux.
  33  *        This method is not applicable to all platforms e.g. when the
  34  *        initialization needs that some code is run.
  35  *
  36  *  - \b through constructors: for each mutex, a constructor function is
  37  *        defined, which then runs when the program (or the module)
  38  *        starts. The problem with this approach is that there is a
  39  *        lot of code duplication (a new block of code is created for
  40  *        each mutex). Also, it does not prevent a user from declaring
  41  *        a global mutex without going through the wrapper macros,
  42  *        so sane programming practices are still required.
  43  */
  44
  45 #ifndef _ASTERISK_LOCK_H
  46 #define _ASTERISK_LOCK_H
  47
  48 #include <pthread.h>
  49 #include <netdb.h>
  50 #include <time.h>
  51 #include <sys/param.h>
  52
  53 #include "asterisk/logger.h"
  54
  55 /* internal macro to profile mutexes. Only computes the delay on
  56  * non-blocking calls.
  57  */
  58 #ifndef HAVE_MTX_PROFILE
  59 #define __MTX_PROF(a)   return pthread_mutex_lock((a))
  60 #else
  61 #define __MTX_PROF(a)   do {                    \
  62         int i;                                  \
  63         /* profile only non-blocking events */  \
  64         ast_mark(mtx_prof, 1);                  \
  65         i = pthread_mutex_trylock((a));         \
  66         ast_mark(mtx_prof, 0);                  \
  67         if (!i)                                 \
  68                 return i;                       \
  69         else                                    \
  70                 return pthread_mutex_lock((a)); \
  71         } while (0)
  72 #endif  /* HAVE_MTX_PROFILE */
  73
  74 #define AST_PTHREADT_NULL (pthread_t) -1
  75 #define AST_PTHREADT_STOP (pthread_t) -2
  76
  77 #if defined(SOLARIS) || defined(BSD)
  78 #define AST_MUTEX_INIT_W_CONSTRUCTORS
  79 #endif /* SOLARIS || BSD */
  80
  81 /* Asterisk REQUIRES recursive (not error checking) mutexes
  82    and will not run without them. */
  83 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
  84 #define PTHREAD_MUTEX_INIT_VALUE        PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
  85 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE_NP
  86 #else
  87 #define PTHREAD_MUTEX_INIT_VALUE        PTHREAD_MUTEX_INITIALIZER
  88 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE
  89 #endif /* PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP */
  90
  91 #ifdef DEBUG_THREADS
  92
  93 #define __ast_mutex_logger(...)  do { if (canlog) ast_log(LOG_ERROR, __VA_ARGS__); else fprintf(stderr, __VA_ARGS__); } while (0)
  94
  95 #ifdef THREAD_CRASH
  96 #define DO_THREAD_CRASH do { *((int *)(0)) = 1; } while(0)
  97 #else
  98 #define DO_THREAD_CRASH do { } while (0)
  99 #endif
 100
 101 #include <errno.h>
 102 #include <string.h>
 103 #include <stdio.h>
 104 #include <unistd.h>
 105
 106 #define AST_MUTEX_INIT_VALUE { PTHREAD_MUTEX_INIT_VALUE, { NULL }, { 0 }, 0, { NULL }, { 0 } }
 107
 108 #define AST_MAX_REENTRANCY 10
 109
 110 struct ast_mutex_info {
 111         pthread_mutex_t mutex;
 112         const char *file[AST_MAX_REENTRANCY];
 113         int lineno[AST_MAX_REENTRANCY];
 114         int reentrancy;
 115         const char *func[AST_MAX_REENTRANCY];
 116         pthread_t thread[AST_MAX_REENTRANCY];
 117 };
 118
 119 typedef struct ast_mutex_info ast_mutex_t;
 120
 121 typedef pthread_cond_t ast_cond_t;
 122
 123 static pthread_mutex_t empty_mutex;
 124
 125 static void __attribute__((constructor)) init_empty_mutex(void)
 126 {
 127         memset(&empty_mutex, 0, sizeof(empty_mutex));
 128 }
 129
 130 static inline int __ast_pthread_mutex_init_attr(const char *filename, int lineno, const char *func,
 131                                                 const char *mutex_name, ast_mutex_t *t,
 132                                                 pthread_mutexattr_t *attr)
 133 {
 134 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
 135         int canlog = strcmp(filename, "logger.c");
 136
 137         if ((t->mutex) != ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
 138                 if ((t->mutex) != (empty_mutex)) {
 139                         __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is already initialized.\n",
 140                                            filename, lineno, func, mutex_name);
 141                         __ast_mutex_logger("%s line %d (%s): Error: previously initialization of mutex '%s'.\n",
 142                                            t->file[0], t->lineno[0], t->func[0], mutex_name);
 143                         DO_THREAD_CRASH;
 144                         return 0;
 145                 }
 146         }
 147 #endif
 148
 149         t->file[0] = filename;
 150         t->lineno[0] = lineno;
 151         t->func[0] = func;
 152         t->thread[0]  = 0;
 153         t->reentrancy = 0;
 154
 155         return pthread_mutex_init(&t->mutex, attr);
 156 }
 157
 158 static inline int __ast_pthread_mutex_init(const char *filename, int lineno, const char *func,
 159                                            const char *mutex_name, ast_mutex_t *t)
 160 {
 161         static pthread_mutexattr_t  attr;
 162
 163         pthread_mutexattr_init(&attr);
 164         pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
 165
 166         return __ast_pthread_mutex_init_attr(filename, lineno, func, mutex_name, t, &attr);
 167 }
 168 #define ast_mutex_init(pmutex) __ast_pthread_mutex_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
 169
 170 static inline int __ast_pthread_mutex_destroy(const char *filename, int lineno, const char *func,
 171                                                 const char *mutex_name, ast_mutex_t *t)
 172 {
 173         int res;
 174         int canlog = strcmp(filename, "logger.c");
 175
 176 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
 177         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
 178                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
 179                                    filename, lineno, func, mutex_name);
 180         }
 181 #endif
 182
 183         res = pthread_mutex_trylock(&t->mutex);
 184         switch (res) {
 185         case 0:
 186                 pthread_mutex_unlock(&t->mutex);
 187                 break;
 188         case EINVAL:
 189                 __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy invalid mutex '%s'.\n",
 190                                   filename, lineno, func, mutex_name);
 191                 break;
 192         case EBUSY:
 193                 __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy locked mutex '%s'.\n",
 194                                    filename, lineno, func, mutex_name);
 195                 __ast_mutex_logger("%s line %d (%s): Error: '%s' was locked here.\n",
 196                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
 197                 break;
 198         }
 199
 200         if ((res = pthread_mutex_destroy(&t->mutex)))
 201                 __ast_mutex_logger("%s line %d (%s): Error destroying mutex: %s\n",
 202                                    filename, lineno, func, strerror(res));
 203 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
 204         else
 205                 t->mutex = PTHREAD_MUTEX_INIT_VALUE;
 206 #endif
 207         t->file[0] = filename;
 208         t->lineno[0] = lineno;
 209         t->func[0] = func;
 210
 211         return res;
 212 }
 213
 214 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
 215 /* If AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope
 216  constructors/destructors to create/destroy mutexes.  */
 217 #define __AST_MUTEX_DEFINE(scope, mutex) \
 218         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE; \
 219 static void  __attribute__ ((constructor)) init_##mutex(void) \
 220 { \
 221         ast_mutex_init(&mutex); \
 222 } \
 223 static void  __attribute__ ((destructor)) fini_##mutex(void) \
 224 { \
 225         ast_mutex_destroy(&mutex); \
 226 }
 227 #else /* !AST_MUTEX_INIT_W_CONSTRUCTORS */
 228 /* By default, use static initialization of mutexes. */
 229 #define __AST_MUTEX_DEFINE(scope, mutex) \
 230         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE
 231 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 232
 233 static inline int __ast_pthread_mutex_lock(const char *filename, int lineno, const char *func,
 234                                            const char* mutex_name, ast_mutex_t *t)
 235 {
 236         int res;
 237         int canlog = strcmp(filename, "logger.c");
 238
 239 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
 240         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
 241                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
 242                                  filename, lineno, func, mutex_name);
 243                 ast_mutex_init(t);
 244         }
 245 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 246
 247 #ifdef DETECT_DEADLOCKS
 248         {
 249                 time_t seconds = time(NULL);
 250                 time_t current;
 251                 do {
 252 #ifdef  HAVE_MTX_PROFILE
 253                         ast_mark(mtx_prof, 1);
 254 #endif
 255                         res = pthread_mutex_trylock(&t->mutex);
 256 #ifdef  HAVE_MTX_PROFILE
 257                         ast_mark(mtx_prof, 0);
 258 #endif
 259                         if (res == EBUSY) {
 260                                 current = time(NULL);
 261                                 if ((current - seconds) && (!((current - seconds) % 5))) {
 262                                         __ast_mutex_logger("%s line %d (%s): Deadlock? waited %d sec for mutex '%s'?\n",
 263                                                            filename, lineno, func, (int)(current - seconds), mutex_name);
 264                                         __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
 265                                                            t->file[t->reentrancy-1], t->lineno[t->reentrancy-1],
 266                                                            t->func[t->reentrancy-1], mutex_name);
 267                                 }
 268                                 usleep(200);
 269                         }
 270                 } while (res == EBUSY);
 271         }
 272 #else
 273 #ifdef  HAVE_MTX_PROFILE
 274         ast_mark(mtx_prof, 1);
 275         res = pthread_mutex_trylock(&t->mutex);
 276         ast_mark(mtx_prof, 0);
 277         if (res)
 278 #endif
 279         res = pthread_mutex_lock(&t->mutex);
 280 #endif /* DETECT_DEADLOCKS */
 281
 282         if (!res) {
 283                 if (t->reentrancy < AST_MAX_REENTRANCY) {
 284                         t->file[t->reentrancy] = filename;
 285                         t->lineno[t->reentrancy] = lineno;
 286                         t->func[t->reentrancy] = func;
 287                         t->thread[t->reentrancy] = pthread_self();
 288                         t->reentrancy++;
 289                 } else {
 290                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
 291                                                            filename, lineno, func, mutex_name);
 292                 }
 293         } else {
 294                 __ast_mutex_logger("%s line %d (%s): Error obtaining mutex: %s\n",
 295                                    filename, lineno, func, strerror(errno));
 296                 DO_THREAD_CRASH;
 297         }
 298
 299         return res;
 300 }
 301
 302 static inline int __ast_pthread_mutex_trylock(const char *filename, int lineno, const char *func,
 303                                               const char* mutex_name, ast_mutex_t *t)
 304 {
 305         int res;
 306         int canlog = strcmp(filename, "logger.c");
 307
 308 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
 309         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
 310                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
 311                                    filename, lineno, func, mutex_name);
 312                 ast_mutex_init(t);
 313         }
 314 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 315
 316         if (!(res = pthread_mutex_trylock(&t->mutex))) {
 317                 if (t->reentrancy < AST_MAX_REENTRANCY) {
 318                         t->file[t->reentrancy] = filename;
 319                         t->lineno[t->reentrancy] = lineno;
 320                         t->func[t->reentrancy] = func;
 321                         t->thread[t->reentrancy] = pthread_self();
 322                         t->reentrancy++;
 323                 } else {
 324                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
 325                                                            filename, lineno, func, mutex_name);
 326                 }
 327         }
 328
 329         return res;
 330 }
 331
 332 static inline int __ast_pthread_mutex_unlock(const char *filename, int lineno, const char *func,
 333                                              const char *mutex_name, ast_mutex_t *t)
 334 {
 335         int res;
 336         int canlog = strcmp(filename, "logger.c");
 337
 338 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
 339         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
 340                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
 341                                    filename, lineno, func, mutex_name);
 342         }
 343 #endif
 344
 345         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
 346                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
 347                                    filename, lineno, func, mutex_name);
 348                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
 349                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
 350                 DO_THREAD_CRASH;
 351         }
 352
 353         if (--t->reentrancy < 0) {
 354                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
 355                                    filename, lineno, func, mutex_name);
 356                 t->reentrancy = 0;
 357         }
 358
 359         if (t->reentrancy < AST_MAX_REENTRANCY) {
 360                 t->file[t->reentrancy] = NULL;
 361                 t->lineno[t->reentrancy] = 0;
 362                 t->func[t->reentrancy] = NULL;
 363                 t->thread[t->reentrancy] = 0;
 364         }
 365
 366         if ((res = pthread_mutex_unlock(&t->mutex))) {
 367                 __ast_mutex_logger("%s line %d (%s): Error releasing mutex: %s\n",
 368                                    filename, lineno, func, strerror(res));
 369                 DO_THREAD_CRASH;
 370         }
 371
 372         return res;
 373 }
 374
 375 static inline int __ast_cond_init(const char *filename, int lineno, const char *func,
 376                                   const char *cond_name, ast_cond_t *cond, pthread_condattr_t *cond_attr)
 377 {
 378         return pthread_cond_init(cond, cond_attr);
 379 }
 380
 381 static inline int __ast_cond_signal(const char *filename, int lineno, const char *func,
 382                                     const char *cond_name, ast_cond_t *cond)
 383 {
 384         return pthread_cond_signal(cond);
 385 }
 386
 387 static inline int __ast_cond_broadcast(const char *filename, int lineno, const char *func,
 388                                        const char *cond_name, ast_cond_t *cond)
 389 {
 390         return pthread_cond_broadcast(cond);
 391 }
 392
 393 static inline int __ast_cond_destroy(const char *filename, int lineno, const char *func,
 394                                      const char *cond_name, ast_cond_t *cond)
 395 {
 396         return pthread_cond_destroy(cond);
 397 }
 398
 399 static inline int __ast_cond_wait(const char *filename, int lineno, const char *func,
 400                                   const char *cond_name, const char *mutex_name,
 401                                   ast_cond_t *cond, ast_mutex_t *t)
 402 {
 403         int res;
 404         int canlog = strcmp(filename, "logger.c");
 405
 406 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
 407         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
 408                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
 409                                    filename, lineno, func, mutex_name);
 410         }
 411 #endif
 412
 413         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
 414                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
 415                                    filename, lineno, func, mutex_name);
 416                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
 417                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
 418                 DO_THREAD_CRASH;
 419         }
 420
 421         if (--t->reentrancy < 0) {
 422                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
 423                                    filename, lineno, func, mutex_name);
 424                 t->reentrancy = 0;
 425         }
 426
 427         if (t->reentrancy < AST_MAX_REENTRANCY) {
 428                 t->file[t->reentrancy] = NULL;
 429                 t->lineno[t->reentrancy] = 0;
 430                 t->func[t->reentrancy] = NULL;
 431                 t->thread[t->reentrancy] = 0;
 432         }
 433
 434         if ((res = pthread_cond_wait(cond, &t->mutex))) {
 435                 __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n",
 436                                    filename, lineno, func, strerror(res));
 437                 DO_THREAD_CRASH;
 438         } else {
 439                 if (t->reentrancy < AST_MAX_REENTRANCY) {
 440                         t->file[t->reentrancy] = filename;
 441                         t->lineno[t->reentrancy] = lineno;
 442                         t->func[t->reentrancy] = func;
 443                         t->thread[t->reentrancy] = pthread_self();
 444                         t->reentrancy++;
 445                 } else {
 446                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
 447                                                            filename, lineno, func, mutex_name);
 448                 }
 449         }
 450
 451         return res;
 452 }
 453
 454 static inline int __ast_cond_timedwait(const char *filename, int lineno, const char *func,
 455                                        const char *cond_name, const char *mutex_name, ast_cond_t *cond,
 456                                        ast_mutex_t *t, const struct timespec *abstime)
 457 {
 458         int res;
 459         int canlog = strcmp(filename, "logger.c");
 460
 461 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
 462         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
 463                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
 464                                    filename, lineno, func, mutex_name);
 465         }
 466 #endif
 467
 468         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
 469                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
 470                                    filename, lineno, func, mutex_name);
 471                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
 472                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
 473                 DO_THREAD_CRASH;
 474         }
 475
 476         if (--t->reentrancy < 0) {
 477                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
 478                                    filename, lineno, func, mutex_name);
 479                 t->reentrancy = 0;
 480         }
 481
 482         if (t->reentrancy < AST_MAX_REENTRANCY) {
 483                 t->file[t->reentrancy] = NULL;
 484                 t->lineno[t->reentrancy] = 0;
 485                 t->func[t->reentrancy] = NULL;
 486                 t->thread[t->reentrancy] = 0;
 487         }
 488
 489         if ((res = pthread_cond_timedwait(cond, &t->mutex, abstime)) && (res != ETIMEDOUT)) {
 490                 __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n",
 491                                    filename, lineno, func, strerror(res));
 492                 DO_THREAD_CRASH;
 493         } else {
 494                 if (t->reentrancy < AST_MAX_REENTRANCY) {
 495                         t->file[t->reentrancy] = filename;
 496                         t->lineno[t->reentrancy] = lineno;
 497                         t->func[t->reentrancy] = func;
 498                         t->thread[t->reentrancy] = pthread_self();
 499                         t->reentrancy++;
 500                 } else {
 501                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
 502                                                            filename, lineno, func, mutex_name);
 503                 }
 504         }
 505
 506         return res;
 507 }
 508
 509 #define ast_mutex_destroy(a) __ast_pthread_mutex_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
 510 #define ast_mutex_lock(a) __ast_pthread_mutex_lock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
 511 #define ast_mutex_unlock(a) __ast_pthread_mutex_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
 512 #define ast_mutex_trylock(a) __ast_pthread_mutex_trylock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
 513 #define ast_cond_init(cond, attr) __ast_cond_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond, attr)
 514 #define ast_cond_destroy(cond) __ast_cond_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
 515 #define ast_cond_signal(cond) __ast_cond_signal(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
 516 #define ast_cond_broadcast(cond) __ast_cond_broadcast(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
 517 #define ast_cond_wait(cond, mutex) __ast_cond_wait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex)
 518 #define ast_cond_timedwait(cond, mutex, time) __ast_cond_timedwait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex, time)
 519
 520 #else /* !DEBUG_THREADS */
 521
 522
 523 typedef pthread_mutex_t ast_mutex_t;
 524
 525 #define AST_MUTEX_INIT_VALUE    ((ast_mutex_t) PTHREAD_MUTEX_INIT_VALUE)
 526
 527 static inline int ast_mutex_init(ast_mutex_t *pmutex)
 528 {
 529         pthread_mutexattr_t attr;
 530
 531         pthread_mutexattr_init(&attr);
 532         pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
 533
 534         return pthread_mutex_init(pmutex, &attr);
 535 }
 536
 537 #define ast_pthread_mutex_init(pmutex,a) pthread_mutex_init(pmutex,a)
 538
 539 static inline int ast_mutex_unlock(ast_mutex_t *pmutex)
 540 {
 541         return pthread_mutex_unlock(pmutex);
 542 }
 543
 544 static inline int ast_mutex_destroy(ast_mutex_t *pmutex)
 545 {
 546         return pthread_mutex_destroy(pmutex);
 547 }
 548
 549 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
 550 /* if AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope
 551  constructors/destructors to create/destroy mutexes.  */
 552 #define __AST_MUTEX_DEFINE(scope,mutex) \
 553         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE; \
 554 static void  __attribute__ ((constructor)) init_##mutex(void) \
 555 { \
 556         ast_mutex_init(&mutex); \
 557 } \
 558 static void  __attribute__ ((destructor)) fini_##mutex(void) \
 559 { \
 560         ast_mutex_destroy(&mutex); \
 561 }
 562
 563 static inline int ast_mutex_lock(ast_mutex_t *pmutex)
 564 {
 565         __MTX_PROF(pmutex);
 566 }
 567
 568 static inline int ast_mutex_trylock(ast_mutex_t *pmutex)
 569 {
 570         return pthread_mutex_trylock(pmutex);
 571 }
 572
 573 #else
 574 /* By default, use static initialization of mutexes.*/
 575 #define __AST_MUTEX_DEFINE(scope, mutex) \
 576         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE
 577
 578 static inline int ast_mutex_lock(ast_mutex_t *pmutex)
 579 {
 580         __MTX_PROF(pmutex);
 581 }
 582
 583 static inline int ast_mutex_trylock(ast_mutex_t *pmutex)
 584 {
 585         return pthread_mutex_trylock(pmutex);
 586 }
 587
 588 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
 589
 590 typedef pthread_cond_t ast_cond_t;
 591
 592 static inline int ast_cond_init(ast_cond_t *cond, pthread_condattr_t *cond_attr)
 593 {
 594         return pthread_cond_init(cond, cond_attr);
 595 }
 596
 597 static inline int ast_cond_signal(ast_cond_t *cond)
 598 {
 599         return pthread_cond_signal(cond);
 600 }
 601
 602 static inline int ast_cond_broadcast(ast_cond_t *cond)
 603 {
 604         return pthread_cond_broadcast(cond);
 605 }
 606
 607 static inline int ast_cond_destroy(ast_cond_t *cond)
 608 {
 609         return pthread_cond_destroy(cond);
 610 }
 611
 612 static inline int ast_cond_wait(ast_cond_t *cond, ast_mutex_t *t)
 613 {
 614         return pthread_cond_wait(cond, t);
 615 }
 616
 617 static inline int ast_cond_timedwait(ast_cond_t *cond, ast_mutex_t *t, const struct timespec *abstime)
 618 {
 619         return pthread_cond_timedwait(cond, t, abstime);
 620 }
 621
 622 #endif /* !DEBUG_THREADS */
 623
 624 #define pthread_mutex_t use_ast_mutex_t_instead_of_pthread_mutex_t
 625 #define pthread_mutex_lock use_ast_mutex_lock_instead_of_pthread_mutex_lock
 626 #define pthread_mutex_unlock use_ast_mutex_unlock_instead_of_pthread_mutex_unlock
 627 #define pthread_mutex_trylock use_ast_mutex_trylock_instead_of_pthread_mutex_trylock
 628 #define pthread_mutex_init use_ast_mutex_init_instead_of_pthread_mutex_init
 629 #define pthread_mutex_destroy use_ast_mutex_destroy_instead_of_pthread_mutex_destroy
 630 #define pthread_cond_t use_ast_cond_t_instead_of_pthread_cond_t
 631 #define pthread_cond_init use_ast_cond_init_instead_of_pthread_cond_init
 632 #define pthread_cond_destroy use_ast_cond_destroy_instead_of_pthread_cond_destroy
 633 #define pthread_cond_signal use_ast_cond_signal_instead_of_pthread_cond_signal
 634 #define pthread_cond_broadcast use_ast_cond_broadcast_instead_of_pthread_cond_broadcast
 635 #define pthread_cond_wait use_ast_cond_wait_instead_of_pthread_cond_wait
 636 #define pthread_cond_timedwait use_ast_cond_timedwait_instead_of_pthread_cond_timedwait
 637
 638 #define AST_MUTEX_DEFINE_STATIC(mutex) __AST_MUTEX_DEFINE(static, mutex)
 639
 640 #define AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
 641
 642 #define gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
 643
 644 #ifndef __linux__
 645 #define pthread_create __use_ast_pthread_create_instead__
 646 #endif
 647
 648 /*
 649  * Initial support for atomic instructions.
 650  * For platforms that have it, use the native cpu instruction to
 651  * implement them. For other platforms, resort to a 'slow' version
 652  * (defined in utils.c) that protects the atomic instruction with
 653  * a single lock.
 654  * The slow versions is always available, for testing purposes,
 655  * as ast_atomic_fetchadd_int_slow()
 656  */
 657
 658 int ast_atomic_fetchadd_int_slow(volatile int *p, int v);
 659
 660 #include "asterisk/inline_api.h"
 661
 662 #if defined(HAVE_OSX_ATOMICS)
 663 #include "libkern/OSAtomic.h"
 664 #endif
 665
 666 /*! \brief Atomically add v to *p and return * the previous value of *p.
 667  * This can be used to handle reference counts, and the return value
 668  * can be used to generate unique identifiers.
 669  */
 670
 671 #if defined(HAVE_GCC_ATOMICS)
 672 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
 673 {
 674         return __sync_fetch_and_add(p, v);
 675 })
 676 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 4)
 677 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
 678 {
 679         return OSAtomicAdd32(v, (int32_t *) p);
 680 })
 681 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 8)
 682 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
 683 {
 684         return OSAtomicAdd64(v, (int64_t *) p);
 685 #elif defined (__i386__)
 686 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
 687 {
 688         __asm __volatile (
 689         "       lock   xaddl   %0, %1 ;        "
 690         : "+r" (v),                     /* 0 (result) */
 691           "=m" (*p)                     /* 1 */
 692         : "m" (*p));                    /* 2 */
 693         return (v);
 694 })
 695 #else   /* low performance version in utils.c */
 696 AST_INLINE_API(int ast_atomic_fetchadd_int(volatile int *p, int v),
 697 {
 698         return ast_atomic_fetchadd_int_slow(p, v);
 699 })
 700 #endif
 701
 702 /*! \brief decrement *p by 1 and return true if the variable has reached 0.
 703  * Useful e.g. to check if a refcount has reached 0.
 704  */
 705 #if defined(HAVE_GCC_ATOMICS)
 706 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
 707 {
 708         return __sync_sub_and_fetch(p, 1) == 0;
 709 })
 710 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 4)
 711 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
 712 {
 713         return OSAtomicAdd32( -1, (int32_t *) p) == 0;
 714 })
 715 #elif defined(HAVE_OSX_ATOMICS) && (SIZEOF_INT == 8)
 716 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
 717 {
 718         return OSAtomicAdd64( -1, (int64_t *) p) == 0;
 719 #else
 720 AST_INLINE_API(int ast_atomic_dec_and_test(volatile int *p),
 721 {
 722         int a = ast_atomic_fetchadd_int(p, -1);
 723         return a == 1; /* true if the value is 0 now (so it was 1 previously) */
 724 })
 725 #endif
 726
 727 #ifndef DEBUG_CHANNEL_LOCKS
 728 /*! \brief Lock a channel. If DEBUG_CHANNEL_LOCKS is defined
 729         in the Makefile, print relevant output for debugging */
 730 #define ast_channel_lock(x)             ast_mutex_lock(&x->lock)
 731 /*! \brief Unlock a channel. If DEBUG_CHANNEL_LOCKS is defined
 732         in the Makefile, print relevant output for debugging */
 733 #define ast_channel_unlock(x)           ast_mutex_unlock(&x->lock)
 734 /*! \brief Try locking a channel. If DEBUG_CHANNEL_LOCKS is defined
 735         in the Makefile, print relevant output for debugging */
 736 #define ast_channel_trylock(x)          ast_mutex_trylock(&x->lock)
 737 #else
 738
 739 /*! \brief Lock AST channel (and print debugging output)
 740 \note You need to enable DEBUG_CHANNEL_LOCKS for this function */
 741 int ast_channel_lock(struct ast_channel *chan);
 742
 743 /*! \brief Unlock AST channel (and print debugging output)
 744 \note You need to enable DEBUG_CHANNEL_LOCKS for this function
 745 */
 746 int ast_channel_unlock(struct ast_channel *chan);
 747
 748 /*! \brief Lock AST channel (and print debugging output)
 749 \note   You need to enable DEBUG_CHANNEL_LOCKS for this function */
 750 int ast_channel_trylock(struct ast_channel *chan);
 751 #endif
 752
 753 #endif /* _ASTERISK_LOCK_H */