]> git.sur5r.net Git - openldap/blob - libraries/libldap_r/thr_debug.c
Merge remote branch 'origin/mdb.master'
[openldap] / libraries / libldap_r / thr_debug.c
1 /* thr_debug.c - wrapper around the chosen thread wrapper, for debugging. */
2 /* $OpenLDAP$ */
3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
4  *
5  * Copyright 2005-2012 The OpenLDAP Foundation.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted only as authorized by the OpenLDAP
10  * Public License.
11  *
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>.
15  */
16
17 /*
18  * This package provides several types of thread operation debugging:
19  *
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
23  *   slapd operation.
24  *
25  * - Wrap those types except threads and pools in structs with state
26  *   information, and check that on all operations:
27  *
28  *   + Check that the resources are initialized and are only used at
29  *     their original address (i.e. not realloced or copied).
30  *
31  *   + Check the owner (thread ID) on mutex operations.
32  *
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.
36  *
37  * - Print an error message and by default abort() upon errors.
38  *
39  * - Print a count of leaked thread resources after cleanup.
40  *
41  * Compile-time (./configure) setup:  Macros defined in CPPFLAGS.
42  *
43  *   LDAP_THREAD_DEBUG or LDAP_THREAD_DEBUG=2
44  *      Enables debugging, but value & 2 turns off type wrapping.
45  *
46  *   LDAP_UINTPTR_T=integer type to hold pointers, preferably unsigned.
47  *      Used by dummy memory option "scramble". Default = unsigned long.
48  *
49  *   LDAP_DEBUG_THREAD_NONE = initializer for a "no thread" thread ID.
50  *
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).
57  *
58  * Run-time configuration:
59  *
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.
64  *
65  *  Environment variable $LDAP_THREAD_DEBUG:
66  *   The variable may contain a comma- or space-separated option list.
67  *   Options:
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
90  *                 global variables.
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.
99  */
100
101 #include "portable.h"
102
103 #if defined( LDAP_THREAD_DEBUG )
104
105 #include <stdio.h>
106 #include <ac/errno.h>
107 #include <ac/stdlib.h>
108 #include <ac/string.h>
109
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 */
116
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
121 #endif
122
123 /* Use native malloc - the OpenLDAP wrappers may defeat malloc debuggers */
124 #undef malloc
125 #undef calloc
126 #undef realloc
127 #undef free
128
129
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;
137 #endif
138 #if LDAP_THREAD_DEBUG_THREAD_ID +0
139 static int threadID;
140 #else
141 enum { threadID = 0 };
142 #endif
143 static int nodebug, noabort, noerror, nosync, tracethreads;
144 static int wrap_threads;
145 static int options_done;
146
147
148 /* ldap_pvt_thread_initialize() called, ldap_pvt_thread_destroy() not called */
149 static int threading_enabled;
150
151
152 /* Resource counts */
153 enum {
154         Idx_unexited_thread, Idx_unjoined_thread, Idx_locked_mutex,
155         Idx_mutex, Idx_cond, Idx_rdwr, Idx_tpool, Idx_max
156 };
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"
161 };
162 static ldap_int_thread_mutex_t resource_mutexes[Idx_max];
163
164
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))
169
170
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));}
173
174 #define ERROR(var, msg) { \
175         if (!noerror) { \
176                 errmsg(__FILE__, __LINE__, (msg), #var, (var)); \
177                 if( !noabort ) abort(); \
178         } \
179 }
180
181 #define ERROR_IF(rc, msg) { \
182         if (!noerror) { \
183                 int rc_ = (rc); \
184                 if (rc_) { \
185                         errmsg(__FILE__, __LINE__, (msg), #rc, rc_); \
186                         if( !noabort ) abort(); \
187                 } \
188         } \
189 }
190
191 #ifdef LDAP_THREAD_DEBUG_WRAP
192 #define MEMERROR_IF(rc, msg, mem_act) { \
193         if (!noerror) { \
194                 int rc_ = (rc); \
195                 if (rc_) { \
196                         errmsg(__FILE__, __LINE__, (msg), #rc, rc_); \
197                         if( wraptype != Wrap_noalloc ) { mem_act; } \
198                         if( !noabort ) abort(); \
199                 } \
200         } \
201 }
202 #endif /* LDAP_THREAD_DEBUG_WRAP */
203
204 #if 0
205 static void
206 warn( const char *file, int line, const char *msg, const char *var, int val )
207 {
208         fprintf( stderr,
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 );
213 }
214 #endif
215
216 static void
217 errmsg( const char *file, int line, const char *msg, const char *var, int val )
218 {
219         fprintf( stderr,
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 );
224 }
225
226 static void
227 count_resource_leaks( void )
228 {
229         int i, j;
230         char errbuf[200];
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" );
237 #endif
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] );
242                 if( j )
243                         fprintf( stderr, "== thr_debug: Leaked%s. ==\n", errbuf + 1 );
244         }
245 }
246
247 static void
248 get_options( void )
249 {
250         static const struct option_info_s {
251                 const char      *name;
252                 int             *var, val;
253         } option_info[] = {
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 },
261 #endif
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 },
269 #endif
270                 { "tracethreads", &tracethreads, 1 },
271                 { NULL, NULL, 0 }
272         };
273         const char *s = getenv( "LDAP_THREAD_DEBUG" );
274         if( s != NULL ) {
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;
278                         while( oi->name &&
279                                    (strncasecmp( oi->name, s, optlen ) || oi->name[optlen]) )
280                                 oi++;
281                         if( oi->name )
282                                 *oi->var = oi->val;
283                         else
284                                 fprintf( stderr,
285                                         "== thr_debug: Unknown $%s option '%.*s' ==\n",
286                                         "LDAP_THREAD_DEBUG", (int) optlen, s );
287                         s += optlen;
288                 }
289         }
290         if( nodebug ) {
291                 tracethreads = 0;
292                 nosync = noerror = 1;
293         }
294         if( nosync )
295                 count = Count_no;
296         if( noerror )
297                 noabort = 1;
298 #if LDAP_THREAD_DEBUG_THREAD_ID +0
299         if( nosync )
300                 threadID = 0;
301 #endif
302 #ifdef LDAP_THREAD_DEBUG_WRAP
303         if( noerror )
304                 nomem = 1;
305         if( !nomem ) {
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 ) ) )
311                 {
312                         fputs( "== thr_debug: Memory checks unsupported, "
313                                 "adding nomem to $LDAP_THREAD_DEBUG ==\n", stderr );
314                         nomem = 1;
315                 }
316         }
317         if( nomem ) {
318                 noreinit = 1;
319                 wraptype = Wrap_noalloc;
320         }
321         unwrap_offset = -(wrap_offset = (wraptype == Wrap_adjptr));
322 #endif
323         wrap_threads = (tracethreads || threadID || count);
324         options_done = 1;
325 }
326
327
328 #ifndef LDAP_THREAD_DEBUG_WRAP
329
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)
336
337 #define init_usage(ptr, msg)    ((void) 0)
338 #define check_usage(ptr, msg)   ((void) 0)
339 #define destroy_usage(ptr)              ((void) 0)
340
341 #else /* LDAP_THREAD_DEBUG_WRAP */
342
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 */
347 #endif
348
349 static const ldap_int_thread_t ldap_debug_thread_none = LDAP_DEBUG_THREAD_NONE;
350
351 #define THREAD_MUTEX_OWNER(mutex) \
352         ldap_int_thread_equal( (mutex)->owner, ldap_int_thread_self() )
353
354 void
355 ldap_debug_thread_assert_mutex_owner(
356         const char *file,
357         int line,
358         const char *msg,
359         ldap_pvt_thread_mutex_t *mutex )
360 {
361         if( !(noerror || THREAD_MUTEX_OWNER( mutex )) ) {
362                 errmsg( file, line, msg, "ASSERT_MUTEX_OWNER", 0 );
363                 if( !noabort ) abort();
364         }
365 }
366
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 )
375 #endif
376
377 /* Try to provoke memory access error (for malloc debuggers) */
378 #define PEEK(mem) {if (-*(volatile const unsigned char *)(mem)) debug_noop();}
379
380 static void debug_noop( void );
381 static int debug_already_initialized( const ldap_debug_usage_info_t *usage );
382
383 /* Name used for clearer error message */
384 #define IS_COPY_OR_MOVED(usage) ((usage)->self != SCRAMBLE( usage ))
385
386 #define DUMMY_ADDR(usage) \
387         (wraptype == Wrap_scramble \
388          ? UNSCRAMBLE_dummyp( (usage)->mem.num ) \
389          : (usage)->mem.ptr + unwrap_offset)
390
391 /* Mark resource as initialized */
392 static void
393 init_usage( ldap_debug_usage_info_t *usage, const char *msg )
394 {
395         if( !options_done )
396                 get_options();
397         if( !nomem ) {
398                 if( !noreinit ) {
399                         MEMERROR_IF( debug_already_initialized( usage ), msg, {
400                                 /* Provoke malloc debuggers */
401                                 unsigned char *dummy = DUMMY_ADDR( usage );
402                                 PEEK( dummy );
403                                 free( dummy );
404                                 free( dummy );
405                         } );
406                 }
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 );
414                         } else {
415                                 usage->mem.ptr = dummy + wrap_offset;
416                         }
417                 }
418         } else {
419                 /* Unused, but set for readability in debugger */
420                 usage->mem.ptr = NULL;
421         }
422         usage->self = SCRAMBLE( usage );        /* If nomem, only for debugger */
423         usage->magic = ldap_debug_magic;
424         usage->state = ldap_debug_state_inited;
425 }
426
427 /* Check that resource is initialized and not copied/realloced */
428 static void
429 check_usage( const ldap_debug_usage_info_t *usage, const char *msg )
430 {
431         enum { Is_destroyed = 1 };      /* Name used for clearer error message */
432
433         if( usage->magic != ldap_debug_magic ) {
434                 ERROR( usage->magic, msg );
435                 return;
436         }
437         switch( usage->state ) {
438         case ldap_debug_state_destroyed:
439                 MEMERROR_IF( Is_destroyed, msg, {
440                         PEEK( DUMMY_ADDR( usage ) );
441                 } );
442                 break;
443         default:
444                 ERROR( usage->state, msg );
445                 break;
446         case ldap_debug_state_inited:
447                 if( !nomem ) {
448                         MEMERROR_IF( IS_COPY_OR_MOVED( usage ), msg, {
449                                 PEEK( DUMMY_ADDR( usage ) );
450                                 PEEK( UNSCRAMBLE_usagep( usage->self ) );
451                         } );
452                 }
453                 break;
454         }
455 }
456
457 /* Mark resource as destroyed. */
458 /* Does not check for errors, call check_usage()/init_usage() first. */
459 static void
460 destroy_usage( ldap_debug_usage_info_t *usage )
461 {
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. */
467                 }
468                 usage->state = ldap_debug_state_destroyed;
469         }
470 }
471
472 /* Define these after they are used, so they are hopefully not inlined */
473
474 static void
475 debug_noop( void )
476 {
477 }
478
479 /*
480  * Valid programs access uninitialized memory here unless "noreinit".
481  *
482  * Returns true if the resource is initialized and not copied/realloced.
483  */
484 static int
485 debug_already_initialized( const ldap_debug_usage_info_t *usage )
486 {
487         /*
488          * 'ret' keeps the Valgrind warning "Conditional jump or move
489          * depends on uninitialised value(s)" _inside_ this function.
490          */
491         volatile int ret = 0;
492         if( usage->state == ldap_debug_state_inited )
493                 if( !IS_COPY_OR_MOVED( usage ) )
494                 if( usage->magic == ldap_debug_magic )
495                                 ret = 1;
496         return ret;
497 }
498
499 #endif /* LDAP_THREAD_DEBUG_WRAP */
500
501
502 #if !(LDAP_THREAD_DEBUG_THREAD_ID +0)
503
504 typedef void ldap_debug_thread_t;
505 #define init_thread_info()      {}
506 #define with_thread_info_lock(statements) { statements; }
507 #define thread_info_detached(t) 0
508 #define add_thread_info(msg, thr, det)  ((void) 0)
509 #define remove_thread_info(tinfo, msg)  ((void) 0)
510 #define get_thread_info(thread, msg)    NULL
511
512 #else /* LDAP_THREAD_DEBUG_THREAD_ID */
513
514 /*
515  * Thread ID tracking.  Currently acieves little.
516  * Should be either expanded or deleted.
517  */
518
519 /*
520  * Array of threads.  Used instead of making ldap_pvt_thread_t a wrapper
521  * around ldap_int_thread_t, which would slow down ldap_pvt_thread_self().
522  */
523 typedef struct {
524         ldap_pvt_thread_t           wrapped;
525         ldap_debug_usage_info_t     usage;
526         int                         detached;
527         int                         idx;
528 } ldap_debug_thread_t;
529
530 static ldap_debug_thread_t      **thread_info;
531 static unsigned int             thread_info_size, thread_info_used;
532 static ldap_int_thread_mutex_t  thread_info_mutex;
533
534 #define init_thread_info() { \
535         if( threadID ) { \
536                 int mutex_init_rc = ldap_int_thread_mutex_init( &thread_info_mutex ); \
537                 assert( mutex_init_rc == 0 ); \
538         } \
539 }
540
541 #define with_thread_info_lock(statements) { \
542         int rc_wtl_ = ldap_int_thread_mutex_lock( &thread_info_mutex ); \
543         assert( rc_wtl_ == 0 ); \
544         { statements; } \
545         rc_wtl_ = ldap_int_thread_mutex_unlock( &thread_info_mutex ); \
546         assert( rc_wtl_ == 0 ); \
547 }
548
549 #define thread_info_detached(t) ((t)->detached)
550
551 static void
552 add_thread_info(
553         const char *msg,
554         const ldap_pvt_thread_t *thread,
555         int detached )
556 {
557         ldap_debug_thread_t *t;
558
559         if( thread_info_used >= thread_info_size ) {
560                 unsigned int more = thread_info_size + 8;
561                 unsigned int new_size = thread_info_size + more;
562
563                 t = calloc( more, sizeof(ldap_debug_thread_t) );
564                 assert( t != NULL );
565                 thread_info = realloc( thread_info, new_size * sizeof(*thread_info) );
566                 assert( thread_info != NULL );
567                 do {
568                         t->idx = thread_info_size;
569                         thread_info[thread_info_size++] = t++;
570                 } while( thread_info_size < new_size );
571         }
572
573         t = thread_info[thread_info_used];
574         init_usage( &t->usage, msg );
575         t->wrapped = *thread;
576         t->detached = detached;
577         thread_info_used++;
578 }
579
580 static void
581 remove_thread_info( ldap_debug_thread_t *t, const char *msg )
582 {
583                 ldap_debug_thread_t *last;
584                 int idx;
585                 check_usage( &t->usage, msg );
586                 destroy_usage( &t->usage );
587                 idx = t->idx;
588                 assert( thread_info[idx] == t );
589                 last = thread_info[--thread_info_used];
590                 assert( last->idx == thread_info_used );
591                 (thread_info[idx]              = last)->idx = idx;
592                 (thread_info[thread_info_used] = t   )->idx = thread_info_used;
593 }
594
595 static ldap_debug_thread_t *
596 get_thread_info( ldap_pvt_thread_t thread, const char *msg )
597 {
598         unsigned int i;
599         ldap_debug_thread_t *t;
600         for( i = 0; i < thread_info_used; i++ ) {
601                 if( ldap_pvt_thread_equal( thread, thread_info[i]->wrapped ) )
602                         break;
603         }
604         ERROR_IF( i == thread_info_used, msg );
605         t = thread_info[i];
606         check_usage( &t->usage, msg );
607         return t;
608 }
609
610 #endif /* LDAP_THREAD_DEBUG_THREAD_ID */
611
612
613 static char *
614 thread_name( char *buf, int bufsize, ldap_pvt_thread_t thread )
615 {
616         int i;
617         --bufsize;
618         if( bufsize > 2*sizeof(thread) )
619                 bufsize = 2*sizeof(thread);
620         for( i = 0; i < bufsize; i += 2 )
621                 snprintf( buf+i, 3, "%02x", ((unsigned char *)&thread)[i/2] );
622         return buf;
623 }
624
625
626 /* Add <adjust> (+/-1) to resource count <which> unless "nocount". */
627 static void
628 adjust_count( int which, int adjust )
629 {
630         int rc;
631         switch( count ) {
632         case Count_no:
633                 break;
634         case Count_yes:
635                 rc = ldap_int_thread_mutex_lock( &resource_mutexes[which] );
636                 assert( rc == 0 );
637                 resource_counts[which] += adjust;
638                 rc = ldap_int_thread_mutex_unlock( &resource_mutexes[which] );
639                 assert( rc == 0 );
640                 break;
641         case Count_reported:
642                 fputs( "== thr_debug: More thread activity after exit ==\n", stderr );
643                 count = Count_reported_more;
644                 /* FALL THROUGH */
645         case Count_reported_more:
646                 /* Not used, but result might be inspected with debugger */
647                 /* (Hopefully threading is disabled by now...) */
648                 resource_counts[which] += adjust;
649                 break;
650         }
651 }
652
653
654 /* Wrappers for LDAP_THREAD_IMPLEMENTATION: */
655
656 /* Used instead of ldap_int_thread_initialize by ldap_pvt_thread_initialize */
657 int
658 ldap_debug_thread_initialize( void )
659 {
660         int i, rc, rc2;
661         if( !options_done )
662                 get_options();
663         ERROR_IF( threading_enabled, "ldap_debug_thread_initialize" );
664         threading_enabled = 1;
665         rc = ldap_int_thread_initialize();
666         if( rc ) {
667                 ERROR( rc, "ldap_debug_thread_initialize:threads" );
668                 threading_enabled = 0;
669         } else {
670                 init_thread_info();
671                 if( count != Count_no ) {
672                         for( i = rc2 = 0; i < Idx_max; i++ )
673                                 rc2 |= ldap_int_thread_mutex_init( &resource_mutexes[i] );
674                         assert( rc2 == 0 );
675                         /* FIXME: Only for static libldap_r as in init.c? If so, why? */
676                         atexit( count_resource_leaks );
677                 }
678         }
679         return rc;
680 }
681
682 /* Used instead of ldap_int_thread_destroy by ldap_pvt_thread_destroy */
683 int
684 ldap_debug_thread_destroy( void )
685 {
686         int rc;
687         ERROR_IF( !threading_enabled, "ldap_debug_thread_destroy" );
688         /* sleep(1) -- need to wait for thread pool to finish? */
689         rc = ldap_int_thread_destroy();
690         if( rc ) {
691                 ERROR( rc, "ldap_debug_thread_destroy:threads" );
692         } else {
693                 threading_enabled = 0;
694         }
695         return rc;
696 }
697
698 int
699 ldap_pvt_thread_set_concurrency( int n )
700 {
701         int rc;
702         ERROR_IF( !threading_enabled, "ldap_pvt_thread_set_concurrency" );
703         rc = ldap_int_thread_set_concurrency( n );
704         ERROR_IF( rc, "ldap_pvt_thread_set_concurrency" );
705         return rc;
706 }
707
708 int
709 ldap_pvt_thread_get_concurrency( void )
710 {
711         int rc;
712         ERROR_IF( !threading_enabled, "ldap_pvt_thread_get_concurrency" );
713         rc = ldap_int_thread_get_concurrency();
714         ERROR_IF( rc, "ldap_pvt_thread_get_concurrency" );
715         return rc;
716 }
717
718 unsigned int
719 ldap_pvt_thread_sleep( unsigned int interval )
720 {
721         int rc;
722         ERROR_IF( !threading_enabled, "ldap_pvt_thread_sleep" );
723         rc = ldap_int_thread_sleep( interval );
724         ERROR_IF( rc, "ldap_pvt_thread_sleep" );
725         return 0;
726 }
727
728 static void
729 thread_exiting( const char *how, const char *msg )
730 {
731         ldap_pvt_thread_t thread;
732 #if 0 /* Detached threads may exit after ldap_debug_thread_destroy(). */
733         ERROR_IF( !threading_enabled, msg );
734 #endif
735         thread = ldap_pvt_thread_self();
736         if( tracethreads ) {
737                 char buf[40];
738                 fprintf( stderr, "== thr_debug: %s thread %s ==\n",
739                         how, thread_name( buf, sizeof(buf), thread ) );
740         }
741         if( threadID ) {
742                 with_thread_info_lock({
743                         ldap_debug_thread_t *t = get_thread_info( thread, msg );
744                         if( thread_info_detached( t ) )
745                                 remove_thread_info( t, msg );
746                 });
747         }
748         adjust_count( Idx_unexited_thread, -1 );
749 }
750
751 void
752 ldap_pvt_thread_exit( void *retval )
753 {
754         thread_exiting( "Exiting", "ldap_pvt_thread_exit" );
755         ldap_int_thread_exit( retval );
756 }
757
758 typedef struct {
759         void *(*start_routine)( void * );
760         void *arg;
761 } ldap_debug_thread_call_t;
762
763 static void *
764 ldap_debug_thread_wrapper( void *arg )
765 {
766         void *ret;
767         ldap_debug_thread_call_t call = *(ldap_debug_thread_call_t *)arg;
768         free( arg );
769         ret = call.start_routine( call.arg );
770         thread_exiting( "Returning from", "ldap_debug_thread_wrapper" );
771         return ret;
772 }
773
774 int
775 ldap_pvt_thread_create(
776         ldap_pvt_thread_t *thread,
777         int detach,
778         void *(*start_routine)( void * ),
779         void *arg )
780 {
781         int rc;
782         if( !options_done )
783                 get_options();
784         ERROR_IF( !threading_enabled, "ldap_pvt_thread_create" );
785
786         if( wrap_threads ) {
787                 ldap_debug_thread_call_t *call = malloc(
788                         sizeof( ldap_debug_thread_call_t ) );
789                 assert( call != NULL );
790                 call->start_routine = start_routine;
791                 call->arg = arg;
792                 start_routine = ldap_debug_thread_wrapper;
793                 arg = call;
794         }
795         if( threadID ) {
796                 with_thread_info_lock({
797                         rc = ldap_int_thread_create( thread, detach, start_routine, arg );
798                         if( rc == 0 )
799                                 add_thread_info( "ldap_pvt_thread_create", thread, detach );
800                 });
801         } else {
802                 rc = ldap_int_thread_create( thread, detach, start_routine, arg );
803         }
804         if( rc ) {
805                 ERROR( rc, "ldap_pvt_thread_create" );
806                 if( wrap_threads )
807                         free( arg );
808         } else {
809                 if( tracethreads ) {
810                         char buf[40], buf2[40];
811                         fprintf( stderr,
812                                 "== thr_debug: Created thread %s%s from thread %s ==\n",
813                                 thread_name( buf, sizeof(buf), *thread ),
814                                 detach ? " (detached)" : "",
815                                 thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
816                 }
817                 adjust_count( Idx_unexited_thread, +1 );
818                 if( !detach )
819                         adjust_count( Idx_unjoined_thread, +1 );
820         }
821         return rc;
822 }
823
824 int
825 ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
826 {
827         int rc;
828         ldap_debug_thread_t *t = NULL;
829         ERROR_IF( !threading_enabled, "ldap_pvt_thread_join" );
830         if( tracethreads ) {
831                 char buf[40], buf2[40];
832                 fprintf( stderr, "== thr_debug: Joining thread %s in thread %s ==\n",
833                         thread_name( buf, sizeof(buf), thread ),
834                         thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
835         }
836         if( threadID )
837                 with_thread_info_lock( {
838                         t = get_thread_info( thread, "ldap_pvt_thread_join" );
839                         ERROR_IF( thread_info_detached( t ), "ldap_pvt_thread_join" );
840                 } );
841         rc = ldap_int_thread_join( thread, thread_return );
842         if( rc ) {
843                 ERROR( rc, "ldap_pvt_thread_join" );
844         } else {
845                 if( threadID )
846                         with_thread_info_lock(
847                                 remove_thread_info( t, "ldap_pvt_thread_join" ) );
848                 adjust_count( Idx_unjoined_thread, -1 );
849         }
850
851         return rc;
852 }
853
854 int
855 ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
856 {
857         int rc;
858         ERROR_IF( !threading_enabled, "ldap_pvt_thread_kill" );
859         if( tracethreads ) {
860                 char buf[40], buf2[40];
861                 fprintf( stderr,
862                         "== thr_debug: Killing thread %s (sig %i) from thread %s ==\n",
863                         thread_name( buf, sizeof(buf), thread ), signo,
864                         thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
865         }
866         rc = ldap_int_thread_kill( thread, signo );
867         ERROR_IF( rc, "ldap_pvt_thread_kill" );
868         return rc;
869 }
870
871 int
872 ldap_pvt_thread_yield( void )
873 {
874         int rc;
875         ERROR_IF( !threading_enabled, "ldap_pvt_thread_yield" );
876         rc = ldap_int_thread_yield();
877         ERROR_IF( rc, "ldap_pvt_thread_yield" );
878         return rc;
879 }
880
881 ldap_pvt_thread_t
882 ldap_pvt_thread_self( void )
883 {
884 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
885         ERROR_IF( !threading_enabled, "ldap_pvt_thread_self" );
886 #endif
887         return ldap_int_thread_self();
888 }
889
890 int
891 ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
892 {
893         int rc;
894         init_usage( &cond->usage, "ldap_pvt_thread_cond_init" );
895         rc = ldap_int_thread_cond_init( WRAPPED( cond ) );
896         if( rc ) {
897                 ERROR( rc, "ldap_pvt_thread_cond_init" );
898                 destroy_usage( &cond->usage );
899         } else {
900                 adjust_count( Idx_cond, +1 );
901         }
902         return rc;
903 }
904
905 int
906 ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cond )
907 {
908         int rc;
909         check_usage( &cond->usage, "ldap_pvt_thread_cond_destroy" );
910         rc = ldap_int_thread_cond_destroy( WRAPPED( cond ) );
911         if( rc ) {
912                 ERROR( rc, "ldap_pvt_thread_cond_destroy" );
913         } else {
914                 destroy_usage( &cond->usage );
915                 adjust_count( Idx_cond, -1 );
916         }
917         return rc;
918 }
919
920 int
921 ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
922 {
923         int rc;
924         check_usage( &cond->usage, "ldap_pvt_thread_cond_signal" );
925         rc = ldap_int_thread_cond_signal( WRAPPED( cond ) );
926         ERROR_IF( rc, "ldap_pvt_thread_cond_signal" );
927         return rc;
928 }
929
930 int
931 ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
932 {
933         int rc;
934         check_usage( &cond->usage, "ldap_pvt_thread_cond_broadcast" );
935         rc = ldap_int_thread_cond_broadcast( WRAPPED( cond ) );
936         ERROR_IF( rc, "ldap_pvt_thread_cond_broadcast" );
937         return rc;
938 }
939
940 int
941 ldap_pvt_thread_cond_wait(
942         ldap_pvt_thread_cond_t *cond,
943         ldap_pvt_thread_mutex_t *mutex )
944 {
945         int rc;
946         ldap_int_thread_t owner;
947         check_usage( &cond->usage, "ldap_pvt_thread_cond_wait:cond" );
948         check_usage( &mutex->usage, "ldap_pvt_thread_cond_wait:mutex" );
949         adjust_count( Idx_locked_mutex, -1 );
950         owner = GET_OWNER( mutex );
951         ASSERT_OWNER( mutex, "ldap_pvt_thread_cond_wait" );
952         RESET_OWNER( mutex );
953         rc = ldap_int_thread_cond_wait( WRAPPED( cond ), WRAPPED( mutex ) );
954         ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_cond_wait" );
955         SET_OWNER( mutex, rc ? owner : ldap_int_thread_self() );
956         adjust_count( Idx_locked_mutex, +1 );
957         ERROR_IF( rc, "ldap_pvt_thread_cond_wait" );
958         return rc;
959 }
960
961 int
962 ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
963 {
964         int rc;
965         init_usage( &mutex->usage, "ldap_pvt_thread_mutex_init" );
966         rc = ldap_int_thread_mutex_init( WRAPPED( mutex ) );
967         if( rc ) {
968                 ERROR( rc, "ldap_pvt_thread_mutex_init" );
969                 destroy_usage( &mutex->usage );
970         } else {
971                 RESET_OWNER( mutex );
972                 adjust_count( Idx_mutex, +1 );
973         }
974         return rc;
975 }
976
977 int
978 ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
979 {
980         int rc;
981         check_usage( &mutex->usage, "ldap_pvt_thread_mutex_destroy" );
982         ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_destroy" );
983         rc = ldap_int_thread_mutex_destroy( WRAPPED( mutex ) );
984         if( rc ) {
985                 ERROR( rc, "ldap_pvt_thread_mutex_destroy" );
986         } else {
987                 destroy_usage( &mutex->usage );
988                 RESET_OWNER( mutex );
989                 adjust_count( Idx_mutex, -1 );
990         }
991         return rc;
992 }
993
994 int
995 ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
996 {
997         int rc;
998         check_usage( &mutex->usage, "ldap_pvt_thread_mutex_lock" );
999         rc = ldap_int_thread_mutex_lock( WRAPPED( mutex ) );
1000         if( rc ) {
1001                 ERROR_IF( rc, "ldap_pvt_thread_mutex_lock" );
1002         } else {
1003                 ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_lock" );
1004                 SET_OWNER( mutex, ldap_int_thread_self() );
1005                 adjust_count( Idx_locked_mutex, +1 );
1006         }
1007         return rc;
1008 }
1009
1010 int
1011 ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mutex )
1012 {
1013         int rc;
1014         check_usage( &mutex->usage, "ldap_pvt_thread_mutex_trylock" );
1015         rc = ldap_int_thread_mutex_trylock( WRAPPED( mutex ) );
1016         if( rc == 0 ) {
1017                 ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_trylock" );
1018                 SET_OWNER( mutex, ldap_int_thread_self() );
1019                 adjust_count( Idx_locked_mutex, +1 );
1020         }
1021         return rc;
1022 }
1023
1024 int
1025 ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
1026 {
1027         int rc;
1028         check_usage( &mutex->usage, "ldap_pvt_thread_mutex_unlock" );
1029         ASSERT_OWNER( mutex, "ldap_pvt_thread_mutex_unlock" );
1030         RESET_OWNER( mutex ); /* Breaks if this thread did not own the mutex */
1031         rc = ldap_int_thread_mutex_unlock( WRAPPED( mutex ) );
1032         if( rc ) {
1033                 ERROR_IF( rc, "ldap_pvt_thread_mutex_unlock" );
1034         } else {
1035                 adjust_count( Idx_locked_mutex, -1 );
1036         }
1037         return rc;
1038 }
1039
1040
1041 /* Wrappers for LDAP_THREAD_RDWR_IMPLEMENTATION: */
1042
1043 int
1044 ldap_pvt_thread_rdwr_init( ldap_pvt_thread_rdwr_t *rwlock )
1045 {
1046         int rc;
1047         init_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_init" );
1048         rc = ldap_int_thread_rdwr_init( WRAPPED( rwlock ) );
1049         if( rc ) {
1050                 ERROR( rc, "ldap_pvt_thread_rdwr_init" );
1051                 destroy_usage( &rwlock->usage );
1052         } else {
1053                 adjust_count( Idx_rdwr, +1 );
1054         }
1055         return rc;
1056 }
1057
1058 int
1059 ldap_pvt_thread_rdwr_destroy( ldap_pvt_thread_rdwr_t *rwlock )
1060 {
1061         int rc;
1062         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_destroy" );
1063         rc = ldap_int_thread_rdwr_destroy( WRAPPED( rwlock ) );
1064         if( rc ) {
1065                 ERROR( rc, "ldap_pvt_thread_rdwr_destroy" );
1066         } else {
1067                 destroy_usage( &rwlock->usage );
1068                 adjust_count( Idx_rdwr, -1 );
1069         }
1070         return rc;
1071 }
1072
1073 int
1074 ldap_pvt_thread_rdwr_rlock( ldap_pvt_thread_rdwr_t *rwlock )
1075 {
1076         int rc;
1077         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_rlock" );
1078         rc = ldap_int_thread_rdwr_rlock( WRAPPED( rwlock ) );
1079         ERROR_IF( rc, "ldap_pvt_thread_rdwr_rlock" );
1080         return rc;
1081 }
1082
1083 int
1084 ldap_pvt_thread_rdwr_rtrylock( ldap_pvt_thread_rdwr_t *rwlock )
1085 {
1086         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_rtrylock" );
1087         return ldap_int_thread_rdwr_rtrylock( WRAPPED( rwlock ) );
1088 }
1089
1090 int
1091 ldap_pvt_thread_rdwr_runlock( ldap_pvt_thread_rdwr_t *rwlock )
1092 {
1093         int rc;
1094         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_runlock" );
1095         rc = ldap_int_thread_rdwr_runlock( WRAPPED( rwlock ) );
1096         ERROR_IF( rc, "ldap_pvt_thread_rdwr_runlock" );
1097         return rc;
1098 }
1099
1100 int
1101 ldap_pvt_thread_rdwr_wlock( ldap_pvt_thread_rdwr_t *rwlock )
1102 {
1103         int rc;
1104         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wlock" );
1105         rc = ldap_int_thread_rdwr_wlock( WRAPPED( rwlock ) );
1106         ERROR_IF( rc, "ldap_pvt_thread_rdwr_wlock" );
1107         return rc;
1108 }
1109
1110 int
1111 ldap_pvt_thread_rdwr_wtrylock( ldap_pvt_thread_rdwr_t *rwlock )
1112 {
1113         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wtrylock" );
1114         return ldap_int_thread_rdwr_wtrylock( WRAPPED( rwlock ) );
1115 }
1116
1117 int
1118 ldap_pvt_thread_rdwr_wunlock( ldap_pvt_thread_rdwr_t *rwlock )
1119 {
1120         int rc;
1121         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wunlock" );
1122         rc = ldap_int_thread_rdwr_wunlock( WRAPPED( rwlock ) );
1123         ERROR_IF( rc, "ldap_pvt_thread_rdwr_wunlock" );
1124         return rc;
1125 }
1126
1127 #if defined(LDAP_RDWR_DEBUG) && !defined(LDAP_THREAD_HAVE_RDWR)
1128
1129 int
1130 ldap_pvt_thread_rdwr_readers( ldap_pvt_thread_rdwr_t *rwlock )
1131 {
1132         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_readers" );
1133         return ldap_int_thread_rdwr_readers( WRAPPED( rwlock ) );
1134 }
1135
1136 int
1137 ldap_pvt_thread_rdwr_writers( ldap_pvt_thread_rdwr_t *rwlock )
1138 {
1139         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_writers" );
1140         return ldap_int_thread_rdwr_writers( WRAPPED( rwlock ) );
1141 }
1142
1143 int
1144 ldap_pvt_thread_rdwr_active( ldap_pvt_thread_rdwr_t *rwlock )
1145 {
1146         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_active" );
1147         return ldap_int_thread_rdwr_active( WRAPPED( rwlock ) );
1148 }
1149
1150 #endif /* LDAP_RDWR_DEBUG && !LDAP_THREAD_HAVE_RDWR */
1151
1152
1153 /* Some wrappers for LDAP_THREAD_POOL_IMPLEMENTATION: */
1154 #ifdef LDAP_THREAD_POOL_IMPLEMENTATION
1155
1156 int
1157 ldap_pvt_thread_pool_init(
1158         ldap_pvt_thread_pool_t *tpool,
1159         int max_threads,
1160         int max_pending )
1161 {
1162         int rc;
1163         if( !options_done )
1164                 get_options();
1165         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_init" );
1166         rc = ldap_int_thread_pool_init( tpool, max_threads, max_pending );
1167         if( rc ) {
1168                 ERROR( rc, "ldap_pvt_thread_pool_init" );
1169         } else {
1170                 adjust_count( Idx_tpool, +1 );
1171         }
1172         return rc;
1173 }
1174
1175 int
1176 ldap_pvt_thread_pool_submit(
1177         ldap_pvt_thread_pool_t *tpool,
1178         ldap_pvt_thread_start_t *start_routine, void *arg )
1179 {
1180         int rc, has_pool;
1181         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_submit" );
1182         has_pool = (tpool && *tpool);
1183         rc = ldap_int_thread_pool_submit( tpool, start_routine, arg );
1184         if( has_pool )
1185                 ERROR_IF( rc, "ldap_pvt_thread_pool_submit" );
1186         return rc;
1187 }
1188
1189 int
1190 ldap_pvt_thread_pool_maxthreads(
1191         ldap_pvt_thread_pool_t *tpool,
1192         int max_threads )
1193 {
1194         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_maxthreads" );
1195         return ldap_int_thread_pool_maxthreads( tpool, max_threads );
1196 }
1197
1198 int
1199 ldap_pvt_thread_pool_backload( ldap_pvt_thread_pool_t *tpool )
1200 {
1201         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_backload" );
1202         return ldap_int_thread_pool_backload( tpool );
1203 }
1204
1205 int
1206 ldap_pvt_thread_pool_destroy( ldap_pvt_thread_pool_t *tpool, int run_pending )
1207 {
1208         int rc, has_pool;
1209         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_destroy" );
1210         has_pool = (tpool && *tpool);
1211         rc = ldap_int_thread_pool_destroy( tpool, run_pending );
1212         if( has_pool ) {
1213                 if( rc ) {
1214                         ERROR( rc, "ldap_pvt_thread_pool_destroy" );
1215                 } else {
1216                         adjust_count( Idx_tpool, -1 );
1217                 }
1218         }
1219         return rc;
1220 }
1221
1222 int
1223 ldap_pvt_thread_pool_pause( ldap_pvt_thread_pool_t *tpool )
1224 {
1225         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_pause" );
1226         return ldap_int_thread_pool_pause( tpool );
1227 }
1228
1229 int
1230 ldap_pvt_thread_pool_resume( ldap_pvt_thread_pool_t *tpool )
1231 {
1232         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_resume" );
1233         return ldap_int_thread_pool_resume( tpool );
1234 }
1235
1236 int
1237 ldap_pvt_thread_pool_getkey(
1238         void *xctx,
1239         void *key,
1240         void **data,
1241         ldap_pvt_thread_pool_keyfree_t **kfree )
1242 {
1243 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
1244         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_getkey" );
1245 #endif
1246         return ldap_int_thread_pool_getkey( xctx, key, data, kfree );
1247 }
1248
1249 int
1250 ldap_pvt_thread_pool_setkey(
1251         void *xctx,
1252         void *key,
1253         void *data,
1254         ldap_pvt_thread_pool_keyfree_t *kfree,
1255         void **olddatap,
1256         ldap_pvt_thread_pool_keyfree_t **oldkfreep )
1257 {
1258         int rc;
1259         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_setkey" );
1260         rc = ldap_int_thread_pool_setkey(
1261                 xctx, key, data, kfree, olddatap, oldkfreep );
1262         ERROR_IF( rc, "ldap_pvt_thread_pool_setkey" );
1263         return rc;
1264 }
1265
1266 void
1267 ldap_pvt_thread_pool_purgekey( void *key )
1268 {
1269         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_purgekey" );
1270         ldap_int_thread_pool_purgekey( key );
1271 }
1272
1273 void *
1274 ldap_pvt_thread_pool_context( void )
1275 {
1276 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
1277         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_context" );
1278 #endif
1279         return ldap_int_thread_pool_context();
1280 }
1281
1282 void
1283 ldap_pvt_thread_pool_context_reset( void *vctx )
1284 {
1285         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_context_reset" );
1286         ldap_int_thread_pool_context_reset( vctx );
1287 }
1288
1289 #endif /* LDAP_THREAD_POOL_IMPLEMENTATION */
1290
1291 #endif /* LDAP_THREAD_DEBUG */