2005-09-18 07:28:08 +08:00
|
|
|
/* thr_debug.c - wrapper around the chosen thread wrapper, for debugging. */
|
|
|
|
/* $OpenLDAP$ */
|
|
|
|
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
|
|
|
|
*
|
2007-01-03 04:00:42 +08:00
|
|
|
* Copyright 2005-2007 The OpenLDAP Foundation.
|
2005-09-18 07:28:08 +08:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted only as authorized by the OpenLDAP
|
|
|
|
* Public License.
|
|
|
|
*
|
|
|
|
* A copy of this license is available in file LICENSE in the
|
|
|
|
* top-level directory of the distribution or, alternatively, at
|
|
|
|
* <http://www.OpenLDAP.org/license.html>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2006-04-06 03:52:07 +08:00
|
|
|
* This package provides several types of thread operation debugging:
|
2005-09-18 07:28:08 +08:00
|
|
|
*
|
2006-04-06 03:52:07 +08:00
|
|
|
* - Check the results of operations on threads, mutexes, condition
|
|
|
|
* variables and read/write locks. Also check some thread pool
|
|
|
|
* operations, but not those for which failure can happen in normal
|
|
|
|
* slapd operation.
|
2005-09-18 07:28:08 +08:00
|
|
|
*
|
2006-04-06 03:52:07 +08:00
|
|
|
* - Wrap those types except threads and pools in structs with state
|
|
|
|
* information, and check that on all operations:
|
|
|
|
*
|
|
|
|
* + Check that the resources are initialized and are only used at
|
|
|
|
* their original address (i.e. not realloced or copied).
|
|
|
|
*
|
|
|
|
* + Check the owner (thread ID) on mutex operations.
|
|
|
|
*
|
|
|
|
* + Optionally allocate a reference to a byte of dummy memory.
|
|
|
|
* This lets malloc debuggers see some incorrect use as memory
|
|
|
|
* leaks, access to freed memory, etc.
|
|
|
|
*
|
|
|
|
* - Print an error message and by default abort() upon errors.
|
2005-09-18 07:28:08 +08:00
|
|
|
*
|
|
|
|
* - Print a count of leaked thread resources after cleanup.
|
|
|
|
*
|
|
|
|
* Compile-time (./configure) setup: Macros defined in CPPFLAGS.
|
|
|
|
*
|
|
|
|
* LDAP_THREAD_DEBUG or LDAP_THREAD_DEBUG=2
|
|
|
|
* Enables debugging, but value & 2 turns off type wrapping.
|
|
|
|
*
|
|
|
|
* LDAP_UINTPTR_T=integer type to hold pointers, preferably unsigned.
|
|
|
|
* Used by dummy memory option "scramble". Default = unsigned long.
|
|
|
|
*
|
2006-04-06 03:52:07 +08:00
|
|
|
* LDAP_DEBUG_THREAD_NONE = initializer for a "no thread" thread ID.
|
|
|
|
*
|
2005-09-18 07:28:08 +08:00
|
|
|
* In addition, you may need to set up an implementation-specific way
|
|
|
|
* to enable whatever error checking your thread library provides.
|
|
|
|
* Currently only implemented for Posix threads (pthreads), where
|
|
|
|
* you may need to define LDAP_INT_THREAD_MUTEXATTR. The default
|
|
|
|
* is PTHREAD_MUTEX_ERRORCHECK, or PTHREAD_MUTEX_ERRORCHECK_NP for
|
|
|
|
* Linux threads. See pthread_mutexattr_settype(3).
|
|
|
|
*
|
2006-04-06 03:52:07 +08:00
|
|
|
* Run-time configuration:
|
2005-09-18 07:28:08 +08:00
|
|
|
*
|
2007-05-31 06:20:20 +08:00
|
|
|
* Memory debugging tools:
|
2006-04-06 03:52:07 +08:00
|
|
|
* Tools that report uninitialized memory accesses should disable
|
|
|
|
* such warnings about the function debug_already_initialized().
|
|
|
|
* Alternatively, include "noreinit" (below) in $LDAP_THREAD_DEBUG.
|
|
|
|
*
|
|
|
|
* Environment variable $LDAP_THREAD_DEBUG:
|
2005-09-18 07:28:08 +08:00
|
|
|
* The variable may contain a comma- or space-separated option list.
|
|
|
|
* Options:
|
2006-04-06 03:52:07 +08:00
|
|
|
* off - Disable this package. (It still slows things down).
|
|
|
|
* tracethreads - Report create/join/exit/kill of threads.
|
2005-09-18 07:28:08 +08:00
|
|
|
* noabort - Do not abort() on errors.
|
|
|
|
* noerror - Do not report errors. Implies noabort.
|
|
|
|
* nocount - Do not report counts of unreleased resources.
|
2006-04-06 03:52:07 +08:00
|
|
|
* nosync - Disable tests that use synchronizaion and thus
|
|
|
|
* clearly affect thread scheduling:
|
|
|
|
* Implies nocount, and cancels threadID if that is set.
|
|
|
|
* Note that if you turn on tracethreads or malloc
|
|
|
|
* debugging, these also use library calls which may
|
|
|
|
* affect thread scheduling (fprintf and malloc).
|
|
|
|
* The following options do not apply if type wrapping is disabled:
|
|
|
|
* nomem - Do not check memory operations.
|
|
|
|
* Implies noreinit,noalloc.
|
|
|
|
* noreinit - Do not catch reinitialization of existing resources.
|
|
|
|
* (That test accesses uninitialized memory).
|
|
|
|
* threadID - Trace thread IDs. Currently mostly useless.
|
|
|
|
* Malloc debugging -- allocate dummy memory for initialized
|
|
|
|
* resources, so malloc debuggers will report them as memory leaks:
|
|
|
|
* noalloc - Default. Do not allocate dummy memory.
|
|
|
|
* alloc - Store a pointer to dummy memory. However, leak
|
|
|
|
* detectors might not catch unreleased resources in
|
|
|
|
* global variables.
|
2005-09-18 07:28:08 +08:00
|
|
|
* scramble - Store bitwise complement of dummy memory pointer.
|
|
|
|
* That never escapes memory leak detectors -
|
|
|
|
* but detection while the program is running will
|
|
|
|
* report active resources as leaks. Do not
|
|
|
|
* use this if a garbage collector is in use:-)
|
|
|
|
* adjptr - Point to end of dummy memory.
|
|
|
|
* Purify reports these as "potential leaks" (PLK).
|
|
|
|
* I have not checked other malloc debuggers.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "portable.h"
|
|
|
|
|
|
|
|
#if defined( LDAP_THREAD_DEBUG )
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <ac/errno.h>
|
|
|
|
#include <ac/stdlib.h>
|
|
|
|
#include <ac/string.h>
|
|
|
|
|
|
|
|
#include "ldap_pvt_thread.h" /* Get the thread interface */
|
|
|
|
#define LDAP_THREAD_IMPLEMENTATION
|
|
|
|
#define LDAP_THREAD_DEBUG_IMPLEMENTATION
|
|
|
|
#define LDAP_THREAD_RDWR_IMPLEMENTATION
|
|
|
|
#define LDAP_THREAD_POOL_IMPLEMENTATION
|
|
|
|
#include "ldap_thr_debug.h" /* Get the underlying implementation */
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
#ifndef LDAP_THREAD_DEBUG_WRAP
|
|
|
|
#undef LDAP_THREAD_DEBUG_THREAD_ID
|
|
|
|
#elif !defined LDAP_THREAD_DEBUG_THREAD_ID
|
|
|
|
#define LDAP_THREAD_DEBUG_THREAD_ID 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Use native malloc - the OpenLDAP wrappers may defeat malloc debuggers */
|
|
|
|
#undef malloc
|
|
|
|
#undef calloc
|
|
|
|
#undef realloc
|
|
|
|
#undef free
|
|
|
|
|
2005-09-18 07:28:08 +08:00
|
|
|
|
|
|
|
/* Options from environment variable $LDAP_THREAD_DEBUG */
|
|
|
|
enum { Count_no = 0, Count_yes, Count_reported, Count_reported_more };
|
2006-04-06 03:52:07 +08:00
|
|
|
static int count = Count_yes;
|
2005-09-18 07:28:08 +08:00
|
|
|
#ifdef LDAP_THREAD_DEBUG_WRAP
|
|
|
|
enum { Wrap_noalloc, Wrap_alloc, Wrap_scramble, Wrap_adjptr };
|
2006-04-06 03:52:07 +08:00
|
|
|
static int wraptype = Wrap_noalloc, wrap_offset, unwrap_offset;
|
|
|
|
static int nomem, noreinit;
|
|
|
|
#endif
|
|
|
|
#if LDAP_THREAD_DEBUG_THREAD_ID +0
|
|
|
|
static int threadID;
|
|
|
|
#else
|
|
|
|
enum { threadID = 0 };
|
2005-09-18 07:28:08 +08:00
|
|
|
#endif
|
2006-04-06 03:52:07 +08:00
|
|
|
static int nodebug, noabort, noerror, nosync, tracethreads;
|
2006-04-30 09:15:57 +08:00
|
|
|
static int wrap_threads;
|
2006-04-06 03:52:07 +08:00
|
|
|
static int options_done;
|
2005-09-18 07:28:08 +08:00
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
|
|
|
|
/* ldap_pvt_thread_initialize() called, ldap_pvt_thread_destroy() not called */
|
2005-09-18 07:28:08 +08:00
|
|
|
static int threading_enabled;
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
|
|
|
|
/* Resource counts */
|
2005-09-18 07:28:08 +08:00
|
|
|
enum {
|
|
|
|
Idx_unexited_thread, Idx_unjoined_thread, Idx_locked_mutex,
|
|
|
|
Idx_mutex, Idx_cond, Idx_rdwr, Idx_tpool, Idx_max
|
|
|
|
};
|
|
|
|
static int resource_counts[Idx_max];
|
|
|
|
static const char *const resource_names[] = {
|
|
|
|
"unexited threads", "unjoined threads", "locked mutexes",
|
|
|
|
"mutexes", "conds", "rdwrs", "thread pools"
|
|
|
|
};
|
|
|
|
static ldap_int_thread_mutex_t resource_mutexes[Idx_max];
|
|
|
|
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
/* Hide pointers from malloc debuggers. */
|
|
|
|
#define SCRAMBLE(ptr) (~(LDAP_UINTPTR_T) (ptr))
|
|
|
|
#define UNSCRAMBLE_usagep(num) ((ldap_debug_usage_info_t *) ~(num))
|
|
|
|
#define UNSCRAMBLE_dummyp(num) ((unsigned char *) ~(num))
|
2005-09-18 07:28:08 +08:00
|
|
|
|
|
|
|
|
|
|
|
#define WARN(var, msg) (warn (__FILE__, __LINE__, (msg), #var, (var)))
|
|
|
|
#define WARN_IF(rc, msg) {if (rc) warn (__FILE__, __LINE__, (msg), #rc, (rc));}
|
2006-04-06 03:52:07 +08:00
|
|
|
|
|
|
|
#define ERROR(var, msg) { \
|
|
|
|
if (!noerror) { \
|
|
|
|
errmsg(__FILE__, __LINE__, (msg), #var, (var)); \
|
|
|
|
if( !noabort ) abort(); \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define ERROR_IF(rc, msg) { \
|
|
|
|
if (!noerror) { \
|
|
|
|
int rc_ = (rc); \
|
|
|
|
if (rc_) { \
|
|
|
|
errmsg(__FILE__, __LINE__, (msg), #rc, rc_); \
|
|
|
|
if( !noabort ) abort(); \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef LDAP_THREAD_DEBUG_WRAP
|
|
|
|
#define MEMERROR_IF(rc, msg, mem_act) { \
|
|
|
|
if (!noerror) { \
|
|
|
|
int rc_ = (rc); \
|
|
|
|
if (rc_) { \
|
|
|
|
errmsg(__FILE__, __LINE__, (msg), #rc, rc_); \
|
|
|
|
if( wraptype != Wrap_noalloc ) { mem_act; } \
|
|
|
|
if( !noabort ) abort(); \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
}
|
|
|
|
#endif /* LDAP_THREAD_DEBUG_WRAP */
|
2005-09-18 07:28:08 +08:00
|
|
|
|
|
|
|
#if 0
|
|
|
|
static void
|
|
|
|
warn( const char *file, int line, const char *msg, const char *var, int val )
|
|
|
|
{
|
2006-04-06 03:52:07 +08:00
|
|
|
fprintf( stderr,
|
|
|
|
(strpbrk( var, "!=" )
|
|
|
|
? "%s:%d: %s warning: %s\n"
|
|
|
|
: "%s:%d: %s warning: %s is %d\n"),
|
2005-09-18 07:28:08 +08:00
|
|
|
file, line, msg, var, val );
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static void
|
2006-04-06 03:52:07 +08:00
|
|
|
errmsg( const char *file, int line, const char *msg, const char *var, int val )
|
2005-09-18 07:28:08 +08:00
|
|
|
{
|
2006-04-06 03:52:07 +08:00
|
|
|
fprintf( stderr,
|
|
|
|
(strpbrk( var, "!=" )
|
|
|
|
? "%s:%d: %s error: %s\n"
|
|
|
|
: "%s:%d: %s error: %s is %d\n"),
|
2006-04-03 20:49:30 +08:00
|
|
|
file, line, msg, var, val );
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
count_resource_leaks( void )
|
|
|
|
{
|
|
|
|
int i, j;
|
2006-04-06 03:52:07 +08:00
|
|
|
char errbuf[200];
|
2005-09-18 07:28:08 +08:00
|
|
|
if( count == Count_yes ) {
|
|
|
|
count = Count_reported;
|
|
|
|
#if 0 /* Could break if there are still threads after atexit */
|
|
|
|
for( i = j = 0; i < Idx_max; i++ )
|
|
|
|
j |= ldap_int_thread_mutex_destroy( &resource_mutexes[i] );
|
|
|
|
WARN_IF( j, "ldap_debug_thread_destroy:mutexes" );
|
|
|
|
#endif
|
2006-04-06 03:52:07 +08:00
|
|
|
for( i = j = 0; i < Idx_max; i++ )
|
|
|
|
if( resource_counts[i] )
|
|
|
|
j += sprintf( errbuf + j, ", %d %s",
|
|
|
|
resource_counts[i], resource_names[i] );
|
2005-09-18 07:28:08 +08:00
|
|
|
if( j )
|
2006-04-06 03:52:07 +08:00
|
|
|
fprintf( stderr, "== thr_debug: Leaked%s. ==\n", errbuf + 1 );
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
get_options( void )
|
|
|
|
{
|
|
|
|
static const struct option_info_s {
|
|
|
|
const char *name;
|
|
|
|
int *var, val;
|
|
|
|
} option_info[] = {
|
|
|
|
{ "off", &nodebug, 1 },
|
|
|
|
{ "noabort", &noabort, 1 },
|
|
|
|
{ "noerror", &noerror, 1 },
|
|
|
|
{ "nocount", &count, Count_no },
|
2006-04-06 03:52:07 +08:00
|
|
|
{ "nosync", &nosync, 1 },
|
|
|
|
#if LDAP_THREAD_DEBUG_THREAD_ID +0
|
|
|
|
{ "threadID", &threadID, 1 },
|
|
|
|
#endif
|
2005-09-18 07:28:08 +08:00
|
|
|
#ifdef LDAP_THREAD_DEBUG_WRAP
|
2006-04-06 03:52:07 +08:00
|
|
|
{ "nomem", &nomem, 1 },
|
|
|
|
{ "noreinit", &noreinit, 1 },
|
2005-09-18 07:28:08 +08:00
|
|
|
{ "noalloc", &wraptype, Wrap_noalloc },
|
|
|
|
{ "alloc", &wraptype, Wrap_alloc },
|
|
|
|
{ "adjptr", &wraptype, Wrap_adjptr },
|
|
|
|
{ "scramble", &wraptype, Wrap_scramble },
|
|
|
|
#endif
|
|
|
|
{ "tracethreads", &tracethreads, 1 },
|
|
|
|
{ NULL, NULL, 0 }
|
|
|
|
};
|
|
|
|
const char *s = getenv( "LDAP_THREAD_DEBUG" );
|
|
|
|
if( s != NULL ) {
|
|
|
|
while( *(s += strspn( s, ", \t\r\n" )) != '\0' ) {
|
|
|
|
size_t optlen = strcspn( s, ", \t\r\n" );
|
2007-05-19 01:49:38 +08:00
|
|
|
const struct option_info_s *oi = option_info;
|
|
|
|
while( oi->name &&
|
|
|
|
(strncasecmp( oi->name, s, optlen ) || oi->name[optlen]) )
|
|
|
|
oi++;
|
|
|
|
if( oi->name )
|
|
|
|
*oi->var = oi->val;
|
|
|
|
else
|
|
|
|
fprintf( stderr,
|
|
|
|
"== thr_debug: Unknown $%s option '%.*s' ==\n",
|
|
|
|
"LDAP_THREAD_DEBUG", (int) optlen, s );
|
2005-09-18 07:28:08 +08:00
|
|
|
s += optlen;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( nodebug ) {
|
2006-04-06 03:52:07 +08:00
|
|
|
tracethreads = 0;
|
|
|
|
nosync = noerror = 1;
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
2006-04-06 03:52:07 +08:00
|
|
|
if( nosync )
|
|
|
|
count = Count_no;
|
|
|
|
if( noerror )
|
|
|
|
noabort = 1;
|
|
|
|
#if LDAP_THREAD_DEBUG_THREAD_ID +0
|
|
|
|
if( nosync )
|
|
|
|
threadID = 0;
|
|
|
|
#endif
|
2005-09-18 07:28:08 +08:00
|
|
|
#ifdef LDAP_THREAD_DEBUG_WRAP
|
2006-04-06 03:52:07 +08:00
|
|
|
if( noerror )
|
|
|
|
nomem = 1;
|
|
|
|
if( !nomem ) {
|
|
|
|
static const ldap_debug_usage_info_t usage;
|
|
|
|
if( sizeof(LDAP_UINTPTR_T) < sizeof(unsigned char *)
|
|
|
|
|| sizeof(LDAP_UINTPTR_T) < sizeof(ldap_debug_usage_info_t *)
|
|
|
|
|| UNSCRAMBLE_usagep( SCRAMBLE( &usage ) ) != &usage
|
|
|
|
|| UNSCRAMBLE_dummyp( SCRAMBLE( (unsigned char *) 0 ) ) )
|
2005-09-18 07:28:08 +08:00
|
|
|
{
|
2006-04-06 03:52:07 +08:00
|
|
|
fputs( "== thr_debug: Memory checks unsupported, "
|
|
|
|
"adding nomem to $LDAP_THREAD_DEBUG ==\n", stderr );
|
|
|
|
nomem = 1;
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
}
|
2006-04-06 03:52:07 +08:00
|
|
|
if( nomem ) {
|
|
|
|
noreinit = 1;
|
|
|
|
wraptype = Wrap_noalloc;
|
|
|
|
}
|
2005-09-18 07:28:08 +08:00
|
|
|
unwrap_offset = -(wrap_offset = (wraptype == Wrap_adjptr));
|
|
|
|
#endif
|
2006-04-30 09:15:57 +08:00
|
|
|
wrap_threads = (tracethreads || threadID || count);
|
2005-09-18 07:28:08 +08:00
|
|
|
options_done = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef LDAP_THREAD_DEBUG_WRAP
|
|
|
|
|
|
|
|
#define WRAPPED(ptr) (ptr)
|
2006-04-06 03:52:07 +08:00
|
|
|
#define GET_OWNER(ptr) 0
|
|
|
|
#define SET_OWNER(ptr, thread) ((void) 0)
|
2006-04-02 03:00:37 +08:00
|
|
|
#define RESET_OWNER(ptr) ((void) 0)
|
2006-04-03 20:49:30 +08:00
|
|
|
#define ASSERT_OWNER(ptr, msg) ((void) 0)
|
|
|
|
#define ASSERT_NO_OWNER(ptr, msg) ((void) 0)
|
2006-04-02 03:00:37 +08:00
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
#define init_usage(ptr, msg) ((void) 0)
|
2005-09-18 07:28:08 +08:00
|
|
|
#define check_usage(ptr, msg) ((void) 0)
|
2006-04-06 03:52:07 +08:00
|
|
|
#define destroy_usage(ptr) ((void) 0)
|
2005-09-18 07:28:08 +08:00
|
|
|
|
|
|
|
#else /* LDAP_THREAD_DEBUG_WRAP */
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
/* Specialize this if the initializer is not appropriate. */
|
2006-04-02 03:00:37 +08:00
|
|
|
/* The ASSERT_NO_OWNER() definition may also need an override. */
|
|
|
|
#ifndef LDAP_DEBUG_THREAD_NONE
|
|
|
|
#define LDAP_DEBUG_THREAD_NONE { -1 } /* "no thread" ldap_int_thread_t value */
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const ldap_int_thread_t ldap_debug_thread_none = LDAP_DEBUG_THREAD_NONE;
|
|
|
|
|
2006-04-03 20:49:30 +08:00
|
|
|
#define THREAD_MUTEX_OWNER(mutex) \
|
2006-04-06 03:52:07 +08:00
|
|
|
ldap_int_thread_equal( (mutex)->owner, ldap_int_thread_self() )
|
2006-04-03 20:49:30 +08:00
|
|
|
|
|
|
|
void
|
|
|
|
ldap_debug_thread_assert_mutex_owner(
|
|
|
|
const char *file,
|
|
|
|
int line,
|
|
|
|
const char *msg,
|
|
|
|
ldap_pvt_thread_mutex_t *mutex )
|
2006-04-02 03:00:37 +08:00
|
|
|
{
|
2006-04-06 03:52:07 +08:00
|
|
|
if( !(noerror || THREAD_MUTEX_OWNER( mutex )) ) {
|
|
|
|
errmsg( file, line, msg, "ASSERT_MUTEX_OWNER", 0 );
|
|
|
|
if( !noabort ) abort();
|
|
|
|
}
|
2006-04-02 03:00:37 +08:00
|
|
|
}
|
|
|
|
|
2005-09-18 07:28:08 +08:00
|
|
|
#define WRAPPED(ptr) (&(ptr)->wrapped)
|
2006-04-06 03:52:07 +08:00
|
|
|
#define GET_OWNER(ptr) ((ptr)->owner)
|
|
|
|
#define SET_OWNER(ptr, thread) ((ptr)->owner = (thread))
|
|
|
|
#define RESET_OWNER(ptr) ((ptr)->owner = ldap_debug_thread_none)
|
|
|
|
#define ASSERT_OWNER(ptr, msg) ERROR_IF( !THREAD_MUTEX_OWNER( ptr ), msg )
|
|
|
|
#ifndef ASSERT_NO_OWNER
|
|
|
|
#define ASSERT_NO_OWNER(ptr, msg) ERROR_IF( \
|
2006-04-03 20:49:30 +08:00
|
|
|
!ldap_int_thread_equal( (ptr)->owner, ldap_debug_thread_none ), msg )
|
2006-04-02 03:00:37 +08:00
|
|
|
#endif
|
2005-09-18 07:28:08 +08:00
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
/* Try to provoke memory access error (for malloc debuggers) */
|
|
|
|
#define PEEK(mem) {if (-*(volatile const unsigned char *)(mem)) debug_noop();}
|
2005-09-18 07:28:08 +08:00
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
static void debug_noop( void );
|
|
|
|
static int debug_already_initialized( const ldap_debug_usage_info_t *usage );
|
|
|
|
|
2007-05-19 01:49:38 +08:00
|
|
|
/* Name used for clearer error message */
|
2006-04-06 03:52:07 +08:00
|
|
|
#define IS_COPY_OR_MOVED(usage) ((usage)->self != SCRAMBLE( usage ))
|
2005-09-18 07:28:08 +08:00
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
#define DUMMY_ADDR(usage) \
|
|
|
|
(wraptype == Wrap_scramble \
|
|
|
|
? UNSCRAMBLE_dummyp( (usage)->mem.num ) \
|
|
|
|
: (usage)->mem.ptr + unwrap_offset)
|
|
|
|
|
|
|
|
/* Mark resource as initialized */
|
2005-09-18 07:28:08 +08:00
|
|
|
static void
|
2006-04-06 03:52:07 +08:00
|
|
|
init_usage( ldap_debug_usage_info_t *usage, const char *msg )
|
2005-09-18 07:28:08 +08:00
|
|
|
{
|
|
|
|
if( !options_done )
|
|
|
|
get_options();
|
2006-04-06 03:52:07 +08:00
|
|
|
if( !nomem ) {
|
|
|
|
if( !noreinit ) {
|
|
|
|
MEMERROR_IF( debug_already_initialized( usage ), msg, {
|
|
|
|
/* Provoke malloc debuggers */
|
|
|
|
unsigned char *dummy = DUMMY_ADDR( usage );
|
|
|
|
PEEK( dummy );
|
|
|
|
free( dummy );
|
|
|
|
free( dummy );
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
if( wraptype != Wrap_noalloc ) {
|
|
|
|
unsigned char *dummy = malloc( 1 );
|
|
|
|
assert( dummy != NULL );
|
|
|
|
if( wraptype == Wrap_scramble ) {
|
|
|
|
usage->mem.num = SCRAMBLE( dummy );
|
2007-05-19 01:49:38 +08:00
|
|
|
/* Verify that ptr<->integer casts work on this host */
|
2006-04-06 03:52:07 +08:00
|
|
|
assert( UNSCRAMBLE_dummyp( usage->mem.num ) == dummy );
|
|
|
|
} else {
|
|
|
|
usage->mem.ptr = dummy + wrap_offset;
|
|
|
|
}
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
2007-05-19 01:49:38 +08:00
|
|
|
} else {
|
|
|
|
/* Unused, but set for readability in debugger */
|
|
|
|
usage->mem.ptr = NULL;
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
2007-05-19 01:49:38 +08:00
|
|
|
usage->self = SCRAMBLE( usage ); /* If nomem, only for debugger */
|
2006-04-06 03:52:07 +08:00
|
|
|
usage->magic = ldap_debug_magic;
|
|
|
|
usage->state = ldap_debug_state_inited;
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
/* Check that resource is initialized and not copied/realloced */
|
2005-09-18 07:28:08 +08:00
|
|
|
static void
|
2006-04-06 03:52:07 +08:00
|
|
|
check_usage( const ldap_debug_usage_info_t *usage, const char *msg )
|
2005-09-18 07:28:08 +08:00
|
|
|
{
|
2007-05-19 01:49:38 +08:00
|
|
|
enum { Is_destroyed = 1 }; /* Name used for clearer error message */
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
if( usage->magic != ldap_debug_magic ) {
|
|
|
|
ERROR( usage->magic, msg );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
switch( usage->state ) {
|
|
|
|
case ldap_debug_state_destroyed:
|
|
|
|
MEMERROR_IF( Is_destroyed, msg, {
|
|
|
|
PEEK( DUMMY_ADDR( usage ) );
|
|
|
|
} );
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ERROR( usage->state, msg );
|
|
|
|
break;
|
|
|
|
case ldap_debug_state_inited:
|
|
|
|
if( !nomem ) {
|
|
|
|
MEMERROR_IF( IS_COPY_OR_MOVED( usage ), msg, {
|
|
|
|
PEEK( DUMMY_ADDR( usage ) );
|
|
|
|
PEEK( UNSCRAMBLE_usagep( usage->self ) );
|
|
|
|
} );
|
|
|
|
}
|
|
|
|
break;
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
/* Mark resource as destroyed. */
|
|
|
|
/* Does not check for errors, call check_usage()/init_usage() first. */
|
2005-09-18 07:28:08 +08:00
|
|
|
static void
|
2006-04-06 03:52:07 +08:00
|
|
|
destroy_usage( ldap_debug_usage_info_t *usage )
|
2005-09-18 07:28:08 +08:00
|
|
|
{
|
2006-04-06 03:52:07 +08:00
|
|
|
if( usage->state == ldap_debug_state_inited ) {
|
|
|
|
if( wraptype != Wrap_noalloc ) {
|
|
|
|
free( DUMMY_ADDR( usage ) );
|
|
|
|
/* Do not reset the DUMMY_ADDR, leave it for malloc debuggers
|
|
|
|
* in case the resource is used after it is freed. */
|
|
|
|
}
|
|
|
|
usage->state = ldap_debug_state_destroyed;
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
/* Define these after they are used, so they are hopefully not inlined */
|
|
|
|
|
|
|
|
static void
|
|
|
|
debug_noop( void )
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-05-19 01:49:38 +08:00
|
|
|
/*
|
|
|
|
* Valid programs access uninitialized memory here unless "noreinit".
|
|
|
|
*
|
|
|
|
* Returns true if the resource is initialized and not copied/realloced.
|
|
|
|
*/
|
2006-04-06 03:52:07 +08:00
|
|
|
static int
|
|
|
|
debug_already_initialized( const ldap_debug_usage_info_t *usage )
|
|
|
|
{
|
2007-05-19 01:49:38 +08:00
|
|
|
/*
|
|
|
|
* 'ret' keeps the Valgrind warning "Conditional jump or move
|
|
|
|
* depends on uninitialised value(s)" _inside_ this function.
|
|
|
|
*/
|
|
|
|
volatile int ret = 0;
|
|
|
|
if( usage->state == ldap_debug_state_inited )
|
|
|
|
if( !IS_COPY_OR_MOVED( usage ) )
|
|
|
|
if( usage->magic == ldap_debug_magic )
|
|
|
|
ret = 1;
|
|
|
|
return ret;
|
2006-04-06 03:52:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* LDAP_THREAD_DEBUG_WRAP */
|
|
|
|
|
|
|
|
|
|
|
|
#if !(LDAP_THREAD_DEBUG_THREAD_ID +0)
|
|
|
|
|
2007-05-19 01:49:38 +08:00
|
|
|
typedef void ldap_debug_thread_t;
|
2006-04-06 03:52:07 +08:00
|
|
|
#define init_thread_info() {}
|
|
|
|
#define with_thread_info_lock(statements) { statements; }
|
|
|
|
#define thread_info_detached(t) 0
|
|
|
|
#define add_thread_info(msg, thr, det) ((void) 0)
|
|
|
|
#define remove_thread_info(tinfo, msg) ((void) 0)
|
|
|
|
#define get_thread_info(thread, msg) NULL
|
|
|
|
|
|
|
|
#else /* LDAP_THREAD_DEBUG_THREAD_ID */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Thread ID tracking. Currently acieves little.
|
|
|
|
* Should be either expanded or deleted.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Array of threads. Used instead of making ldap_pvt_thread_t a wrapper
|
|
|
|
* around ldap_int_thread_t, which would slow down ldap_pvt_thread_self().
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
ldap_pvt_thread_t wrapped;
|
|
|
|
ldap_debug_usage_info_t usage;
|
|
|
|
int detached;
|
|
|
|
int idx;
|
|
|
|
} ldap_debug_thread_t;
|
|
|
|
|
|
|
|
static ldap_debug_thread_t **thread_info;
|
|
|
|
static unsigned int thread_info_size, thread_info_used;
|
|
|
|
static ldap_int_thread_mutex_t thread_info_mutex;
|
|
|
|
|
|
|
|
#define init_thread_info() { \
|
|
|
|
if( threadID ) { \
|
|
|
|
int mutex_init_rc = ldap_int_thread_mutex_init( &thread_info_mutex ); \
|
|
|
|
assert( mutex_init_rc == 0 ); \
|
2005-09-18 07:28:08 +08:00
|
|
|
} \
|
|
|
|
}
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
#define with_thread_info_lock(statements) { \
|
|
|
|
int rc_wtl_ = ldap_int_thread_mutex_lock( &thread_info_mutex ); \
|
|
|
|
assert( rc_wtl_ == 0 ); \
|
|
|
|
{ statements; } \
|
|
|
|
rc_wtl_ = ldap_int_thread_mutex_unlock( &thread_info_mutex ); \
|
|
|
|
assert( rc_wtl_ == 0 ); \
|
|
|
|
}
|
|
|
|
|
|
|
|
#define thread_info_detached(t) ((t)->detached)
|
|
|
|
|
|
|
|
static void
|
|
|
|
add_thread_info(
|
|
|
|
const char *msg,
|
|
|
|
const ldap_pvt_thread_t *thread,
|
|
|
|
int detached )
|
2005-09-18 07:28:08 +08:00
|
|
|
{
|
2006-04-06 03:52:07 +08:00
|
|
|
ldap_debug_thread_t *t;
|
2005-09-18 07:28:08 +08:00
|
|
|
if( thread_info_used >= thread_info_size ) {
|
2006-04-06 03:52:07 +08:00
|
|
|
unsigned int more = thread_info_size + 8;
|
2005-09-18 07:28:08 +08:00
|
|
|
unsigned int new_size = thread_info_size + more;
|
2006-04-06 03:52:07 +08:00
|
|
|
t = calloc( more, sizeof(ldap_debug_thread_t) );
|
2005-09-18 07:28:08 +08:00
|
|
|
assert( t != NULL );
|
|
|
|
thread_info = realloc( thread_info, new_size * sizeof(*thread_info) );
|
|
|
|
assert( thread_info != NULL );
|
|
|
|
while( thread_info_size < new_size ) {
|
|
|
|
t->idx = thread_info_size;
|
|
|
|
thread_info[thread_info_size++] = t++;
|
|
|
|
}
|
|
|
|
}
|
2006-04-06 03:52:07 +08:00
|
|
|
t = thread_info[thread_info_used];
|
|
|
|
init_usage( &t->usage, msg );
|
|
|
|
t->wrapped = *thread;
|
|
|
|
t->detached = detached;
|
|
|
|
thread_info_used++;
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
remove_thread_info( ldap_debug_thread_t *t, const char *msg )
|
|
|
|
{
|
|
|
|
ldap_debug_thread_t *last;
|
|
|
|
int idx;
|
2006-04-06 03:52:07 +08:00
|
|
|
check_usage( &t->usage, msg );
|
|
|
|
destroy_usage( &t->usage );
|
2005-09-18 07:28:08 +08:00
|
|
|
idx = t->idx;
|
|
|
|
assert( thread_info[idx] == t );
|
|
|
|
last = thread_info[--thread_info_used];
|
|
|
|
assert( last->idx == thread_info_used );
|
|
|
|
(thread_info[idx] = last)->idx = idx;
|
|
|
|
(thread_info[thread_info_used] = t )->idx = thread_info_used;
|
|
|
|
}
|
|
|
|
|
2007-05-31 06:20:20 +08:00
|
|
|
static ldap_debug_thread_t *
|
2007-05-19 01:49:38 +08:00
|
|
|
get_thread_info( ldap_pvt_thread_t thread, const char *msg )
|
2005-09-18 07:28:08 +08:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
ldap_debug_thread_t *t;
|
|
|
|
for( i = 0; i < thread_info_used; i++ ) {
|
2007-05-19 01:49:38 +08:00
|
|
|
if( ldap_pvt_thread_equal( thread, thread_info[i]->wrapped ) )
|
2005-09-18 07:28:08 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
ERROR_IF( i == thread_info_used, msg );
|
|
|
|
t = thread_info[i];
|
|
|
|
check_usage( &t->usage, msg );
|
|
|
|
return t;
|
|
|
|
}
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
#endif /* LDAP_THREAD_DEBUG_THREAD_ID */
|
2005-09-18 07:28:08 +08:00
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
|
|
|
|
static char *
|
|
|
|
thread_name( char *buf, int bufsize, ldap_pvt_thread_t thread )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
--bufsize;
|
|
|
|
if( bufsize > 2*sizeof(thread) )
|
|
|
|
bufsize = 2*sizeof(thread);
|
|
|
|
for( i = 0; i < bufsize; i += 2 )
|
|
|
|
snprintf( buf+i, 3, "%02x", ((unsigned char *)&thread)[i/2] );
|
|
|
|
return buf;
|
|
|
|
}
|
2005-09-18 07:28:08 +08:00
|
|
|
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
/* Add <adjust> (+/-1) to resource count <which> unless "nocount". */
|
2005-09-18 07:28:08 +08:00
|
|
|
static void
|
|
|
|
adjust_count( int which, int adjust )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
switch( count ) {
|
|
|
|
case Count_no:
|
|
|
|
break;
|
|
|
|
case Count_yes:
|
|
|
|
rc = ldap_int_thread_mutex_lock( &resource_mutexes[which] );
|
|
|
|
assert( rc == 0 );
|
|
|
|
resource_counts[which] += adjust;
|
|
|
|
rc = ldap_int_thread_mutex_unlock( &resource_mutexes[which] );
|
|
|
|
assert( rc == 0 );
|
2006-04-30 06:31:33 +08:00
|
|
|
break;
|
2005-09-18 07:28:08 +08:00
|
|
|
case Count_reported:
|
2006-04-06 03:52:07 +08:00
|
|
|
fputs( "== thr_debug: More thread activity after exit ==\n", stderr );
|
2005-09-18 07:28:08 +08:00
|
|
|
count = Count_reported_more;
|
|
|
|
/* FALL THROUGH */
|
|
|
|
case Count_reported_more:
|
|
|
|
/* Not used, but result might be inspected with debugger */
|
|
|
|
/* (Hopefully threading is disabled by now...) */
|
|
|
|
resource_counts[which] += adjust;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Wrappers for LDAP_THREAD_IMPLEMENTATION: */
|
|
|
|
|
|
|
|
/* Used instead of ldap_int_thread_initialize by ldap_pvt_thread_initialize */
|
|
|
|
int
|
|
|
|
ldap_debug_thread_initialize( void )
|
|
|
|
{
|
|
|
|
int i, rc, rc2;
|
|
|
|
if( !options_done )
|
|
|
|
get_options();
|
|
|
|
ERROR_IF( threading_enabled, "ldap_debug_thread_initialize" );
|
|
|
|
threading_enabled = 1;
|
|
|
|
rc = ldap_int_thread_initialize();
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_debug_thread_initialize:threads" );
|
|
|
|
threading_enabled = 0;
|
|
|
|
} else {
|
2006-04-06 03:52:07 +08:00
|
|
|
init_thread_info();
|
2005-09-18 07:28:08 +08:00
|
|
|
if( count != Count_no ) {
|
|
|
|
for( i = rc2 = 0; i < Idx_max; i++ )
|
|
|
|
rc2 |= ldap_int_thread_mutex_init( &resource_mutexes[i] );
|
|
|
|
assert( rc2 == 0 );
|
|
|
|
/* FIXME: Only for static libldap_r as in init.c? If so, why? */
|
|
|
|
atexit( count_resource_leaks );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Used instead of ldap_int_thread_destroy by ldap_pvt_thread_destroy */
|
|
|
|
int
|
|
|
|
ldap_debug_thread_destroy( void )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_debug_thread_destroy" );
|
|
|
|
/* sleep(1) -- need to wait for thread pool to finish? */
|
|
|
|
rc = ldap_int_thread_destroy();
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_debug_thread_destroy:threads" );
|
|
|
|
} else {
|
|
|
|
threading_enabled = 0;
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_set_concurrency( int n )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_set_concurrency" );
|
|
|
|
rc = ldap_int_thread_set_concurrency( n );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_set_concurrency" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_get_concurrency( void )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_get_concurrency" );
|
|
|
|
rc = ldap_int_thread_get_concurrency();
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_get_concurrency" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned int
|
|
|
|
ldap_pvt_thread_sleep( unsigned int interval )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_sleep" );
|
|
|
|
rc = ldap_int_thread_sleep( interval );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_sleep" );
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-05-01 23:23:16 +08:00
|
|
|
static void
|
2006-04-30 09:15:57 +08:00
|
|
|
thread_exiting( const char *how, const char *msg )
|
|
|
|
{
|
|
|
|
ldap_pvt_thread_t thread;
|
2007-05-10 03:21:08 +08:00
|
|
|
#if 0 /* Detached threads may exit after ldap_debug_thread_destroy(). */
|
2006-04-30 09:15:57 +08:00
|
|
|
ERROR_IF( !threading_enabled, msg );
|
2007-05-10 03:21:08 +08:00
|
|
|
#endif
|
2006-04-30 09:15:57 +08:00
|
|
|
thread = ldap_pvt_thread_self();
|
|
|
|
if( tracethreads ) {
|
|
|
|
char buf[40];
|
|
|
|
fprintf( stderr, "== thr_debug: %s thread %s ==\n",
|
|
|
|
how, thread_name( buf, sizeof(buf), thread ) );
|
|
|
|
}
|
|
|
|
if( threadID ) {
|
|
|
|
with_thread_info_lock({
|
2007-05-19 01:49:38 +08:00
|
|
|
ldap_debug_thread_t *t = get_thread_info( thread, msg );
|
2006-04-30 09:15:57 +08:00
|
|
|
if( thread_info_detached( t ) )
|
|
|
|
remove_thread_info( t, msg );
|
|
|
|
});
|
|
|
|
}
|
|
|
|
adjust_count( Idx_unexited_thread, -1 );
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ldap_pvt_thread_exit( void *retval )
|
|
|
|
{
|
|
|
|
thread_exiting( "Exiting", "ldap_pvt_thread_exit" );
|
|
|
|
ldap_int_thread_exit( retval );
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
void *(*start_routine)( void * );
|
|
|
|
void *arg;
|
|
|
|
} ldap_debug_thread_call_t;
|
|
|
|
|
|
|
|
static void *
|
|
|
|
ldap_debug_thread_wrapper( void *arg )
|
|
|
|
{
|
|
|
|
void *ret;
|
|
|
|
ldap_debug_thread_call_t call = *(ldap_debug_thread_call_t *)arg;
|
|
|
|
free( arg );
|
|
|
|
ret = call.start_routine( call.arg );
|
|
|
|
thread_exiting( "Returning from", "ldap_debug_thread_wrapper" );
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-09-18 07:28:08 +08:00
|
|
|
int
|
|
|
|
ldap_pvt_thread_create(
|
|
|
|
ldap_pvt_thread_t *thread,
|
|
|
|
int detach,
|
|
|
|
void *(*start_routine)( void * ),
|
|
|
|
void *arg )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
if( !options_done )
|
|
|
|
get_options();
|
2006-04-06 03:52:07 +08:00
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_create" );
|
2006-04-30 09:15:57 +08:00
|
|
|
if( wrap_threads ) {
|
|
|
|
ldap_debug_thread_call_t *call = malloc(
|
|
|
|
sizeof( ldap_debug_thread_call_t ) );
|
|
|
|
assert( call != NULL );
|
|
|
|
call->start_routine = start_routine;
|
|
|
|
call->arg = arg;
|
|
|
|
start_routine = ldap_debug_thread_wrapper;
|
|
|
|
arg = call;
|
|
|
|
}
|
2006-04-06 03:52:07 +08:00
|
|
|
if( threadID ) {
|
|
|
|
with_thread_info_lock({
|
|
|
|
rc = ldap_int_thread_create( thread, detach, start_routine, arg );
|
|
|
|
if( rc == 0 )
|
|
|
|
add_thread_info( "ldap_pvt_thread_create", thread, detach );
|
|
|
|
});
|
|
|
|
} else {
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_create( thread, detach, start_routine, arg );
|
2006-04-06 03:52:07 +08:00
|
|
|
}
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_create" );
|
2007-05-19 01:49:38 +08:00
|
|
|
if( wrap_threads )
|
|
|
|
free( arg );
|
2006-04-06 03:52:07 +08:00
|
|
|
} else {
|
2005-09-18 07:28:08 +08:00
|
|
|
if( tracethreads ) {
|
2006-04-06 03:52:07 +08:00
|
|
|
char buf[40], buf2[40];
|
|
|
|
fprintf( stderr,
|
|
|
|
"== thr_debug: Created thread %s%s from thread %s ==\n",
|
2005-09-18 07:28:08 +08:00
|
|
|
thread_name( buf, sizeof(buf), *thread ),
|
2006-04-06 03:52:07 +08:00
|
|
|
detach ? " (detached)" : "",
|
|
|
|
thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
adjust_count( Idx_unexited_thread, +1 );
|
|
|
|
if( !detach )
|
|
|
|
adjust_count( Idx_unjoined_thread, +1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
|
|
|
|
{
|
|
|
|
int rc;
|
2006-04-06 03:52:07 +08:00
|
|
|
ldap_debug_thread_t *t = NULL;
|
2005-09-18 07:28:08 +08:00
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_join" );
|
|
|
|
if( tracethreads ) {
|
2006-04-06 03:52:07 +08:00
|
|
|
char buf[40], buf2[40];
|
|
|
|
fprintf( stderr, "== thr_debug: Joining thread %s in thread %s ==\n",
|
|
|
|
thread_name( buf, sizeof(buf), thread ),
|
|
|
|
thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
2006-04-06 03:52:07 +08:00
|
|
|
if( threadID )
|
|
|
|
with_thread_info_lock( {
|
2007-05-19 01:49:38 +08:00
|
|
|
t = get_thread_info( thread, "ldap_pvt_thread_join" );
|
2006-04-06 03:52:07 +08:00
|
|
|
ERROR_IF( thread_info_detached( t ), "ldap_pvt_thread_join" );
|
|
|
|
} );
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_join( thread, thread_return );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_join" );
|
|
|
|
} else {
|
2006-04-06 03:52:07 +08:00
|
|
|
if( threadID )
|
|
|
|
with_thread_info_lock(
|
|
|
|
remove_thread_info( t, "ldap_pvt_thread_join" ) );
|
2005-09-18 07:28:08 +08:00
|
|
|
adjust_count( Idx_unjoined_thread, -1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_kill" );
|
|
|
|
if( tracethreads ) {
|
2006-04-06 03:52:07 +08:00
|
|
|
char buf[40], buf2[40];
|
|
|
|
fprintf( stderr,
|
|
|
|
"== thr_debug: Killing thread %s (sig %i) from thread %s ==\n",
|
|
|
|
thread_name( buf, sizeof(buf), thread ), signo,
|
|
|
|
thread_name( buf2, sizeof(buf2), ldap_pvt_thread_self() ) );
|
2005-09-18 07:28:08 +08:00
|
|
|
}
|
|
|
|
rc = ldap_int_thread_kill( thread, signo );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_kill" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_yield( void )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_yield" );
|
|
|
|
rc = ldap_int_thread_yield();
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_yield" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
ldap_pvt_thread_t
|
|
|
|
ldap_pvt_thread_self( void )
|
|
|
|
{
|
|
|
|
#if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_self" );
|
|
|
|
#endif
|
|
|
|
return ldap_int_thread_self();
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
|
|
|
|
{
|
|
|
|
int rc;
|
2006-04-06 03:52:07 +08:00
|
|
|
init_usage( &cond->usage, "ldap_pvt_thread_cond_init" );
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_cond_init( WRAPPED( cond ) );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_cond_init" );
|
2006-04-06 03:52:07 +08:00
|
|
|
destroy_usage( &cond->usage );
|
2005-09-18 07:28:08 +08:00
|
|
|
} else {
|
|
|
|
adjust_count( Idx_cond, +1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cond )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &cond->usage, "ldap_pvt_thread_cond_destroy" );
|
|
|
|
rc = ldap_int_thread_cond_destroy( WRAPPED( cond ) );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_cond_destroy" );
|
|
|
|
} else {
|
2006-04-06 03:52:07 +08:00
|
|
|
destroy_usage( &cond->usage );
|
2005-09-18 07:28:08 +08:00
|
|
|
adjust_count( Idx_cond, -1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &cond->usage, "ldap_pvt_thread_cond_signal" );
|
|
|
|
rc = ldap_int_thread_cond_signal( WRAPPED( cond ) );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_cond_signal" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &cond->usage, "ldap_pvt_thread_cond_broadcast" );
|
|
|
|
rc = ldap_int_thread_cond_broadcast( WRAPPED( cond ) );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_cond_broadcast" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_cond_wait(
|
|
|
|
ldap_pvt_thread_cond_t *cond,
|
|
|
|
ldap_pvt_thread_mutex_t *mutex )
|
|
|
|
{
|
|
|
|
int rc;
|
2006-04-06 03:52:07 +08:00
|
|
|
ldap_int_thread_t owner;
|
2005-09-18 07:28:08 +08:00
|
|
|
check_usage( &cond->usage, "ldap_pvt_thread_cond_wait:cond" );
|
|
|
|
check_usage( &mutex->usage, "ldap_pvt_thread_cond_wait:mutex" );
|
|
|
|
adjust_count( Idx_locked_mutex, -1 );
|
2006-04-06 03:52:07 +08:00
|
|
|
owner = GET_OWNER( mutex );
|
2006-04-03 20:49:30 +08:00
|
|
|
ASSERT_OWNER( mutex, "ldap_pvt_thread_cond_wait" );
|
2006-04-06 03:52:07 +08:00
|
|
|
RESET_OWNER( mutex );
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_cond_wait( WRAPPED( cond ), WRAPPED( mutex ) );
|
2006-04-03 20:49:30 +08:00
|
|
|
ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_cond_wait" );
|
2006-04-06 03:52:07 +08:00
|
|
|
SET_OWNER( mutex, rc ? owner : ldap_int_thread_self() );
|
2005-09-18 07:28:08 +08:00
|
|
|
adjust_count( Idx_locked_mutex, +1 );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_cond_wait" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
|
|
|
|
{
|
|
|
|
int rc;
|
2006-04-06 03:52:07 +08:00
|
|
|
init_usage( &mutex->usage, "ldap_pvt_thread_mutex_init" );
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_mutex_init( WRAPPED( mutex ) );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_mutex_init" );
|
2006-04-06 03:52:07 +08:00
|
|
|
destroy_usage( &mutex->usage );
|
2005-09-18 07:28:08 +08:00
|
|
|
} else {
|
2006-04-02 03:00:37 +08:00
|
|
|
RESET_OWNER( mutex );
|
2005-09-18 07:28:08 +08:00
|
|
|
adjust_count( Idx_mutex, +1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &mutex->usage, "ldap_pvt_thread_mutex_destroy" );
|
2006-04-03 20:49:30 +08:00
|
|
|
ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_destroy" );
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_mutex_destroy( WRAPPED( mutex ) );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_mutex_destroy" );
|
|
|
|
} else {
|
2006-04-06 03:52:07 +08:00
|
|
|
destroy_usage( &mutex->usage );
|
2006-04-02 03:00:37 +08:00
|
|
|
RESET_OWNER( mutex );
|
2005-09-18 07:28:08 +08:00
|
|
|
adjust_count( Idx_mutex, -1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &mutex->usage, "ldap_pvt_thread_mutex_lock" );
|
|
|
|
rc = ldap_int_thread_mutex_lock( WRAPPED( mutex ) );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_mutex_lock" );
|
|
|
|
} else {
|
2006-04-03 20:49:30 +08:00
|
|
|
ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_lock" );
|
2006-04-06 03:52:07 +08:00
|
|
|
SET_OWNER( mutex, ldap_int_thread_self() );
|
2005-09-18 07:28:08 +08:00
|
|
|
adjust_count( Idx_locked_mutex, +1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mutex )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &mutex->usage, "ldap_pvt_thread_mutex_trylock" );
|
|
|
|
rc = ldap_int_thread_mutex_trylock( WRAPPED( mutex ) );
|
2006-04-02 03:00:37 +08:00
|
|
|
if( rc == 0 ) {
|
2006-04-03 20:49:30 +08:00
|
|
|
ASSERT_NO_OWNER( mutex, "ldap_pvt_thread_mutex_trylock" );
|
2006-04-06 03:52:07 +08:00
|
|
|
SET_OWNER( mutex, ldap_int_thread_self() );
|
2005-09-18 07:28:08 +08:00
|
|
|
adjust_count( Idx_locked_mutex, +1 );
|
2006-04-02 03:00:37 +08:00
|
|
|
}
|
2005-09-18 07:28:08 +08:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &mutex->usage, "ldap_pvt_thread_mutex_unlock" );
|
2006-04-03 20:49:30 +08:00
|
|
|
ASSERT_OWNER( mutex, "ldap_pvt_thread_mutex_unlock" );
|
2006-04-02 03:00:37 +08:00
|
|
|
RESET_OWNER( mutex ); /* Breaks if this thread did not own the mutex */
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_mutex_unlock( WRAPPED( mutex ) );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_mutex_unlock" );
|
|
|
|
} else {
|
|
|
|
adjust_count( Idx_locked_mutex, -1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Wrappers for LDAP_THREAD_RDWR_IMPLEMENTATION: */
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_init( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
int rc;
|
2006-04-06 03:52:07 +08:00
|
|
|
init_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_init" );
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_rdwr_init( WRAPPED( rwlock ) );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_rdwr_init" );
|
2006-04-06 03:52:07 +08:00
|
|
|
destroy_usage( &rwlock->usage );
|
2005-09-18 07:28:08 +08:00
|
|
|
} else {
|
|
|
|
adjust_count( Idx_rdwr, +1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_destroy( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_destroy" );
|
|
|
|
rc = ldap_int_thread_rdwr_destroy( WRAPPED( rwlock ) );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_rdwr_destroy" );
|
|
|
|
} else {
|
2006-04-06 03:52:07 +08:00
|
|
|
destroy_usage( &rwlock->usage );
|
2005-09-18 07:28:08 +08:00
|
|
|
adjust_count( Idx_rdwr, -1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_rlock( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_rlock" );
|
|
|
|
rc = ldap_int_thread_rdwr_rlock( WRAPPED( rwlock ) );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_rdwr_rlock" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_rtrylock( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_rtrylock" );
|
|
|
|
return ldap_int_thread_rdwr_rtrylock( WRAPPED( rwlock ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_runlock( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_runlock" );
|
|
|
|
rc = ldap_int_thread_rdwr_runlock( WRAPPED( rwlock ) );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_rdwr_runlock" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_wlock( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wlock" );
|
|
|
|
rc = ldap_int_thread_rdwr_wlock( WRAPPED( rwlock ) );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_rdwr_wlock" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_wtrylock( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wtrylock" );
|
|
|
|
return ldap_int_thread_rdwr_wtrylock( WRAPPED( rwlock ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_wunlock( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_wunlock" );
|
|
|
|
rc = ldap_int_thread_rdwr_wunlock( WRAPPED( rwlock ) );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_rdwr_wunlock" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
#if defined(LDAP_RDWR_DEBUG) && !defined(LDAP_THREAD_HAVE_RDWR)
|
2005-09-18 07:28:08 +08:00
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_readers( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_readers" );
|
|
|
|
return ldap_int_thread_rdwr_readers( WRAPPED( rwlock ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_writers( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_writers" );
|
|
|
|
return ldap_int_thread_rdwr_writers( WRAPPED( rwlock ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_rdwr_active( ldap_pvt_thread_rdwr_t *rwlock )
|
|
|
|
{
|
|
|
|
check_usage( &rwlock->usage, "ldap_pvt_thread_rdwr_active" );
|
|
|
|
return ldap_int_thread_rdwr_active( WRAPPED( rwlock ) );
|
|
|
|
}
|
|
|
|
|
2006-04-06 03:52:07 +08:00
|
|
|
#endif /* LDAP_RDWR_DEBUG && !LDAP_THREAD_HAVE_RDWR */
|
2005-09-18 07:28:08 +08:00
|
|
|
|
|
|
|
|
|
|
|
/* Some wrappers for LDAP_THREAD_POOL_IMPLEMENTATION: */
|
|
|
|
#ifdef LDAP_THREAD_POOL_IMPLEMENTATION
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_init(
|
|
|
|
ldap_pvt_thread_pool_t *tpool,
|
|
|
|
int max_threads,
|
|
|
|
int max_pending )
|
|
|
|
{
|
|
|
|
int rc;
|
2006-04-06 03:52:07 +08:00
|
|
|
if( !options_done )
|
|
|
|
get_options();
|
2005-09-18 07:28:08 +08:00
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_init" );
|
|
|
|
rc = ldap_int_thread_pool_init( tpool, max_threads, max_pending );
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_pool_init" );
|
|
|
|
} else {
|
|
|
|
adjust_count( Idx_tpool, +1 );
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_submit(
|
|
|
|
ldap_pvt_thread_pool_t *tpool,
|
|
|
|
ldap_pvt_thread_start_t *start_routine, void *arg )
|
|
|
|
{
|
|
|
|
int rc, has_pool;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_submit" );
|
2007-05-31 06:20:20 +08:00
|
|
|
has_pool = (tpool && *tpool);
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_pool_submit( tpool, start_routine, arg );
|
|
|
|
if( has_pool )
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_pool_submit" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_maxthreads(
|
|
|
|
ldap_pvt_thread_pool_t *tpool,
|
|
|
|
int max_threads )
|
|
|
|
{
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_maxthreads" );
|
|
|
|
return ldap_int_thread_pool_maxthreads( tpool, max_threads );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_backload( ldap_pvt_thread_pool_t *tpool )
|
|
|
|
{
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_backload" );
|
|
|
|
return ldap_int_thread_pool_backload( tpool );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_destroy( ldap_pvt_thread_pool_t *tpool, int run_pending )
|
|
|
|
{
|
|
|
|
int rc, has_pool;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_destroy" );
|
2007-05-31 06:20:20 +08:00
|
|
|
has_pool = (tpool && *tpool);
|
2005-09-18 07:28:08 +08:00
|
|
|
rc = ldap_int_thread_pool_destroy( tpool, run_pending );
|
|
|
|
if( has_pool ) {
|
|
|
|
if( rc ) {
|
|
|
|
ERROR( rc, "ldap_pvt_thread_pool_destroy" );
|
|
|
|
} else {
|
|
|
|
adjust_count( Idx_tpool, -1 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_pause( ldap_pvt_thread_pool_t *tpool )
|
|
|
|
{
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_pause" );
|
|
|
|
return ldap_int_thread_pool_pause( tpool );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_resume( ldap_pvt_thread_pool_t *tpool )
|
|
|
|
{
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_resume" );
|
|
|
|
return ldap_int_thread_pool_resume( tpool );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_getkey(
|
|
|
|
void *xctx,
|
|
|
|
void *key,
|
|
|
|
void **data,
|
|
|
|
ldap_pvt_thread_pool_keyfree_t **kfree )
|
|
|
|
{
|
|
|
|
#if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_getkey" );
|
|
|
|
#endif
|
|
|
|
return ldap_int_thread_pool_getkey( xctx, key, data, kfree );
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldap_pvt_thread_pool_setkey(
|
|
|
|
void *xctx,
|
|
|
|
void *key,
|
|
|
|
void *data,
|
|
|
|
ldap_pvt_thread_pool_keyfree_t *kfree )
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_setkey" );
|
|
|
|
rc = ldap_int_thread_pool_setkey( xctx, key, data, kfree );
|
|
|
|
ERROR_IF( rc, "ldap_pvt_thread_pool_setkey" );
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ldap_pvt_thread_pool_purgekey( void *key )
|
|
|
|
{
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_purgekey" );
|
|
|
|
ldap_int_thread_pool_purgekey( key );
|
|
|
|
}
|
|
|
|
|
|
|
|
void *
|
|
|
|
ldap_pvt_thread_pool_context( void )
|
|
|
|
{
|
|
|
|
#if 0 /* Function is used by ch_free() via slap_sl_contxt() in slapd */
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_context" );
|
|
|
|
#endif
|
|
|
|
return ldap_int_thread_pool_context();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ldap_pvt_thread_pool_context_reset( void *vctx )
|
|
|
|
{
|
|
|
|
ERROR_IF( !threading_enabled, "ldap_pvt_thread_pool_context_reset" );
|
|
|
|
ldap_int_thread_pool_context_reset( vctx );
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* LDAP_THREAD_POOL_IMPLEMENTATION */
|
|
|
|
|
|
|
|
#endif /* LDAP_THREAD_DEBUG */
|