git.sur5r.net Git - openldap/blob - 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-2008 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         if( thread_info_used >= thread_info_size ) {
 559                 unsigned int more = thread_info_size + 8;
 560                 unsigned int new_size = thread_info_size + more;
 561                 t = calloc( more, sizeof(ldap_debug_thread_t) );
 562                 assert( t != NULL );
 563                 thread_info = realloc( thread_info, new_size * sizeof(*thread_info) );
 564                 assert( thread_info != NULL );
 565                 while( thread_info_size < new_size ) {
 566                         t->idx = thread_info_size;
 567                         thread_info[thread_info_size++] = t++;
 568                 }
 569         }
 570         t = thread_info[thread_info_used];
 571         init_usage( &t->usage, msg );
 572         t->wrapped = *thread;
 573         t->detached = detached;
 574         thread_info_used++;
 575 }
 576
 577 static void
 578 remove_thread_info( ldap_debug_thread_t *t, const char *msg )
 579 {
 580                 ldap_debug_thread_t *last;
 581                 int idx;
 582                 check_usage( &t->usage, msg );
 583                 destroy_usage( &t->usage );
 584                 idx = t->idx;
 585                 assert( thread_info[idx] == t );
 586                 last = thread_info[--thread_info_used];
 587                 assert( last->idx == thread_info_used );
 588                 (thread_info[idx]              = last)->idx = idx;
 589                 (thread_info[thread_info_used] = t   )->idx = thread_info_used;
 590 }
 591
 592 static ldap_debug_thread_t *
 593 get_thread_info( ldap_pvt_thread_t thread, const char *msg )
 594 {
 595         unsigned int i;
 596         ldap_debug_thread_t *t;
 597         for( i = 0; i < thread_info_used; i++ ) {
 598                 if( ldap_pvt_thread_equal( thread, thread_info[i]->wrapped ) )
 599                         break;
 600         }
 601         ERROR_IF( i == thread_info_used, msg );
 602         t = thread_info[i];
 603         check_usage( &t->usage, msg );
 604         return t;
 605 }
 606
 607 #endif /* LDAP_THREAD_DEBUG_THREAD_ID */
 608
 609
 610 static char *
 611 thread_name( char *buf, int bufsize, ldap_pvt_thread_t thread )
 612 {
 613         int i;
 614         --bufsize;
 615         if( bufsize > 2*sizeof(thread) )
 616                 bufsize = 2*sizeof(thread);
 617         for( i = 0; i < bufsize; i += 2 )
 618                 snprintf( buf+i, 3, "%02x", ((unsigned char *)&thread)[i/2] );
 619         return buf;
 620 }
 621
 622
 623 /* Add <adjust> (+/-1) to resource count <which> unless "nocount". */
 624 static void
 625 adjust_count( int which, int adjust )
 626 {
 627         int rc;
 628         switch( count ) {
 629         case Count_no:
 630                 break;
 631         case Count_yes:
 632                 rc = ldap_int_thread_mutex_lock( &resource_mutexes[which] );
 633                 assert( rc == 0 );
 634                 resource_counts[which] += adjust;
 635                 rc = ldap_int_thread_mutex_unlock( &resource_mutexes[which] );
 636                 assert( rc == 0 );
 637                 break;
 638         case Count_reported:
 639                 fputs( "== thr_debug: More thread activity after exit ==\n", stderr );
 640                 count = Count_reported_more;
 641                 /* FALL THROUGH */
 642         case Count_reported_more:
 643                 /* Not used, but result might be inspected with debugger */
 644                 /* (Hopefully threading is disabled by now...) */
 645                 resource_counts[which] += adjust;
 646                 break;
 647         }
 648 }
 649
 650
 651 /* Wrappers for LDAP_THREAD_IMPLEMENTATION: */
 652
 653 /* Used instead of ldap_int_thread_initialize by ldap_pvt_thread_initialize */
 654 int
 655 ldap_debug_thread_initialize( void )
 656 {
 657         int i, rc, rc2;
 658         if( !options_done )
 659                 get_options();
 660         ERROR_IF( threading_enabled, "ldap_debug_thread_initialize" );
 661         threading_enabled = 1;
 662         rc = ldap_int_thread_initialize();
 663         if( rc ) {
 664                 ERROR( rc, "ldap_debug_thread_initialize:threads" );
 665                 threading_enabled = 0;
 666         } else {
 667                 init_thread_info();
 668                 if( count != Count_no ) {
 669                         for( i = rc2 = 0; i < Idx_max; i++ )
 670                                 rc2 |= ldap_int_thread_mutex_init( &resource_mutexes[i] );
 671                         assert( rc2 == 0 );
 672                         /* FIXME: Only for static libldap_r as in init.c? If so, why? */
 673                         atexit( count_resource_leaks );
 674                 }
 675         }
 676         return rc;
 677 }
 678
 679 /* Used instead of ldap_int_thread_destroy by ldap_pvt_thread_destroy */
 680 int
 681 ldap_debug_thread_destroy( void )
 682 {
 683         int rc;
 684         ERROR_IF( !threading_enabled, "ldap_debug_thread_destroy" );
 685         /* sleep(1) -- need to wait for thread pool to finish? */
 686         rc = ldap_int_thread_destroy();
 687         if( rc ) {
 688                 ERROR( rc, "ldap_debug_thread_destroy:threads" );
 689         } else {
 690                 threading_enabled = 0;
 691         }
 692         return rc;
 693 }
 694
 695 int
 696 ldap_pvt_thread_set_concurrency( int n )
 697 {
 698         int rc;
 699         ERROR_IF( !threading_enabled, "ldap_pvt_thread_set_concurrency" );
 700         rc = ldap_int_thread_set_concurrency( n );
 701         ERROR_IF( rc, "ldap_pvt_thread_set_concurrency" );
 702         return rc;
 703 }
 704
 705 int
 706 ldap_pvt_thread_get_concurrency( void )
 707 {
 708         int rc;
 709         ERROR_IF( !threading_enabled, "ldap_pvt_thread_get_concurrency" );
 710         rc = ldap_int_thread_get_concurrency();
 711         ERROR_IF( rc, "ldap_pvt_thread_get_concurrency" );
 712         return rc;
 713 }
 714
 715 unsigned int
 716 ldap_pvt_thread_sleep( unsigned int interval )
 717 {
 718         int rc;
 719         ERROR_IF( !threading_enabled, "ldap_pvt_thread_sleep" );
 720         rc = ldap_int_thread_sleep( interval );
 721         ERROR_IF( rc, "ldap_pvt_thread_sleep" );
 722         return 0;
 723 }
 724
 725 static void
 726 thread_exiting( const char *how, const char *msg )
 727 {
 728         ldap_pvt_thread_t thread;
 729 #if 0 /* Detached threads may exit after ldap_debug_thread_destroy(). */
 730         ERROR_IF( !threading_enabled, msg );
 731 #endif
 732         thread = ldap_pvt_thread_self();
 733         if( tracethreads ) {
 734                 char buf[40];
 735                 fprintf( stderr, "== thr_debug: %s thread %s ==\n",
 736                         how, thread_name( buf, sizeof(buf), thread ) );
 737         }
 738         if( threadID ) {
 739                 with_thread_info_lock({
 740                         ldap_debug_thread_t *t = get_thread_info( thread, msg );
 741                         if( thread_info_detached( t ) )
 742                                 remove_thread_info( t, msg );
 743                 });
 744         }
 745         adjust_count( Idx_unexited_thread, -1 );
 746 }
 747
 748 void
 749 ldap_pvt_thread_exit( void *retval )
 750 {
 751         thread_exiting( "Exiting", "ldap_pvt_thread_exit" );
 752         ldap_int_thread_exit( retval );
 753 }
 754
 755 typedef struct {
 756         void *(*start_routine)( void * );
 757         void *arg;
 758 } ldap_debug_thread_call_t;
 759
 760 static void *
 761 ldap_debug_thread_wrapper( void *arg )
 762 {
 763         void *ret;
 764         ldap_debug_thread_call_t call = *(ldap_debug_thread_call_t *)arg;
 765         free( arg );
 766         ret = call.start_routine( call.arg );
 767         thread_exiting( "Returning from", "ldap_debug_thread_wrapper" );
 768         return ret;
 769 }
 770
 771 int
 772 ldap_pvt_thread_create(
 773         ldap_pvt_thread_t *thread,
 774         int detach,
 775         void *(*start_routine)( void * ),
 776         void *arg )
 777 {
 778         int rc;
 779         if( !options_done )
 780                 get_options();
 781         ERROR_IF( !threading_enabled, "ldap_pvt_thread_create" );
 782         if( wrap_threads ) {
 783                 ldap_debug_thread_call_t *call = malloc(
 784                         sizeof( ldap_debug_thread_call_t ) );
 785                 assert( call != NULL );
 786                 call->start_routine = start_routine;
 787                 call->arg = arg;
 788                 start_routine = ldap_debug_thread_wrapper;
 789                 arg = call;
 790         }
 791         if( threadID ) {
 792                 with_thread_info_lock({
 793                         rc = ldap_int_thread_create( thread, detach, start_routine, arg );
 794                         if( rc == 0 )
 795                                 add_thread_info( "ldap_pvt_thread_create", thread, detach );
 796                 });
 797         } else {
 798                 rc = ldap_int_thread_create( thread, detach, start_routine, arg );
 799         }
 800         if( rc ) {
 801                 ERROR( rc, "ldap_pvt_thread_create" );
 802                 if( wrap_threads )
 803                         free( arg );
 804         } else {
 805                 if( tracethreads ) {
 806                         char buf[40], buf2[40];
 807                         fprintf( stderr,
 808                                 "== thr_debug: Created thread %s%s from thread %s ==\n",
 809                                 thread_name( buf, sizeof(buf), *thread ),
 810                                 detach ? " (detached)" : "",
 811                                 thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
 812                 }
 813                 adjust_count( Idx_unexited_thread, +1 );
 814                 if( !detach )
 815                         adjust_count( Idx_unjoined_thread, +1 );
 816         }
 817         return rc;
 818 }
 819
 820 int
 821 ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
 822 {
 823         int rc;
 824         ldap_debug_thread_t *t = NULL;
 825         ERROR_IF( !threading_enabled, "ldap_pvt_thread_join" );
 826         if( tracethreads ) {
 827                 char buf[40], buf2[40];
 828                 fprintf( stderr, "== thr_debug: Joining thread %s in thread %s ==\n",
 829                         thread_name( buf, sizeof(buf), thread ),
 830                         thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
 831         }
 832         if( threadID )
 833                 with_thread_info_lock( {
 834                         t = get_thread_info( thread, "ldap_pvt_thread_join" );
 835                         ERROR_IF( thread_info_detached( t ), "ldap_pvt_thread_join" );
 836                 } );
 837         rc = ldap_int_thread_join( thread, thread_return );
 838         if( rc ) {
 839                 ERROR( rc, "ldap_pvt_thread_join" );
 840         } else {
 841                 if( threadID )
 842                         with_thread_info_lock(
 843                                 remove_thread_info( t, "ldap_pvt_thread_join" ) );
 844                 adjust_count( Idx_unjoined_thread, -1 );
 845         }
 846         return rc;
 847 }
 848
 849 int
 850 ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
 851 {
 852         int rc;
 853         ERROR_IF( !threading_enabled, "ldap_pvt_thread_kill" );
 854         if( tracethreads ) {
 855                 char buf[40], buf2[40];
 856                 fprintf( stderr,
 857                         "== thr_debug: Killing thread %s (sig %i) from thread %s ==\n",
 858                         thread_name( buf, sizeof(buf), thread ), signo,
 859                         thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
 860         }
 861         rc = ldap_int_thread_kill( thread, signo );
 862         ERROR_IF( rc, "ldap_pvt_thread_kill" );
 863         return rc;
 864 }
 865
 866 int
 867 ldap_pvt_thread_yield( void )
 868 {
 869         int rc;
 870         ERROR_IF( !threading_enabled, "ldap_pvt_thread_yield" );
 871         rc = ldap_int_thread_yield();
 872         ERROR_IF( rc, "ldap_pvt_thread_yield" );
 873         return rc;
 874 }
 875
 876 ldap_pvt_thread_t
 877 ldap_pvt_thread_self( void )
 878 {
 879 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
 880         ERROR_IF( !threading_enabled, "ldap_pvt_thread_self" );
 881 #endif
 882         return ldap_int_thread_self();
 883 }
 884
 885 int
 886 ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
 887 {
 888         int rc;
 889         init_usage( &cond->usage, "ldap_pvt_thread_cond_init" );
 890         rc = ldap_int_thread_cond_init( WRAPPED( cond ) );
 891         if( rc ) {
 892                 ERROR( rc, "ldap_pvt_thread_cond_init" );
 893                 destroy_usage( &cond->usage );
 894         } else {
 895                 adjust_count( Idx_cond, +1 );
 896         }
 897         return rc;
 898 }
 899
 900 int
 901 ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cond )
 902 {
 903         int rc;
 904         check_usage( &cond->usage, "ldap_pvt_thread_cond_destroy" );
 905         rc = ldap_int_thread_cond_destroy( WRAPPED( cond ) );
 906         if( rc ) {
 907                 ERROR( rc, "ldap_pvt_thread_cond_destroy" );
 908         } else {
 909                 destroy_usage( &cond->usage );
 910                 adjust_count( Idx_cond, -1 );
 911         }
 912         return rc;
 913 }
 914
 915 int
 916 ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
 917 {
 918         int rc;
 919         check_usage( &cond->usage, "ldap_pvt_thread_cond_signal" );
 920         rc = ldap_int_thread_cond_signal( WRAPPED( cond ) );
 921         ERROR_IF( rc, "ldap_pvt_thread_cond_signal" );
 922         return rc;
 923 }
 924
 925 int
 926 ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
 927 {
 928         int rc;
 929         check_usage( &cond->usage, "ldap_pvt_thread_cond_broadcast" );
 930         rc = ldap_int_thread_cond_broadcast( WRAPPED( cond ) );
 931         ERROR_IF( rc, "ldap_pvt_thread_cond_broadcast" );
 932         return rc;
 933 }
 934
 935 int
 936 ldap_pvt_thread_cond_wait(
 937         ldap_pvt_thread_cond_t *cond,
 938         ldap_pvt_thread_mutex_t *mutex )
 939 {
 940         int rc;
 941         ldap_int_thread_t owner;
 942         check_usage( &cond->usage, "ldap_pvt_thread_cond_wait:cond" );
 943         check_usage( &mutex->usage, "ldap_pvt_thread_cond_wait:mutex" );
 944         adjust_count( Idx_locked_mutex, -1 );
 945         owner = GET_OWNER( mutex );
 946         ASSERT_OWNER( mutex, "ldap_pvt_thread_cond_wait" );
 947         RESET_OWNER( mutex );
 948         rc = ldap_int_thread_cond_wait( WRAPPED( cond ), WRAPPED( mutex ) );
 949         ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_cond_wait" );
 950         SET_OWNER( mutex, rc ? owner : ldap_int_thread_self() );
 951         adjust_count( Idx_locked_mutex, +1 );
 952         ERROR_IF( rc, "ldap_pvt_thread_cond_wait" );
 953         return rc;
 954 }
 955
 956 int
 957 ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
 958 {
 959         int rc;
 960         init_usage( &mutex->usage, "ldap_pvt_thread_mutex_init" );
 961         rc = ldap_int_thread_mutex_init( WRAPPED( mutex ) );
 962         if( rc ) {
 963                 ERROR( rc, "ldap_pvt_thread_mutex_init" );
 964                 destroy_usage( &mutex->usage );
 965         } else {
 966                 RESET_OWNER( mutex );
 967                 adjust_count( Idx_mutex, +1 );
 968         }
 969         return rc;
 970 }
 971
 972 int
 973 ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
 974 {
 975         int rc;
 976         check_usage( &mutex->usage, "ldap_pvt_thread_mutex_destroy" );
 977         ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_destroy" );
 978         rc = ldap_int_thread_mutex_destroy( WRAPPED( mutex ) );
 979         if( rc ) {
 980                 ERROR( rc, "ldap_pvt_thread_mutex_destroy" );
 981         } else {
 982                 destroy_usage( &mutex->usage );
 983                 RESET_OWNER( mutex );
 984                 adjust_count( Idx_mutex, -1 );
 985         }
 986         return rc;
 987 }
 988
 989 int
 990 ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
 991 {
 992         int rc;
 993         check_usage( &mutex->usage, "ldap_pvt_thread_mutex_lock" );
 994         rc = ldap_int_thread_mutex_lock( WRAPPED( mutex ) );
 995         if( rc ) {
 996                 ERROR_IF( rc, "ldap_pvt_thread_mutex_lock" );
 997         } else {
 998                 ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_lock" );
 999                 SET_OWNER( mutex, ldap_int_thread_self() );
1000                 adjust_count( Idx_locked_mutex, +1 );
1001         }
1002         return rc;
1003 }
1004
1005 int
1006 ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mutex )
1007 {
1008         int rc;
1009         check_usage( &mutex->usage, "ldap_pvt_thread_mutex_trylock" );
1010         rc = ldap_int_thread_mutex_trylock( WRAPPED( mutex ) );
1011         if( rc == 0 ) {
1012                 ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_trylock" );
1013                 SET_OWNER( mutex, ldap_int_thread_self() );
1014                 adjust_count( Idx_locked_mutex, +1 );
1015         }
1016         return rc;
1017 }
1018
1019 int
1020 ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
1021 {
1022         int rc;
1023         check_usage( &mutex->usage, "ldap_pvt_thread_mutex_unlock" );
1024         ASSERT_OWNER( mutex, "ldap_pvt_thread_mutex_unlock" );
1025         RESET_OWNER( mutex ); /* Breaks if this thread did not own the mutex */
1026         rc = ldap_int_thread_mutex_unlock( WRAPPED( mutex ) );
1027         if( rc ) {
1028                 ERROR_IF( rc, "ldap_pvt_thread_mutex_unlock" );
1029         } else {
1030                 adjust_count( Idx_locked_mutex, -1 );
1031         }
1032         return rc;
1033 }
1034
1035
1036 /* Wrappers for LDAP_THREAD_RDWR_IMPLEMENTATION: */
1037
1038 int
1039 ldap_pvt_thread_rdwr_init( ldap_pvt_thread_rdwr_t *rwlock )
1040 {
1041         int rc;
1042         init_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_init" );
1043         rc = ldap_int_thread_rdwr_init( WRAPPED( rwlock ) );
1044         if( rc ) {
1045                 ERROR( rc, "ldap_pvt_thread_rdwr_init" );
1046                 destroy_usage( &rwlock->usage );
1047         } else {
1048                 adjust_count( Idx_rdwr, +1 );
1049         }
1050         return rc;
1051 }
1052
1053 int
1054 ldap_pvt_thread_rdwr_destroy( ldap_pvt_thread_rdwr_t *rwlock )
1055 {
1056         int rc;
1057         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_destroy" );
1058         rc = ldap_int_thread_rdwr_destroy( WRAPPED( rwlock ) );
1059         if( rc ) {
1060                 ERROR( rc, "ldap_pvt_thread_rdwr_destroy" );
1061         } else {
1062                 destroy_usage( &rwlock->usage );
1063                 adjust_count( Idx_rdwr, -1 );
1064         }
1065         return rc;
1066 }
1067
1068 int
1069 ldap_pvt_thread_rdwr_rlock( ldap_pvt_thread_rdwr_t *rwlock )
1070 {
1071         int rc;
1072         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_rlock" );
1073         rc = ldap_int_thread_rdwr_rlock( WRAPPED( rwlock ) );
1074         ERROR_IF( rc, "ldap_pvt_thread_rdwr_rlock" );
1075         return rc;
1076 }
1077
1078 int
1079 ldap_pvt_thread_rdwr_rtrylock( ldap_pvt_thread_rdwr_t *rwlock )
1080 {
1081         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_rtrylock" );
1082         return ldap_int_thread_rdwr_rtrylock( WRAPPED( rwlock ) );
1083 }
1084
1085 int
1086 ldap_pvt_thread_rdwr_runlock( ldap_pvt_thread_rdwr_t *rwlock )
1087 {
1088         int rc;
1089         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_runlock" );
1090         rc = ldap_int_thread_rdwr_runlock( WRAPPED( rwlock ) );
1091         ERROR_IF( rc, "ldap_pvt_thread_rdwr_runlock" );
1092         return rc;
1093 }
1094
1095 int
1096 ldap_pvt_thread_rdwr_wlock( ldap_pvt_thread_rdwr_t *rwlock )
1097 {
1098         int rc;
1099         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wlock" );
1100         rc = ldap_int_thread_rdwr_wlock( WRAPPED( rwlock ) );
1101         ERROR_IF( rc, "ldap_pvt_thread_rdwr_wlock" );
1102         return rc;
1103 }
1104
1105 int
1106 ldap_pvt_thread_rdwr_wtrylock( ldap_pvt_thread_rdwr_t *rwlock )
1107 {
1108         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wtrylock" );
1109         return ldap_int_thread_rdwr_wtrylock( WRAPPED( rwlock ) );
1110 }
1111
1112 int
1113 ldap_pvt_thread_rdwr_wunlock( ldap_pvt_thread_rdwr_t *rwlock )
1114 {
1115         int rc;
1116         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wunlock" );
1117         rc = ldap_int_thread_rdwr_wunlock( WRAPPED( rwlock ) );
1118         ERROR_IF( rc, "ldap_pvt_thread_rdwr_wunlock" );
1119         return rc;
1120 }
1121
1122 #if defined(LDAP_RDWR_DEBUG) && !defined(LDAP_THREAD_HAVE_RDWR)
1123
1124 int
1125 ldap_pvt_thread_rdwr_readers( ldap_pvt_thread_rdwr_t *rwlock )
1126 {
1127         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_readers" );
1128         return ldap_int_thread_rdwr_readers( WRAPPED( rwlock ) );
1129 }
1130
1131 int
1132 ldap_pvt_thread_rdwr_writers( ldap_pvt_thread_rdwr_t *rwlock )
1133 {
1134         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_writers" );
1135         return ldap_int_thread_rdwr_writers( WRAPPED( rwlock ) );
1136 }
1137
1138 int
1139 ldap_pvt_thread_rdwr_active( ldap_pvt_thread_rdwr_t *rwlock )
1140 {
1141         check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_active" );
1142         return ldap_int_thread_rdwr_active( WRAPPED( rwlock ) );
1143 }
1144
1145 #endif /* LDAP_RDWR_DEBUG && !LDAP_THREAD_HAVE_RDWR */
1146
1147
1148 /* Some wrappers for LDAP_THREAD_POOL_IMPLEMENTATION: */
1149 #ifdef LDAP_THREAD_POOL_IMPLEMENTATION
1150
1151 int
1152 ldap_pvt_thread_pool_init(
1153         ldap_pvt_thread_pool_t *tpool,
1154         int max_threads,
1155         int max_pending )
1156 {
1157         int rc;
1158         if( !options_done )
1159                 get_options();
1160         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_init" );
1161         rc = ldap_int_thread_pool_init( tpool, max_threads, max_pending );
1162         if( rc ) {
1163                 ERROR( rc, "ldap_pvt_thread_pool_init" );
1164         } else {
1165                 adjust_count( Idx_tpool, +1 );
1166         }
1167         return rc;
1168 }
1169
1170 int
1171 ldap_pvt_thread_pool_submit(
1172         ldap_pvt_thread_pool_t *tpool,
1173         ldap_pvt_thread_start_t *start_routine, void *arg )
1174 {
1175         int rc, has_pool;
1176         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_submit" );
1177         has_pool = (tpool && *tpool);
1178         rc = ldap_int_thread_pool_submit( tpool, start_routine, arg );
1179         if( has_pool )
1180                 ERROR_IF( rc, "ldap_pvt_thread_pool_submit" );
1181         return rc;
1182 }
1183
1184 int
1185 ldap_pvt_thread_pool_maxthreads(
1186         ldap_pvt_thread_pool_t *tpool,
1187         int max_threads )
1188 {
1189         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_maxthreads" );
1190         return ldap_int_thread_pool_maxthreads( tpool, max_threads );
1191 }
1192
1193 int
1194 ldap_pvt_thread_pool_backload( ldap_pvt_thread_pool_t *tpool )
1195 {
1196         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_backload" );
1197         return ldap_int_thread_pool_backload( tpool );
1198 }
1199
1200 int
1201 ldap_pvt_thread_pool_destroy( ldap_pvt_thread_pool_t *tpool, int run_pending )
1202 {
1203         int rc, has_pool;
1204         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_destroy" );
1205         has_pool = (tpool && *tpool);
1206         rc = ldap_int_thread_pool_destroy( tpool, run_pending );
1207         if( has_pool ) {
1208                 if( rc ) {
1209                         ERROR( rc, "ldap_pvt_thread_pool_destroy" );
1210                 } else {
1211                         adjust_count( Idx_tpool, -1 );
1212                 }
1213         }
1214         return rc;
1215 }
1216
1217 int
1218 ldap_pvt_thread_pool_pause( ldap_pvt_thread_pool_t *tpool )
1219 {
1220         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_pause" );
1221         return ldap_int_thread_pool_pause( tpool );
1222 }
1223
1224 int
1225 ldap_pvt_thread_pool_resume( ldap_pvt_thread_pool_t *tpool )
1226 {
1227         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_resume" );
1228         return ldap_int_thread_pool_resume( tpool );
1229 }
1230
1231 int
1232 ldap_pvt_thread_pool_getkey(
1233         void *xctx,
1234         void *key,
1235         void **data,
1236         ldap_pvt_thread_pool_keyfree_t **kfree )
1237 {
1238 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
1239         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_getkey" );
1240 #endif
1241         return ldap_int_thread_pool_getkey( xctx, key, data, kfree );
1242 }
1243
1244 int
1245 ldap_pvt_thread_pool_setkey(
1246         void *xctx,
1247         void *key,
1248         void *data,
1249         ldap_pvt_thread_pool_keyfree_t *kfree,
1250         void **olddatap,
1251         ldap_pvt_thread_pool_keyfree_t **oldkfreep )
1252 {
1253         int rc;
1254         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_setkey" );
1255         rc = ldap_int_thread_pool_setkey(
1256                 xctx, key, data, kfree, olddatap, oldkfreep );
1257         ERROR_IF( rc, "ldap_pvt_thread_pool_setkey" );
1258         return rc;
1259 }
1260
1261 void
1262 ldap_pvt_thread_pool_purgekey( void *key )
1263 {
1264         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_purgekey" );
1265         ldap_int_thread_pool_purgekey( key );
1266 }
1267
1268 void *
1269 ldap_pvt_thread_pool_context( void )
1270 {
1271 #if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
1272         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_context" );
1273 #endif
1274         return ldap_int_thread_pool_context();
1275 }
1276
1277 void
1278 ldap_pvt_thread_pool_context_reset( void *vctx )
1279 {
1280         ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_context_reset" );
1281         ldap_int_thread_pool_context_reset( vctx );
1282 }
1283
1284 #endif /* LDAP_THREAD_POOL_IMPLEMENTATION */
1285
1286 #endif /* LDAP_THREAD_DEBUG */