1 /* thr_debug.c - wrapper around the chosen thread wrapper, for debugging. */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
5 * Copyright 2005-2012 The OpenLDAP Foundation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted only as authorized by the OpenLDAP
12 * A copy of this license is available in file LICENSE in the
13 * top-level directory of the distribution or, alternatively, at
14 * <http://www.OpenLDAP.org/license.html>.
18 * This package provides several types of thread operation debugging:
20 * - Check the results of operations on threads, mutexes, condition
21 * variables and read/write locks. Also check some thread pool
22 * operations, but not those for which failure can happen in normal
25 * - Wrap those types except threads and pools in structs with state
26 * information, and check that on all operations:
28 * + Check that the resources are initialized and are only used at
29 * their original address (i.e. not realloced or copied).
31 * + Check the owner (thread ID) on mutex operations.
33 * + Optionally allocate a reference to a byte of dummy memory.
34 * This lets malloc debuggers see some incorrect use as memory
35 * leaks, access to freed memory, etc.
37 * - Print an error message and by default abort() upon errors.
39 * - Print a count of leaked thread resources after cleanup.
41 * Compile-time (./configure) setup: Macros defined in CPPFLAGS.
43 * LDAP_THREAD_DEBUG or LDAP_THREAD_DEBUG=2
44 * Enables debugging, but value & 2 turns off type wrapping.
46 * LDAP_UINTPTR_T=integer type to hold pointers, preferably unsigned.
47 * Used by dummy memory option "scramble". Default = unsigned long.
49 * LDAP_DEBUG_THREAD_NONE = initializer for a "no thread" thread ID.
51 * In addition, you may need to set up an implementation-specific way
52 * to enable whatever error checking your thread library provides.
53 * Currently only implemented for Posix threads (pthreads), where
54 * you may need to define LDAP_INT_THREAD_MUTEXATTR. The default
55 * is PTHREAD_MUTEX_ERRORCHECK, or PTHREAD_MUTEX_ERRORCHECK_NP for
56 * Linux threads. See pthread_mutexattr_settype(3).
58 * Run-time configuration:
60 * Memory debugging tools:
61 * Tools that report uninitialized memory accesses should disable
62 * such warnings about the function debug_already_initialized().
63 * Alternatively, include "noreinit" (below) in $LDAP_THREAD_DEBUG.
65 * Environment variable $LDAP_THREAD_DEBUG:
66 * The variable may contain a comma- or space-separated option list.
68 * off - Disable this package. (It still slows things down).
69 * tracethreads - Report create/join/exit/kill of threads.
70 * noabort - Do not abort() on errors.
71 * noerror - Do not report errors. Implies noabort.
72 * nocount - Do not report counts of unreleased resources.
73 * nosync - Disable tests that use synchronizaion and thus
74 * clearly affect thread scheduling:
75 * Implies nocount, and cancels threadID if that is set.
76 * Note that if you turn on tracethreads or malloc
77 * debugging, these also use library calls which may
78 * affect thread scheduling (fprintf and malloc).
79 * The following options do not apply if type wrapping is disabled:
80 * nomem - Do not check memory operations.
81 * Implies noreinit,noalloc.
82 * noreinit - Do not catch reinitialization of existing resources.
83 * (That test accesses uninitialized memory).
84 * threadID - Trace thread IDs. Currently mostly useless.
85 * Malloc debugging -- allocate dummy memory for initialized
86 * resources, so malloc debuggers will report them as memory leaks:
87 * noalloc - Default. Do not allocate dummy memory.
88 * alloc - Store a pointer to dummy memory. However, leak
89 * detectors might not catch unreleased resources in
91 * scramble - Store bitwise complement of dummy memory pointer.
92 * That never escapes memory leak detectors -
93 * but detection while the program is running will
94 * report active resources as leaks. Do not
95 * use this if a garbage collector is in use:-)
96 * adjptr - Point to end of dummy memory.
97 * Purify reports these as "potential leaks" (PLK).
98 * I have not checked other malloc debuggers.
101 #include "portable.h"
103 #if defined( LDAP_THREAD_DEBUG )
106 #include <ac/errno.h>
107 #include <ac/stdlib.h>
108 #include <ac/string.h>
110 #include "ldap_pvt_thread.h" /* Get the thread interface */
111 #define LDAP_THREAD_IMPLEMENTATION
112 #define LDAP_THREAD_DEBUG_IMPLEMENTATION
113 #define LDAP_THREAD_RDWR_IMPLEMENTATION
114 #define LDAP_THREAD_POOL_IMPLEMENTATION
115 #include "ldap_thr_debug.h" /* Get the underlying implementation */
117 #ifndef LDAP_THREAD_DEBUG_WRAP
118 #undef LDAP_THREAD_DEBUG_THREAD_ID
119 #elif !defined LDAP_THREAD_DEBUG_THREAD_ID
120 #define LDAP_THREAD_DEBUG_THREAD_ID 1
123 /* Use native malloc - the OpenLDAP wrappers may defeat malloc debuggers */
130 /* Options from environment variable $LDAP_THREAD_DEBUG */
131 enum { Count_no = 0, Count_yes, Count_reported, Count_reported_more };
132 static int count = Count_yes;
133 #ifdef LDAP_THREAD_DEBUG_WRAP
134 enum { Wrap_noalloc, Wrap_alloc, Wrap_scramble, Wrap_adjptr };
135 static int wraptype = Wrap_noalloc, wrap_offset, unwrap_offset;
136 static int nomem, noreinit;
138 #if LDAP_THREAD_DEBUG_THREAD_ID +0
141 enum { threadID = 0 };
143 static int nodebug, noabort, noerror, nosync, tracethreads;
144 static int wrap_threads;
145 static int options_done;
148 /* ldap_pvt_thread_initialize() called, ldap_pvt_thread_destroy() not called */
149 static int threading_enabled;
152 /* Resource counts */
154 Idx_unexited_thread, Idx_unjoined_thread, Idx_locked_mutex,
155 Idx_mutex, Idx_cond, Idx_rdwr, Idx_tpool, Idx_max
157 static int resource_counts[Idx_max];
158 static const char *const resource_names[] = {
159 "unexited threads", "unjoined threads", "locked mutexes",
160 "mutexes", "conds", "rdwrs", "thread pools"
162 static ldap_int_thread_mutex_t resource_mutexes[Idx_max];
165 /* Hide pointers from malloc debuggers. */
166 #define SCRAMBLE(ptr) (~(LDAP_UINTPTR_T) (ptr))
167 #define UNSCRAMBLE_usagep(num) ((ldap_debug_usage_info_t *) ~(num))
168 #define UNSCRAMBLE_dummyp(num) ((unsigned char *) ~(num))
171 #define WARN(var, msg) (warn (__FILE__, __LINE__, (msg), #var, (var)))
172 #define WARN_IF(rc, msg) {if (rc) warn (__FILE__, __LINE__, (msg), #rc, (rc));}
174 #define ERROR(var, msg) { \
176 errmsg(__FILE__, __LINE__, (msg), #var, (var)); \
177 if( !noabort ) abort(); \
181 #define ERROR_IF(rc, msg) { \
185 errmsg(__FILE__, __LINE__, (msg), #rc, rc_); \
186 if( !noabort ) abort(); \
191 #ifdef LDAP_THREAD_DEBUG_WRAP
192 #define MEMERROR_IF(rc, msg, mem_act) { \
196 errmsg(__FILE__, __LINE__, (msg), #rc, rc_); \
197 if( wraptype != Wrap_noalloc ) { mem_act; } \
198 if( !noabort ) abort(); \
202 #endif /* LDAP_THREAD_DEBUG_WRAP */
206 warn( const char *file, int line, const char *msg, const char *var, int val )
209 (strpbrk( var, "!=" )
210 ? "%s:%d: %s warning: %s\n"
211 : "%s:%d: %s warning: %s is %d\n"),
212 file, line, msg, var, val );
217 errmsg( const char *file, int line, const char *msg, const char *var, int val )
220 (strpbrk( var, "!=" )
221 ? "%s:%d: %s error: %s\n"
222 : "%s:%d: %s error: %s is %d\n"),
223 file, line, msg, var, val );
227 count_resource_leaks( void )
231 if( count == Count_yes ) {
232 count = Count_reported;
233 #if 0 /* Could break if there are still threads after atexit */
234 for( i = j = 0; i < Idx_max; i++ )
235 j |= ldap_int_thread_mutex_destroy( &resource_mutexes[i] );
236 WARN_IF( j, "ldap_debug_thread_destroy:mutexes" );
238 for( i = j = 0; i < Idx_max; i++ )
239 if( resource_counts[i] )
240 j += sprintf( errbuf + j, ", %d %s",
241 resource_counts[i], resource_names[i] );
243 fprintf( stderr, "== thr_debug: Leaked%s. ==\n", errbuf + 1 );
250 static const struct option_info_s {
254 { "off", &nodebug, 1 },
255 { "noabort", &noabort, 1 },
256 { "noerror", &noerror, 1 },
257 { "nocount", &count, Count_no },
258 { "nosync", &nosync, 1 },
259 #if LDAP_THREAD_DEBUG_THREAD_ID +0
260 { "threadID", &threadID, 1 },
262 #ifdef LDAP_THREAD_DEBUG_WRAP
263 { "nomem", &nomem, 1 },
264 { "noreinit", &noreinit, 1 },
265 { "noalloc", &wraptype, Wrap_noalloc },
266 { "alloc", &wraptype, Wrap_alloc },
267 { "adjptr", &wraptype, Wrap_adjptr },
268 { "scramble", &wraptype, Wrap_scramble },
270 { "tracethreads", &tracethreads, 1 },
273 const char *s = getenv( "LDAP_THREAD_DEBUG" );
275 while( *(s += strspn( s, ", \t\r\n" )) != '\0' ) {
276 size_t optlen = strcspn( s, ", \t\r\n" );
277 const struct option_info_s *oi = option_info;
279 (strncasecmp( oi->name, s, optlen ) || oi->name[optlen]) )
285 "== thr_debug: Unknown $%s option '%.*s' ==\n",
286 "LDAP_THREAD_DEBUG", (int) optlen, s );
292 nosync = noerror = 1;
298 #if LDAP_THREAD_DEBUG_THREAD_ID +0
302 #ifdef LDAP_THREAD_DEBUG_WRAP
306 static const ldap_debug_usage_info_t usage;
307 if( sizeof(LDAP_UINTPTR_T) < sizeof(unsigned char *)
308 || sizeof(LDAP_UINTPTR_T) < sizeof(ldap_debug_usage_info_t *)
309 || UNSCRAMBLE_usagep( SCRAMBLE( &usage ) ) != &usage
310 || UNSCRAMBLE_dummyp( SCRAMBLE( (unsigned char *) 0 ) ) )
312 fputs( "== thr_debug: Memory checks unsupported, "
313 "adding nomem to $LDAP_THREAD_DEBUG ==\n", stderr );
319 wraptype = Wrap_noalloc;
321 unwrap_offset = -(wrap_offset = (wraptype == Wrap_adjptr));
323 wrap_threads = (tracethreads || threadID || count);
328 #ifndef LDAP_THREAD_DEBUG_WRAP
330 #define WRAPPED(ptr) (ptr)
331 #define GET_OWNER(ptr) 0
332 #define SET_OWNER(ptr, thread) ((void) 0)
333 #define RESET_OWNER(ptr) ((void) 0)
334 #define ASSERT_OWNER(ptr, msg) ((void) 0)
335 #define ASSERT_NO_OWNER(ptr, msg) ((void) 0)
337 #define init_usage(ptr, msg) ((void) 0)
338 #define check_usage(ptr, msg) ((void) 0)
339 #define destroy_usage(ptr) ((void) 0)
341 #else /* LDAP_THREAD_DEBUG_WRAP */
343 /* Specialize this if the initializer is not appropriate. */
344 /* The ASSERT_NO_OWNER() definition may also need an override. */
345 #ifndef LDAP_DEBUG_THREAD_NONE
346 #define LDAP_DEBUG_THREAD_NONE { -1 } /* "no thread" ldap_int_thread_t value */
349 static const ldap_int_thread_t ldap_debug_thread_none = LDAP_DEBUG_THREAD_NONE;
351 #define THREAD_MUTEX_OWNER(mutex) \
352 ldap_int_thread_equal( (mutex)->owner, ldap_int_thread_self() )
355 ldap_debug_thread_assert_mutex_owner(
359 ldap_pvt_thread_mutex_t *mutex )
361 if( !(noerror || THREAD_MUTEX_OWNER( mutex )) ) {
362 errmsg( file, line, msg, "ASSERT_MUTEX_OWNER", 0 );
363 if( !noabort ) abort();
367 #define WRAPPED(ptr) (&(ptr)->wrapped)
368 #define GET_OWNER(ptr) ((ptr)->owner)
369 #define SET_OWNER(ptr, thread) ((ptr)->owner = (thread))
370 #define RESET_OWNER(ptr) ((ptr)->owner = ldap_debug_thread_none)
371 #define ASSERT_OWNER(ptr, msg) ERROR_IF( !THREAD_MUTEX_OWNER( ptr ), msg )
372 #ifndef ASSERT_NO_OWNER
373 #define ASSERT_NO_OWNER(ptr, msg) ERROR_IF( \
374 !ldap_int_thread_equal( (ptr)->owner, ldap_debug_thread_none ), msg )
377 /* Try to provoke memory access error (for malloc debuggers) */
378 #define PEEK(mem) {if (-*(volatile const unsigned char *)(mem)) debug_noop();}
380 static void debug_noop( void );
381 static int debug_already_initialized( const ldap_debug_usage_info_t *usage );
383 /* Name used for clearer error message */
384 #define IS_COPY_OR_MOVED(usage) ((usage)->self != SCRAMBLE( usage ))
386 #define DUMMY_ADDR(usage) \
387 (wraptype == Wrap_scramble \
388 ? UNSCRAMBLE_dummyp( (usage)->mem.num ) \
389 : (usage)->mem.ptr + unwrap_offset)
391 /* Mark resource as initialized */
393 init_usage( ldap_debug_usage_info_t *usage, const char *msg )
399 MEMERROR_IF( debug_already_initialized( usage ), msg, {
400 /* Provoke malloc debuggers */
401 unsigned char *dummy = DUMMY_ADDR( usage );
407 if( wraptype != Wrap_noalloc ) {
408 unsigned char *dummy = malloc( 1 );
409 assert( dummy != NULL );
410 if( wraptype == Wrap_scramble ) {
411 usage->mem.num = SCRAMBLE( dummy );
412 /* Verify that ptr<->integer casts work on this host */
413 assert( UNSCRAMBLE_dummyp( usage->mem.num ) == dummy );
415 usage->mem.ptr = dummy + wrap_offset;
419 /* Unused, but set for readability in debugger */
420 usage->mem.ptr = NULL;
422 usage->self = SCRAMBLE( usage ); /* If nomem, only for debugger */
423 usage->magic = ldap_debug_magic;
424 usage->state = ldap_debug_state_inited;
427 /* Check that resource is initialized and not copied/realloced */
429 check_usage( const ldap_debug_usage_info_t *usage, const char *msg )
431 enum { Is_destroyed = 1 }; /* Name used for clearer error message */
433 if( usage->magic != ldap_debug_magic ) {
434 ERROR( usage->magic, msg );
437 switch( usage->state ) {
438 case ldap_debug_state_destroyed:
439 MEMERROR_IF( Is_destroyed, msg, {
440 PEEK( DUMMY_ADDR( usage ) );
444 ERROR( usage->state, msg );
446 case ldap_debug_state_inited:
448 MEMERROR_IF( IS_COPY_OR_MOVED( usage ), msg, {
449 PEEK( DUMMY_ADDR( usage ) );
450 PEEK( UNSCRAMBLE_usagep( usage->self ) );
457 /* Mark resource as destroyed. */
458 /* Does not check for errors, call check_usage()/init_usage() first. */
460 destroy_usage( ldap_debug_usage_info_t *usage )
462 if( usage->state == ldap_debug_state_inited ) {
463 if( wraptype != Wrap_noalloc ) {
464 free( DUMMY_ADDR( usage ) );
465 /* Do not reset the DUMMY_ADDR, leave it for malloc debuggers
466 * in case the resource is used after it is freed. */
468 usage->state = ldap_debug_state_destroyed;
472 /* Define these after they are used, so they are hopefully not inlined */
480 * Valid programs access uninitialized memory here unless "noreinit".
482 * Returns true if the resource is initialized and not copied/realloced.
484 LDAP_GCCATTR((noinline))
486 debug_already_initialized( const ldap_debug_usage_info_t *usage )
489 * 'ret' keeps the Valgrind warning "Conditional jump or move
490 * depends on uninitialised value(s)" _inside_ this function.
492 volatile int ret = 0;
493 if( usage->state == ldap_debug_state_inited )
494 if( !IS_COPY_OR_MOVED( usage ) )
495 if( usage->magic == ldap_debug_magic )
500 #endif /* LDAP_THREAD_DEBUG_WRAP */
503 #if !(LDAP_THREAD_DEBUG_THREAD_ID +0)
505 typedef void ldap_debug_thread_t;
506 #define init_thread_info() {}
507 #define with_thread_info_lock(statements) { statements; }
508 #define thread_info_detached(t) 0
509 #define add_thread_info(msg, thr, det) ((void) 0)
510 #define remove_thread_info(tinfo, msg) ((void) 0)
511 #define get_thread_info(thread, msg) NULL
513 #else /* LDAP_THREAD_DEBUG_THREAD_ID */
516 * Thread ID tracking. Currently acieves little.
517 * Should be either expanded or deleted.
521 * Array of threads. Used instead of making ldap_pvt_thread_t a wrapper
522 * around ldap_int_thread_t, which would slow down ldap_pvt_thread_self().
525 ldap_pvt_thread_t wrapped;
526 ldap_debug_usage_info_t usage;
529 } ldap_debug_thread_t;
531 static ldap_debug_thread_t **thread_info;
532 static unsigned int thread_info_size, thread_info_used;
533 static ldap_int_thread_mutex_t thread_info_mutex;
535 #define init_thread_info() { \
537 int mutex_init_rc = ldap_int_thread_mutex_init( &thread_info_mutex ); \
538 assert( mutex_init_rc == 0 ); \
542 #define with_thread_info_lock(statements) { \
543 int rc_wtl_ = ldap_int_thread_mutex_lock( &thread_info_mutex ); \
544 assert( rc_wtl_ == 0 ); \
546 rc_wtl_ = ldap_int_thread_mutex_unlock( &thread_info_mutex ); \
547 assert( rc_wtl_ == 0 ); \
550 #define thread_info_detached(t) ((t)->detached)
555 const ldap_pvt_thread_t *thread,
558 ldap_debug_thread_t *t;
560 if( thread_info_used >= thread_info_size ) {
561 unsigned int more = thread_info_size + 8;
562 unsigned int new_size = thread_info_size + more;
564 t = calloc( more, sizeof(ldap_debug_thread_t) );
566 thread_info = realloc( thread_info, new_size * sizeof(*thread_info) );
567 assert( thread_info != NULL );
569 t->idx = thread_info_size;
570 thread_info[thread_info_size++] = t++;
571 } while( thread_info_size < new_size );
574 t = thread_info[thread_info_used];
575 init_usage( &t->usage, msg );
576 t->wrapped = *thread;
577 t->detached = detached;
582 remove_thread_info( ldap_debug_thread_t *t, const char *msg )
584 ldap_debug_thread_t *last;
586 check_usage( &t->usage, msg );
587 destroy_usage( &t->usage );
589 assert( thread_info[idx] == t );
590 last = thread_info[--thread_info_used];
591 assert( last->idx == thread_info_used );
592 (thread_info[idx] = last)->idx = idx;
593 (thread_info[thread_info_used] = t )->idx = thread_info_used;
596 static ldap_debug_thread_t *
597 get_thread_info( ldap_pvt_thread_t thread, const char *msg )
600 ldap_debug_thread_t *t;
601 for( i = 0; i < thread_info_used; i++ ) {
602 if( ldap_pvt_thread_equal( thread, thread_info[i]->wrapped ) )
605 ERROR_IF( i == thread_info_used, msg );
607 check_usage( &t->usage, msg );
611 #endif /* LDAP_THREAD_DEBUG_THREAD_ID */
615 thread_name( char *buf, int bufsize, ldap_pvt_thread_t thread )
619 if( bufsize > 2*sizeof(thread) )
620 bufsize = 2*sizeof(thread);
621 for( i = 0; i < bufsize; i += 2 )
622 snprintf( buf+i, 3, "%02x", ((unsigned char *)&thread)[i/2] );
627 /* Add <adjust> (+/-1) to resource count <which> unless "nocount". */
629 adjust_count( int which, int adjust )
636 rc = ldap_int_thread_mutex_lock( &resource_mutexes[which] );
638 resource_counts[which] += adjust;
639 rc = ldap_int_thread_mutex_unlock( &resource_mutexes[which] );
643 fputs( "== thr_debug: More thread activity after exit ==\n", stderr );
644 count = Count_reported_more;
646 case Count_reported_more:
647 /* Not used, but result might be inspected with debugger */
648 /* (Hopefully threading is disabled by now...) */
649 resource_counts[which] += adjust;
655 /* Wrappers for LDAP_THREAD_IMPLEMENTATION: */
657 /* Used instead of ldap_int_thread_initialize by ldap_pvt_thread_initialize */
659 ldap_debug_thread_initialize( void )
664 ERROR_IF( threading_enabled, "ldap_debug_thread_initialize" );
665 threading_enabled = 1;
666 rc = ldap_int_thread_initialize();
668 ERROR( rc, "ldap_debug_thread_initialize:threads" );
669 threading_enabled = 0;
672 if( count != Count_no ) {
673 for( i = rc2 = 0; i < Idx_max; i++ )
674 rc2 |= ldap_int_thread_mutex_init( &resource_mutexes[i] );
676 /* FIXME: Only for static libldap_r as in init.c? If so, why? */
677 atexit( count_resource_leaks );
683 /* Used instead of ldap_int_thread_destroy by ldap_pvt_thread_destroy */
685 ldap_debug_thread_destroy( void )
688 ERROR_IF( !threading_enabled, "ldap_debug_thread_destroy" );
689 /* sleep(1) -- need to wait for thread pool to finish? */
690 rc = ldap_int_thread_destroy();
692 ERROR( rc, "ldap_debug_thread_destroy:threads" );
694 threading_enabled = 0;
700 ldap_pvt_thread_set_concurrency( int n )
703 ERROR_IF( !threading_enabled, "ldap_pvt_thread_set_concurrency" );
704 rc = ldap_int_thread_set_concurrency( n );
705 ERROR_IF( rc, "ldap_pvt_thread_set_concurrency" );
710 ldap_pvt_thread_get_concurrency( void )
713 ERROR_IF( !threading_enabled, "ldap_pvt_thread_get_concurrency" );
714 rc = ldap_int_thread_get_concurrency();
715 ERROR_IF( rc, "ldap_pvt_thread_get_concurrency" );
720 ldap_pvt_thread_sleep( unsigned int interval )
723 ERROR_IF( !threading_enabled, "ldap_pvt_thread_sleep" );
724 rc = ldap_int_thread_sleep( interval );
725 ERROR_IF( rc, "ldap_pvt_thread_sleep" );
730 thread_exiting( const char *how, const char *msg )
732 ldap_pvt_thread_t thread;
733 #if 0 /* Detached threads may exit after ldap_debug_thread_destroy(). */
734 ERROR_IF( !threading_enabled, msg );
736 thread = ldap_pvt_thread_self();
739 fprintf( stderr, "== thr_debug: %s thread %s ==\n",
740 how, thread_name( buf, sizeof(buf), thread ) );
743 with_thread_info_lock({
744 ldap_debug_thread_t *t = get_thread_info( thread, msg );
745 if( thread_info_detached( t ) )
746 remove_thread_info( t, msg );
749 adjust_count( Idx_unexited_thread, -1 );
753 ldap_pvt_thread_exit( void *retval )
755 thread_exiting( "Exiting", "ldap_pvt_thread_exit" );
756 ldap_int_thread_exit( retval );
760 void *(*start_routine)( void * );
762 } ldap_debug_thread_call_t;
765 ldap_debug_thread_wrapper( void *arg )
768 ldap_debug_thread_call_t call = *(ldap_debug_thread_call_t *)arg;
770 ret = call.start_routine( call.arg );
771 thread_exiting( "Returning from", "ldap_debug_thread_wrapper" );
776 ldap_pvt_thread_create(
777 ldap_pvt_thread_t *thread,
779 void *(*start_routine)( void * ),
785 ERROR_IF( !threading_enabled, "ldap_pvt_thread_create" );
788 ldap_debug_thread_call_t *call = malloc(
789 sizeof( ldap_debug_thread_call_t ) );
790 assert( call != NULL );
791 call->start_routine = start_routine;
793 start_routine = ldap_debug_thread_wrapper;
797 with_thread_info_lock({
798 rc = ldap_int_thread_create( thread, detach, start_routine, arg );
800 add_thread_info( "ldap_pvt_thread_create", thread, detach );
803 rc = ldap_int_thread_create( thread, detach, start_routine, arg );
806 ERROR( rc, "ldap_pvt_thread_create" );
811 char buf[40], buf2[40];
813 "== thr_debug: Created thread %s%s from thread %s ==\n",
814 thread_name( buf, sizeof(buf), *thread ),
815 detach ? " (detached)" : "",
816 thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
818 adjust_count( Idx_unexited_thread, +1 );
820 adjust_count( Idx_unjoined_thread, +1 );
826 ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
829 ldap_debug_thread_t *t = NULL;
830 ERROR_IF( !threading_enabled, "ldap_pvt_thread_join" );
832 char buf[40], buf2[40];
833 fprintf( stderr, "== thr_debug: Joining thread %s in thread %s ==\n",
834 thread_name( buf, sizeof(buf), thread ),
835 thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
838 with_thread_info_lock( {
839 t = get_thread_info( thread, "ldap_pvt_thread_join" );
840 ERROR_IF( thread_info_detached( t ), "ldap_pvt_thread_join" );
842 rc = ldap_int_thread_join( thread, thread_return );
844 ERROR( rc, "ldap_pvt_thread_join" );
847 with_thread_info_lock(
848 remove_thread_info( t, "ldap_pvt_thread_join" ) );
849 adjust_count( Idx_unjoined_thread, -1 );
856 ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
859 ERROR_IF( !threading_enabled, "ldap_pvt_thread_kill" );
861 char buf[40], buf2[40];
863 "== thr_debug: Killing thread %s (sig %i) from thread %s ==\n",
864 thread_name( buf, sizeof(buf), thread ), signo,
865 thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
867 rc = ldap_int_thread_kill( thread, signo );
868 ERROR_IF( rc, "ldap_pvt_thread_kill" );
873 ldap_pvt_thread_yield( void )
876 ERROR_IF( !threading_enabled, "ldap_pvt_thread_yield" );
877 rc = ldap_int_thread_yield();
878 ERROR_IF( rc, "ldap_pvt_thread_yield" );
883 ldap_pvt_thread_self( void )
885 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
886 ERROR_IF( !threading_enabled, "ldap_pvt_thread_self" );
888 return ldap_int_thread_self();
892 ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
895 init_usage( &cond->usage, "ldap_pvt_thread_cond_init" );
896 rc = ldap_int_thread_cond_init( WRAPPED( cond ) );
898 ERROR( rc, "ldap_pvt_thread_cond_init" );
899 destroy_usage( &cond->usage );
901 adjust_count( Idx_cond, +1 );
907 ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cond )
910 check_usage( &cond->usage, "ldap_pvt_thread_cond_destroy" );
911 rc = ldap_int_thread_cond_destroy( WRAPPED( cond ) );
913 ERROR( rc, "ldap_pvt_thread_cond_destroy" );
915 destroy_usage( &cond->usage );
916 adjust_count( Idx_cond, -1 );
922 ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
925 check_usage( &cond->usage, "ldap_pvt_thread_cond_signal" );
926 rc = ldap_int_thread_cond_signal( WRAPPED( cond ) );
927 ERROR_IF( rc, "ldap_pvt_thread_cond_signal" );
932 ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
935 check_usage( &cond->usage, "ldap_pvt_thread_cond_broadcast" );
936 rc = ldap_int_thread_cond_broadcast( WRAPPED( cond ) );
937 ERROR_IF( rc, "ldap_pvt_thread_cond_broadcast" );
942 ldap_pvt_thread_cond_wait(
943 ldap_pvt_thread_cond_t *cond,
944 ldap_pvt_thread_mutex_t *mutex )
947 ldap_int_thread_t owner;
948 check_usage( &cond->usage, "ldap_pvt_thread_cond_wait:cond" );
949 check_usage( &mutex->usage, "ldap_pvt_thread_cond_wait:mutex" );
950 adjust_count( Idx_locked_mutex, -1 );
951 owner = GET_OWNER( mutex );
952 ASSERT_OWNER( mutex, "ldap_pvt_thread_cond_wait" );
953 RESET_OWNER( mutex );
954 rc = ldap_int_thread_cond_wait( WRAPPED( cond ), WRAPPED( mutex ) );
955 ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_cond_wait" );
956 SET_OWNER( mutex, rc ? owner : ldap_int_thread_self() );
957 adjust_count( Idx_locked_mutex, +1 );
958 ERROR_IF( rc, "ldap_pvt_thread_cond_wait" );
963 ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
966 init_usage( &mutex->usage, "ldap_pvt_thread_mutex_init" );
967 rc = ldap_int_thread_mutex_init( WRAPPED( mutex ) );
969 ERROR( rc, "ldap_pvt_thread_mutex_init" );
970 destroy_usage( &mutex->usage );
972 RESET_OWNER( mutex );
973 adjust_count( Idx_mutex, +1 );
979 ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
982 check_usage( &mutex->usage, "ldap_pvt_thread_mutex_destroy" );
983 ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_destroy" );
984 rc = ldap_int_thread_mutex_destroy( WRAPPED( mutex ) );
986 ERROR( rc, "ldap_pvt_thread_mutex_destroy" );
988 destroy_usage( &mutex->usage );
989 RESET_OWNER( mutex );
990 adjust_count( Idx_mutex, -1 );
996 ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
999 check_usage( &mutex->usage, "ldap_pvt_thread_mutex_lock" );
1000 rc = ldap_int_thread_mutex_lock( WRAPPED( mutex ) );
1002 ERROR_IF( rc, "ldap_pvt_thread_mutex_lock" );
1004 ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_lock" );
1005 SET_OWNER( mutex, ldap_int_thread_self() );
1006 adjust_count( Idx_locked_mutex, +1 );
1012 ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mutex )
1015 check_usage( &mutex->usage, "ldap_pvt_thread_mutex_trylock" );
1016 rc = ldap_int_thread_mutex_trylock( WRAPPED( mutex ) );
1018 ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_trylock" );
1019 SET_OWNER( mutex, ldap_int_thread_self() );
1020 adjust_count( Idx_locked_mutex, +1 );
1026 ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
1029 check_usage( &mutex->usage, "ldap_pvt_thread_mutex_unlock" );
1030 ASSERT_OWNER( mutex, "ldap_pvt_thread_mutex_unlock" );
1031 RESET_OWNER( mutex ); /* Breaks if this thread did not own the mutex */
1032 rc = ldap_int_thread_mutex_unlock( WRAPPED( mutex ) );
1034 ERROR_IF( rc, "ldap_pvt_thread_mutex_unlock" );
1036 adjust_count( Idx_locked_mutex, -1 );
1042 /* Wrappers for LDAP_THREAD_RDWR_IMPLEMENTATION: */
1045 ldap_pvt_thread_rdwr_init( ldap_pvt_thread_rdwr_t *rwlock )
1048 init_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_init" );
1049 rc = ldap_int_thread_rdwr_init( WRAPPED( rwlock ) );
1051 ERROR( rc, "ldap_pvt_thread_rdwr_init" );
1052 destroy_usage( &rwlock->usage );
1054 adjust_count( Idx_rdwr, +1 );
1060 ldap_pvt_thread_rdwr_destroy( ldap_pvt_thread_rdwr_t *rwlock )
1063 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_destroy" );
1064 rc = ldap_int_thread_rdwr_destroy( WRAPPED( rwlock ) );
1066 ERROR( rc, "ldap_pvt_thread_rdwr_destroy" );
1068 destroy_usage( &rwlock->usage );
1069 adjust_count( Idx_rdwr, -1 );
1075 ldap_pvt_thread_rdwr_rlock( ldap_pvt_thread_rdwr_t *rwlock )
1078 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_rlock" );
1079 rc = ldap_int_thread_rdwr_rlock( WRAPPED( rwlock ) );
1080 ERROR_IF( rc, "ldap_pvt_thread_rdwr_rlock" );
1085 ldap_pvt_thread_rdwr_rtrylock( ldap_pvt_thread_rdwr_t *rwlock )
1087 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_rtrylock" );
1088 return ldap_int_thread_rdwr_rtrylock( WRAPPED( rwlock ) );
1092 ldap_pvt_thread_rdwr_runlock( ldap_pvt_thread_rdwr_t *rwlock )
1095 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_runlock" );
1096 rc = ldap_int_thread_rdwr_runlock( WRAPPED( rwlock ) );
1097 ERROR_IF( rc, "ldap_pvt_thread_rdwr_runlock" );
1102 ldap_pvt_thread_rdwr_wlock( ldap_pvt_thread_rdwr_t *rwlock )
1105 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wlock" );
1106 rc = ldap_int_thread_rdwr_wlock( WRAPPED( rwlock ) );
1107 ERROR_IF( rc, "ldap_pvt_thread_rdwr_wlock" );
1112 ldap_pvt_thread_rdwr_wtrylock( ldap_pvt_thread_rdwr_t *rwlock )
1114 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wtrylock" );
1115 return ldap_int_thread_rdwr_wtrylock( WRAPPED( rwlock ) );
1119 ldap_pvt_thread_rdwr_wunlock( ldap_pvt_thread_rdwr_t *rwlock )
1122 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wunlock" );
1123 rc = ldap_int_thread_rdwr_wunlock( WRAPPED( rwlock ) );
1124 ERROR_IF( rc, "ldap_pvt_thread_rdwr_wunlock" );
1128 #if defined(LDAP_RDWR_DEBUG) && !defined(LDAP_THREAD_HAVE_RDWR)
1131 ldap_pvt_thread_rdwr_readers( ldap_pvt_thread_rdwr_t *rwlock )
1133 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_readers" );
1134 return ldap_int_thread_rdwr_readers( WRAPPED( rwlock ) );
1138 ldap_pvt_thread_rdwr_writers( ldap_pvt_thread_rdwr_t *rwlock )
1140 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_writers" );
1141 return ldap_int_thread_rdwr_writers( WRAPPED( rwlock ) );
1145 ldap_pvt_thread_rdwr_active( ldap_pvt_thread_rdwr_t *rwlock )
1147 check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_active" );
1148 return ldap_int_thread_rdwr_active( WRAPPED( rwlock ) );
1151 #endif /* LDAP_RDWR_DEBUG && !LDAP_THREAD_HAVE_RDWR */
1154 /* Some wrappers for LDAP_THREAD_POOL_IMPLEMENTATION: */
1155 #ifdef LDAP_THREAD_POOL_IMPLEMENTATION
1158 ldap_pvt_thread_pool_init(
1159 ldap_pvt_thread_pool_t *tpool,
1166 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_init" );
1167 rc = ldap_int_thread_pool_init( tpool, max_threads, max_pending );
1169 ERROR( rc, "ldap_pvt_thread_pool_init" );
1171 adjust_count( Idx_tpool, +1 );
1177 ldap_pvt_thread_pool_submit(
1178 ldap_pvt_thread_pool_t *tpool,
1179 ldap_pvt_thread_start_t *start_routine, void *arg )
1182 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_submit" );
1183 has_pool = (tpool && *tpool);
1184 rc = ldap_int_thread_pool_submit( tpool, start_routine, arg );
1186 ERROR_IF( rc, "ldap_pvt_thread_pool_submit" );
1191 ldap_pvt_thread_pool_maxthreads(
1192 ldap_pvt_thread_pool_t *tpool,
1195 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_maxthreads" );
1196 return ldap_int_thread_pool_maxthreads( tpool, max_threads );
1200 ldap_pvt_thread_pool_backload( ldap_pvt_thread_pool_t *tpool )
1202 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_backload" );
1203 return ldap_int_thread_pool_backload( tpool );
1207 ldap_pvt_thread_pool_destroy( ldap_pvt_thread_pool_t *tpool, int run_pending )
1210 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_destroy" );
1211 has_pool = (tpool && *tpool);
1212 rc = ldap_int_thread_pool_destroy( tpool, run_pending );
1215 ERROR( rc, "ldap_pvt_thread_pool_destroy" );
1217 adjust_count( Idx_tpool, -1 );
1224 ldap_pvt_thread_pool_pause( ldap_pvt_thread_pool_t *tpool )
1226 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_pause" );
1227 return ldap_int_thread_pool_pause( tpool );
1231 ldap_pvt_thread_pool_resume( ldap_pvt_thread_pool_t *tpool )
1233 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_resume" );
1234 return ldap_int_thread_pool_resume( tpool );
1238 ldap_pvt_thread_pool_getkey(
1242 ldap_pvt_thread_pool_keyfree_t **kfree )
1244 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
1245 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_getkey" );
1247 return ldap_int_thread_pool_getkey( xctx, key, data, kfree );
1251 ldap_pvt_thread_pool_setkey(
1255 ldap_pvt_thread_pool_keyfree_t *kfree,
1257 ldap_pvt_thread_pool_keyfree_t **oldkfreep )
1260 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_setkey" );
1261 rc = ldap_int_thread_pool_setkey(
1262 xctx, key, data, kfree, olddatap, oldkfreep );
1263 ERROR_IF( rc, "ldap_pvt_thread_pool_setkey" );
1268 ldap_pvt_thread_pool_purgekey( void *key )
1270 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_purgekey" );
1271 ldap_int_thread_pool_purgekey( key );
1275 ldap_pvt_thread_pool_context( void )
1277 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
1278 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_context" );
1280 return ldap_int_thread_pool_context();
1284 ldap_pvt_thread_pool_context_reset( void *vctx )
1286 ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_context_reset" );
1287 ldap_int_thread_pool_context_reset( vctx );
1290 #endif /* LDAP_THREAD_POOL_IMPLEMENTATION */
1292 #endif /* LDAP_THREAD_DEBUG */