remove AST_MUTEX_DEFINE_EXPORTED, which now has no more clients.
[asterisk/asterisk.git] / 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  * This file provides several different implementation of the functions,
23  * depending on the platform, the use of DEBUG_THREADS, and the way
24  * global mutexes are initialized.
25  * At the moment, we have 3 ways to initialize global mutexes, depending on
26  *
27  *  + static: the mutex is assigned the value AST_MUTEX_INIT_VALUE
28  *        this is done at compile time, and is the way used on Linux.
29  *        This method is not applicable to all platforms e.g. when the
30  *        initialization needs that some code is run.
31  *
32  *  + on first use: the mutex is assigned a magic value at compile time,
33  *        and ast_mutex_init() is called when this magic value is detected.
34  *        This technique is generally applicable, though it has a bit of
35  *        overhead on each access to check whether initialization is needed.
36  *        On the other hand, the overall cost of a mutex_lock operation
37  *        is such that this overhead is often negligible.
38
39  *  + through constructors: for each mutex, a constructor function is
40  *        defined, which then runs when the program (or the module)
41  *        starts. The problem with this approach is that there is a
42  *        lot of code duplication (a new block of code is created for
43  *        each mutex). Also, it does not prevent a user from declaring
44  *        a global mutex without going through the wrapper macros,
45  *        so sane programming practices are still required.
46  *
47  * Eventually we should converge on a single method for all platforms.
48  */
49
50 #ifndef _ASTERISK_LOCK_H
51 #define _ASTERISK_LOCK_H
52
53 #include <pthread.h>
54 #include <netdb.h>
55 #include <time.h>
56 #include <sys/param.h>
57
58 #include "asterisk/logger.h"
59
60 #define AST_PTHREADT_NULL (pthread_t) -1
61 #define AST_PTHREADT_STOP (pthread_t) -2
62
63 #ifdef __APPLE__
64 /* Provide the Linux initializers for MacOS X */
65 #define PTHREAD_MUTEX_RECURSIVE_NP                      PTHREAD_MUTEX_RECURSIVE
66 #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP          { 0x4d555458, \
67                                                         { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
68                                                         0x20 } }
69 #endif
70
71 #ifdef BSD
72 #ifdef __GNUC__
73 #define AST_MUTEX_INIT_W_CONSTRUCTORS
74 #else
75 #define AST_MUTEX_INIT_ON_FIRST_USE
76 #endif
77 #endif /* BSD */
78
79 /* From now on, Asterisk REQUIRES Recursive (not error checking) mutexes
80    and will not run without them. */
81 #if defined(__CYGWIN__)
82 #define PTHREAD_MUTEX_RECURSIVE_NP      PTHREAD_MUTEX_RECURSIVE
83 #define PTHREAD_MUTEX_INIT_VALUE        (ast_mutex_t)18
84 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE_NP
85 #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
86 #define PTHREAD_MUTEX_INIT_VALUE        PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
87 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE_NP
88 #else
89 #define PTHREAD_MUTEX_INIT_VALUE        PTHREAD_MUTEX_INITIALIZER
90 #define AST_MUTEX_KIND                  PTHREAD_MUTEX_RECURSIVE
91 #endif /* PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP */
92
93 #ifdef SOLARIS
94 #define AST_MUTEX_INIT_W_CONSTRUCTORS
95 #endif
96
97 #ifdef DEBUG_THREADS
98
99 #define __ast_mutex_logger(...) { if (canlog) ast_log(LOG_ERROR, __VA_ARGS__); else fprintf(stderr, __VA_ARGS__); }
100
101 #ifdef THREAD_CRASH
102 #define DO_THREAD_CRASH do { *((int *)(0)) = 1; } while(0)
103 #endif
104
105 #include <errno.h>
106 #include <string.h>
107 #include <stdio.h>
108 #include <unistd.h>
109
110 #define AST_MUTEX_INIT_VALUE { PTHREAD_MUTEX_INIT_VALUE, { NULL }, { 0 }, 0, { NULL }, { 0 } }
111
112 #define AST_MAX_REENTRANCY 10
113
114 struct ast_mutex_info {
115         pthread_mutex_t mutex;
116         const char *file[AST_MAX_REENTRANCY];
117         int lineno[AST_MAX_REENTRANCY];
118         int reentrancy;
119         const char *func[AST_MAX_REENTRANCY];
120         pthread_t thread[AST_MAX_REENTRANCY];
121 };
122
123 typedef struct ast_mutex_info ast_mutex_t;
124
125 typedef pthread_cond_t ast_cond_t;
126
127 static inline int __ast_pthread_mutex_init_attr(const char *filename, int lineno, const char *func,
128                                                 const char *mutex_name, ast_mutex_t *t,
129                                                 pthread_mutexattr_t *attr) 
130 {
131 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
132         int canlog = strcmp(filename, "logger.c");
133
134         if ((t->mutex) != ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
135                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is already initialized.\n",
136                                    filename, lineno, func, mutex_name);
137                 __ast_mutex_logger("%s line %d (%s): Error: previously initialization of mutex '%s'.\n",
138                                    t->file, t->lineno, t->func, mutex_name);
139 #ifdef THREAD_CRASH
140                 DO_THREAD_CRASH;
141 #endif
142                 return 0;
143         }
144 #endif
145
146         t->file[0] = filename;
147         t->lineno[0] = lineno;
148         t->func[0] = func;
149         t->thread[0]  = 0;
150         t->reentrancy = 0;
151
152         return pthread_mutex_init(&t->mutex, attr);
153 }
154
155 static inline int __ast_pthread_mutex_init(const char *filename, int lineno, const char *func,
156                                            const char *mutex_name, ast_mutex_t *t)
157 {
158         static pthread_mutexattr_t  attr;
159
160         pthread_mutexattr_init(&attr);
161         pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
162
163         return __ast_pthread_mutex_init_attr(filename, lineno, func, mutex_name, t, &attr);
164 }
165
166 static inline int __ast_pthread_mutex_destroy(const char *filename, int lineno, const char *func,
167                                                 const char *mutex_name, ast_mutex_t *t)
168 {
169         int res;
170         int canlog = strcmp(filename, "logger.c");
171
172 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
173         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
174                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
175                                    filename, lineno, func, mutex_name);
176         }
177 #endif
178
179         res = pthread_mutex_trylock(&t->mutex);
180         switch (res) {
181         case 0:
182                 pthread_mutex_unlock(&t->mutex);
183                 break;
184         case EINVAL:
185                 __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy invalid mutex '%s'.\n",
186                                   filename, lineno, func, mutex_name);
187                 break;
188         case EBUSY:
189                 __ast_mutex_logger("%s line %d (%s): Error: attempt to destroy locked mutex '%s'.\n",
190                                    filename, lineno, func, mutex_name);
191                 __ast_mutex_logger("%s line %d (%s): Error: '%s' was locked here.\n",
192                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
193                 break;
194         }
195
196         if ((res = pthread_mutex_destroy(&t->mutex)))
197                 __ast_mutex_logger("%s line %d (%s): Error destroying mutex: %s\n",
198                                    filename, lineno, func, strerror(res));
199 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
200         else
201                 t->mutex = PTHREAD_MUTEX_INIT_VALUE;
202 #endif
203         t->file[0] = filename;
204         t->lineno[0] = lineno;
205         t->func[0] = func;
206
207         return res;
208 }
209
210 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
211 /* if AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope
212  constrictors/destructors to create/destroy mutexes.  */
213 #define __AST_MUTEX_DEFINE(scope,mutex) \
214         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE; \
215 static void  __attribute__ ((constructor)) init_##mutex(void) \
216 { \
217         ast_mutex_init(&mutex); \
218 } \
219 static void  __attribute__ ((destructor)) fini_##mutex(void) \
220 { \
221         ast_mutex_destroy(&mutex); \
222 }
223 #elif defined(AST_MUTEX_INIT_ON_FIRST_USE)
224 /* if AST_MUTEX_INIT_ON_FIRST_USE is defined, mutexes are created on
225  first use.  The performance impact on FreeBSD should be small since
226  the pthreads library does this itself to initialize errror checking
227  (defaulty type) mutexes.  If nither is defined, the pthreads librariy
228  does the initialization itself on first use. */ 
229 #define __AST_MUTEX_DEFINE(scope,mutex) \
230         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE
231 #else /* AST_MUTEX_INIT_W_CONSTRUCTORS */
232 /* By default, use static initialization of mutexes.*/ 
233 #define __AST_MUTEX_DEFINE(scope,mutex) \
234         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE
235 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
236
237 static inline int __ast_pthread_mutex_lock(const char *filename, int lineno, const char *func,
238                                            const char* mutex_name, ast_mutex_t *t)
239 {
240         int res;
241         int canlog = strcmp(filename, "logger.c");
242
243 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) || defined(AST_MUTEX_INIT_ON_FIRST_USE)
244         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
245 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
246                 ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
247                                  filename, lineno, func, mutex_name);
248 #endif
249                 ast_mutex_init(t);
250         }
251 #endif /* defined(AST_MUTEX_INIT_W_CONSTRUCTORS) || defined(AST_MUTEX_INIT_ON_FIRST_USE) */
252
253 #ifdef DETECT_DEADLOCKS
254         {
255                 time_t seconds = time(NULL);
256                 time_t current;
257                 do {
258                         res = pthread_mutex_trylock(&t->mutex);
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         res = pthread_mutex_lock(&t->mutex);
274 #endif /* DETECT_DEADLOCKS */
275
276         if (!res) {
277                 if (t->reentrancy < AST_MAX_REENTRANCY) {
278                         t->file[t->reentrancy] = filename;
279                         t->lineno[t->reentrancy] = lineno;
280                         t->func[t->reentrancy] = func;
281                         t->thread[t->reentrancy] = pthread_self();
282                         t->reentrancy++;
283                 } else {
284                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
285                                                            filename, lineno, func, mutex_name);
286                 }
287         } else {
288                 __ast_mutex_logger("%s line %d (%s): Error obtaining mutex: %s\n",
289                                    filename, lineno, func, strerror(errno));
290 #ifdef THREAD_CRASH
291                 DO_THREAD_CRASH;
292 #endif
293         }
294
295         return res;
296 }
297
298 static inline int __ast_pthread_mutex_trylock(const char *filename, int lineno, const char *func,
299                                               const char* mutex_name, ast_mutex_t *t)
300 {
301         int res;
302         int canlog = strcmp(filename, "logger.c");
303
304 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS) || defined(AST_MUTEX_INIT_ON_FIRST_USE)
305         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
306 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
307
308                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
309                                    filename, lineno, func, mutex_name);
310 #endif
311                 ast_mutex_init(t);
312         }
313 #endif /* defined(AST_MUTEX_INIT_W_CONSTRUCTORS) || defined(AST_MUTEX_INIT_ON_FIRST_USE) */
314
315         if (!(res = pthread_mutex_trylock(&t->mutex))) {
316                 if (t->reentrancy < AST_MAX_REENTRANCY) {
317                         t->file[t->reentrancy] = filename;
318                         t->lineno[t->reentrancy] = lineno;
319                         t->func[t->reentrancy] = func;
320                         t->thread[t->reentrancy] = pthread_self();
321                         t->reentrancy++;
322                 } else {
323                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
324                                                            filename, lineno, func, mutex_name);
325                 }
326         }
327
328         return res;
329 }
330
331 static inline int __ast_pthread_mutex_unlock(const char *filename, int lineno, const char *func,
332                                              const char *mutex_name, ast_mutex_t *t)
333 {
334         int res;
335         int canlog = strcmp(filename, "logger.c");
336
337 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
338         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
339                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
340                                    filename, lineno, func, mutex_name);
341         }
342 #endif
343
344         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
345                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
346                                    filename, lineno, func, mutex_name);
347                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
348                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
349 #ifdef THREAD_CRASH
350                 DO_THREAD_CRASH;
351 #endif
352         }
353
354         if (--t->reentrancy < 0) {
355                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
356                                    filename, lineno, func, mutex_name);
357                 t->reentrancy = 0;
358         }
359
360         if (t->reentrancy < AST_MAX_REENTRANCY) {
361                 t->file[t->reentrancy] = NULL;
362                 t->lineno[t->reentrancy] = 0;
363                 t->func[t->reentrancy] = NULL;
364                 t->thread[t->reentrancy] = 0;
365         }
366
367         if ((res = pthread_mutex_unlock(&t->mutex))) {
368                 __ast_mutex_logger("%s line %d (%s): Error releasing mutex: %s\n", 
369                                    filename, lineno, func, strerror(res));
370 #ifdef THREAD_CRASH
371                 DO_THREAD_CRASH;
372 #endif
373         }
374
375         return res;
376 }
377
378 static inline int __ast_cond_init(const char *filename, int lineno, const char *func,
379                                   const char *cond_name, ast_cond_t *cond, pthread_condattr_t *cond_attr)
380 {
381         return pthread_cond_init(cond, cond_attr);
382 }
383
384 static inline int __ast_cond_signal(const char *filename, int lineno, const char *func,
385                                     const char *cond_name, ast_cond_t *cond)
386 {
387         return pthread_cond_signal(cond);
388 }
389
390 static inline int __ast_cond_broadcast(const char *filename, int lineno, const char *func,
391                                        const char *cond_name, ast_cond_t *cond)
392 {
393         return pthread_cond_broadcast(cond);
394 }
395
396 static inline int __ast_cond_destroy(const char *filename, int lineno, const char *func,
397                                      const char *cond_name, ast_cond_t *cond)
398 {
399         return pthread_cond_destroy(cond);
400 }
401
402 static inline int __ast_cond_wait(const char *filename, int lineno, const char *func,
403                                   const char *cond_name, const char *mutex_name,
404                                   ast_cond_t *cond, ast_mutex_t *t)
405 {
406         int res;
407         int canlog = strcmp(filename, "logger.c");
408
409 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
410         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
411                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
412                                    filename, lineno, func, mutex_name);
413         }
414 #endif
415
416         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
417                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
418                                    filename, lineno, func, mutex_name);
419                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
420                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
421 #ifdef THREAD_CRASH
422                 DO_THREAD_CRASH;
423 #endif
424         }
425
426         if (--t->reentrancy < 0) {
427                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
428                                    filename, lineno, func, mutex_name);
429                 t->reentrancy = 0;
430         }
431
432         if (t->reentrancy < AST_MAX_REENTRANCY) {
433                 t->file[t->reentrancy] = NULL;
434                 t->lineno[t->reentrancy] = 0;
435                 t->func[t->reentrancy] = NULL;
436                 t->thread[t->reentrancy] = 0;
437         }
438
439         if ((res = pthread_cond_wait(cond, &t->mutex))) {
440                 __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n", 
441                                    filename, lineno, func, strerror(res));
442 #ifdef THREAD_CRASH
443                 DO_THREAD_CRASH;
444 #endif
445         } else {
446                 if (t->reentrancy < AST_MAX_REENTRANCY) {
447                         t->file[t->reentrancy] = filename;
448                         t->lineno[t->reentrancy] = lineno;
449                         t->func[t->reentrancy] = func;
450                         t->thread[t->reentrancy] = pthread_self();
451                         t->reentrancy++;
452                 } else {
453                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
454                                                            filename, lineno, func, mutex_name);
455                 }
456         }
457
458         return res;
459 }
460
461 static inline int __ast_cond_timedwait(const char *filename, int lineno, const char *func,
462                                        const char *cond_name, const char *mutex_name, ast_cond_t *cond,
463                                        ast_mutex_t *t, const struct timespec *abstime)
464 {
465         int res;
466         int canlog = strcmp(filename, "logger.c");
467
468 #ifdef AST_MUTEX_INIT_W_CONSTRUCTORS
469         if ((t->mutex) == ((pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER)) {
470                 __ast_mutex_logger("%s line %d (%s): Error: mutex '%s' is uninitialized.\n",
471                                    filename, lineno, func, mutex_name);
472         }
473 #endif
474
475         if (t->reentrancy && (t->thread[t->reentrancy-1] != pthread_self())) {
476                 __ast_mutex_logger("%s line %d (%s): attempted unlock mutex '%s' without owning it!\n",
477                                    filename, lineno, func, mutex_name);
478                 __ast_mutex_logger("%s line %d (%s): '%s' was locked here.\n",
479                                    t->file[t->reentrancy-1], t->lineno[t->reentrancy-1], t->func[t->reentrancy-1], mutex_name);
480 #ifdef THREAD_CRASH
481                 DO_THREAD_CRASH;
482 #endif
483         }
484
485         if (--t->reentrancy < 0) {
486                 __ast_mutex_logger("%s line %d (%s): mutex '%s' freed more times than we've locked!\n",
487                                    filename, lineno, func, mutex_name);
488                 t->reentrancy = 0;
489         }
490
491         if (t->reentrancy < AST_MAX_REENTRANCY) {
492                 t->file[t->reentrancy] = NULL;
493                 t->lineno[t->reentrancy] = 0;
494                 t->func[t->reentrancy] = NULL;
495                 t->thread[t->reentrancy] = 0;
496         }
497
498         if ((res = pthread_cond_timedwait(cond, &t->mutex, abstime)) && (res != ETIMEDOUT)) {
499                 __ast_mutex_logger("%s line %d (%s): Error waiting on condition mutex '%s'\n", 
500                                    filename, lineno, func, strerror(res));
501 #ifdef THREAD_CRASH
502                 DO_THREAD_CRASH;
503 #endif
504         } else {
505                 if (t->reentrancy < AST_MAX_REENTRANCY) {
506                         t->file[t->reentrancy] = filename;
507                         t->lineno[t->reentrancy] = lineno;
508                         t->func[t->reentrancy] = func;
509                         t->thread[t->reentrancy] = pthread_self();
510                         t->reentrancy++;
511                 } else {
512                         __ast_mutex_logger("%s line %d (%s): '%s' really deep reentrancy!\n",
513                                                            filename, lineno, func, mutex_name);
514                 }
515         }
516
517         return res;
518 }
519
520 #define ast_mutex_init(pmutex) __ast_pthread_mutex_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #pmutex, pmutex)
521 #define ast_mutex_destroy(a) __ast_pthread_mutex_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
522 #define ast_mutex_lock(a) __ast_pthread_mutex_lock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
523 #define ast_mutex_unlock(a) __ast_pthread_mutex_unlock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
524 #define ast_mutex_trylock(a) __ast_pthread_mutex_trylock(__FILE__, __LINE__, __PRETTY_FUNCTION__, #a, a)
525 #define ast_cond_init(cond, attr) __ast_cond_init(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond, attr)
526 #define ast_cond_destroy(cond) __ast_cond_destroy(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
527 #define ast_cond_signal(cond) __ast_cond_signal(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
528 #define ast_cond_broadcast(cond) __ast_cond_broadcast(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, cond)
529 #define ast_cond_wait(cond, mutex) __ast_cond_wait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex)
530 #define ast_cond_timedwait(cond, mutex, time) __ast_cond_timedwait(__FILE__, __LINE__, __PRETTY_FUNCTION__, #cond, #mutex, cond, mutex, time)
531
532 #else /* !DEBUG_THREADS */
533
534
535 #define AST_MUTEX_INIT_VALUE    PTHREAD_MUTEX_INIT_VALUE
536
537
538 typedef pthread_mutex_t ast_mutex_t;
539
540 static inline int ast_mutex_init(ast_mutex_t *pmutex)
541 {
542         pthread_mutexattr_t attr;
543         pthread_mutexattr_init(&attr);
544         pthread_mutexattr_settype(&attr, AST_MUTEX_KIND);
545         return pthread_mutex_init(pmutex, &attr);
546 }
547
548 #define ast_pthread_mutex_init(pmutex,a) pthread_mutex_init(pmutex,a)
549
550 static inline int ast_mutex_unlock(ast_mutex_t *pmutex)
551 {
552         return pthread_mutex_unlock(pmutex);
553 }
554
555 static inline int ast_mutex_destroy(ast_mutex_t *pmutex)
556 {
557         return pthread_mutex_destroy(pmutex);
558 }
559
560 #if defined(AST_MUTEX_INIT_W_CONSTRUCTORS)
561 /* if AST_MUTEX_INIT_W_CONSTRUCTORS is defined, use file scope
562  constrictors/destructors to create/destroy mutexes.  */ 
563 #define __AST_MUTEX_DEFINE(scope,mutex) \
564         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE; \
565 static void  __attribute__ ((constructor)) init_##mutex(void) \
566 { \
567         ast_mutex_init(&mutex); \
568 } \
569 static void  __attribute__ ((destructor)) fini_##mutex(void) \
570 { \
571         ast_mutex_destroy(&mutex); \
572 }
573
574 static inline int ast_mutex_lock(ast_mutex_t *pmutex)
575 {
576         return pthread_mutex_lock(pmutex);
577 }
578
579 static inline int ast_mutex_trylock(ast_mutex_t *pmutex)
580 {
581         return pthread_mutex_trylock(pmutex);
582 }
583
584 #elif defined(AST_MUTEX_INIT_ON_FIRST_USE)
585 /* if AST_MUTEX_INIT_ON_FIRST_USE is defined, mutexes are created on
586  first use.  The performance impact on FreeBSD should be small since
587  the pthreads library does this itself to initialize errror checking
588  (defaulty type) mutexes.*/ 
589 #define __AST_MUTEX_DEFINE(scope,mutex) \
590         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE
591
592 static inline int ast_mutex_lock(ast_mutex_t *pmutex)
593 {
594         if (*pmutex == (ast_mutex_t)AST_MUTEX_KIND)
595                 ast_mutex_init(pmutex);
596         return pthread_mutex_lock(pmutex);
597 }
598 static inline int ast_mutex_trylock(ast_mutex_t *pmutex)
599 {
600         if (*pmutex == (ast_mutex_t)AST_MUTEX_KIND)
601                 ast_mutex_init(pmutex);
602         return pthread_mutex_trylock(pmutex);
603 }
604 #else
605 /* By default, use static initialization of mutexes.*/ 
606 #define __AST_MUTEX_DEFINE(scope,mutex) \
607         scope ast_mutex_t mutex = AST_MUTEX_INIT_VALUE
608
609 static inline int ast_mutex_lock(ast_mutex_t *pmutex)
610 {
611         return pthread_mutex_lock(pmutex);
612 }
613
614 static inline int ast_mutex_trylock(ast_mutex_t *pmutex)
615 {
616         return pthread_mutex_trylock(pmutex);
617 }
618
619 #endif /* AST_MUTEX_INIT_W_CONSTRUCTORS */
620
621 typedef pthread_cond_t ast_cond_t;
622
623 static inline int ast_cond_init(ast_cond_t *cond, pthread_condattr_t *cond_attr)
624 {
625         return pthread_cond_init(cond, cond_attr);
626 }
627
628 static inline int ast_cond_signal(ast_cond_t *cond)
629 {
630         return pthread_cond_signal(cond);
631 }
632
633 static inline int ast_cond_broadcast(ast_cond_t *cond)
634 {
635         return pthread_cond_broadcast(cond);
636 }
637
638 static inline int ast_cond_destroy(ast_cond_t *cond)
639 {
640         return pthread_cond_destroy(cond);
641 }
642
643 static inline int ast_cond_wait(ast_cond_t *cond, ast_mutex_t *t)
644 {
645         return pthread_cond_wait(cond, t);
646 }
647
648 static inline int ast_cond_timedwait(ast_cond_t *cond, ast_mutex_t *t, const struct timespec *abstime)
649 {
650         return pthread_cond_timedwait(cond, t, abstime);
651 }
652
653 #endif /* !DEBUG_THREADS */
654
655 #define pthread_mutex_t use_ast_mutex_t_instead_of_pthread_mutex_t
656 #define pthread_mutex_lock use_ast_mutex_lock_instead_of_pthread_mutex_lock
657 #define pthread_mutex_unlock use_ast_mutex_unlock_instead_of_pthread_mutex_unlock
658 #define pthread_mutex_trylock use_ast_mutex_trylock_instead_of_pthread_mutex_trylock
659 #define pthread_mutex_init use_ast_mutex_init_instead_of_pthread_mutex_init
660 #define pthread_mutex_destroy use_ast_mutex_destroy_instead_of_pthread_mutex_destroy
661 #define pthread_cond_t use_ast_cond_t_instead_of_pthread_cond_t
662 #define pthread_cond_init use_ast_cond_init_instead_of_pthread_cond_init
663 #define pthread_cond_destroy use_ast_cond_destroy_instead_of_pthread_cond_destroy
664 #define pthread_cond_signal use_ast_cond_signal_instead_of_pthread_cond_signal
665 #define pthread_cond_broadcast use_ast_cond_broadcast_instead_of_pthread_cond_broadcast
666 #define pthread_cond_wait use_ast_cond_wait_instead_of_pthread_cond_wait
667 #define pthread_cond_timedwait use_ast_cond_timedwait_instead_of_pthread_cond_timedwait
668
669 #define AST_MUTEX_DEFINE_STATIC(mutex) __AST_MUTEX_DEFINE(static,mutex)
670
671 #define AST_MUTEX_INITIALIZER __use_AST_MUTEX_DEFINE_STATIC_rather_than_AST_MUTEX_INITIALIZER__
672
673 #define gethostbyname __gethostbyname__is__not__reentrant__use__ast_gethostbyname__instead__
674 #ifndef __linux__
675 #define pthread_create __use_ast_pthread_create_instead__
676 #endif
677
678 #endif /* _ASTERISK_LOCK_H */