upstream/openldap
1
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2026-02-18 18:18:06 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

MegaCommit of locking update.

Browse source 
use ldap_pvt_ routines (replacing old lthread impl)
This commit is contained in:
Kurt Zeilenga 1999-01-29 06:11:40 +00:00
parent eb82000f3f
commit 98331ed1dd
65 changed files with 2394 additions and 2146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
CHANGES
View file

@ -4,8 +4,10 @@ Changes included in OpenLDAP 1.2
CVS Tag: OPENLDAP_REL_ENG_1_2
Fixed slapd/ldbm/add cache set state deadlock bug
Fixed slapd/ldbm/add,modrdn,delete e_ndn handling
Update ldap_open(3) man page to note ldap_init() is preferred.
Updated ldap_open(3) man page to note ldap_init() is preferred.
Updated internal thread library
Build environment
Fixed --without-threads building
Fixed mkdep to handle multiple dependent files on one line
Fixed openldap.m4 to "protect" shell variable
Fixed HAVE_PHREAD_FINAL typo

1021
configure vendored
View file

File diff suppressed because it is too large Load diff

27
configure.in
View file

@ -50,6 +50,8 @@ OL_ARG_ENABLE(x_compile,[ --enable-x-compile enable cross compiling],
no, [yes no])dnl
dnl General "with" options
OL_ARG_ENABLE(dmalloc,[ --enable-dmalloc enable debug malloc support], no)dnl
OL_ARG_WITH(kerberos,[ --with-kerberos use Kerberos],
auto, [auto k5 k4 afs yes no])
OL_ARG_WITH(threads,[ --with-threads use threads],
@ -592,30 +594,28 @@ if test $ol_with_threads = auto -o $ol_with_threads = yes \
if test $ac_cv_func_sched_yield = no -a \
$ac_cv_func_pthread_yield = no ; then
dnl Solaris has sched_yield() in -lposix4
AC_CHECK_LIB(posix4, sched_yield,
[LTHREAD_LIBS="$LTHREAD_LIBS -lposix4"
AC_DEFINE(HAVE_SCHED_YIELD,1)
ac_cv_func_sched_yield=yes],
[ac_cv_func_sched_yield=no])
dnl but we'll use thr_yield instead.
AC_CHECK_FUNCS(thr_yield)
fi
if test $ac_cv_func_sched_yield = no -a \
$ac_cv_func_pthread_yield = no ; then
$ac_cv_func_pthread_yield = no -a \
"$ac_cv_func_thr_yield" = no ; then
AC_MSG_WARN([could not locate sched_yield() or pthread_yield()])
fi
dnl Check functions for compatibility
AC_CHECK_FUNCS(pthread_kill pthread_detach)
AC_CHECK_FUNCS( \
pthread_attr_create pthread_attr_init \
pthread_attr_destroy pthread_attr_delete \
pthread_attr_setdetachstate pthread_attr_setdetach_np \
)
if test $ac_cv_func_pthread_detach = no ; then
AC_MSG_ERROR([could not locate pthread_detach()])
fi
dnl Check for setconcurreny functions
AC_CHECK_FUNCS( \
pthread_setconcurrency \
pthread_getconcurrency \
thr_setconcurrency \
thr_getconcurrency \
)
AC_MSG_CHECKING([if pthread_create() works])
@ -1018,6 +1018,11 @@ if test $ol_enable_wrappers != no ; then
fi
fi
if test $ol_enable_dmalloc != no ; then
AC_CHECK_HEADERS(dmalloc.h)
AC_CHECK_LIB(dmalloc, dmalloc_shutdown)
fi
# ud needs termcap (should insert check here)
ol_link_termcap=no
AC_CHECK_HEADERS(termcap.h ncurses.h)

263
include/ldap_pvt_thread.h Normal file
View file

@ -0,0 +1,263 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
/* ldap_pvt_thread.h - ldap threads header file NG */
#ifndef _LDAP_PVT_THREAD_H
#define _LDAP_PVT_THREAD_H
#include "ldap_cdefs.h"
#if defined( HAVE_PTHREADS )
/**********************************
* *
* definitions for POSIX Threads *
* *
**********************************/
#include <pthread.h>
#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
LDAP_BEGIN_DECL
typedef pthread_t ldap_pvt_thread_t;
typedef pthread_mutex_t ldap_pvt_thread_mutex_t;
typedef pthread_cond_t ldap_pvt_thread_cond_t;
#if defined( _POSIX_REENTRANT_FUNCTIONS ) || \
defined( _POSIX_THREAD_SAFE_FUNCTIONS ) || \
defined( _POSIX_THREADSAFE_FUNCTIONS )
#define HAVE_REENTRANT_FUNCTIONS 1
#endif
#if defined( HAVE_PTHREAD_GETCONCURRENCY ) || \
defined( HAVE_THR_GETCONCURRENCY )
#define HAVE_GETCONCURRENCY 1
#endif
#if defined( HAVE_PTHREAD_SETCONCURRENCY ) || \
defined( HAVE_THR_SETCONCURRENCY )
#define HAVE_SETCONCURRENCY 1
#endif
LDAP_END_DECL
#elif defined ( HAVE_MACH_CTHREADS )
/**********************************
* *
* definitions for Mach CThreads *
* *
**********************************/
#include <mach/cthreads.h>
LDAP_BEGIN_DECL
typedef cthread_t ldap_pvt_thread_t;
typedef struct mutex ldap_pvt_thread_mutex_t;
typedef struct condition ldap_pvt_thread_cond_t;
LDAP_END_DECL
#elif defined( HAVE_THR )
/********************************************
* *
* thread definitions for Solaris LWP (THR) *
* *
********************************************/
#include <thread.h>
#include <synch.h>
LDAP_BEGIN_DECL
typedef thread_t ldap_pvt_thread_t;
typedef mutex_t ldap_pvt_thread_mutex_t;
typedef cond_t ldap_pvt_thread_cond_t;
#define HAVE_REENTRANT_FUNCTIONS 1
#ifdef HAVE_THR_GETCONCURRENCY
#define HAVE_GETCONCURRENCY 1
#endif
#ifdef HAVE_THR_SETCONCURRENCY
#define HAVE_SETCONCURRENCY 1
#endif
LDAP_END_DECL
#elif defined( HAVE_LWP )
/*************************************
* *
* thread definitions for SunOS LWP *
* *
*************************************/
#include <lwp/lwp.h>
#include <lwp/stackdep.h>
LDAP_BEGIN_DECL
typedef thread_t ldap_pvt_thread_t;
typedef mon_t ldap_pvt_thread_mutex_t;
struct lwpcv {
int lcv_created;
cv_t lcv_cv;
};
typedef struct lwpcv ldap_pvt_thread_cond_t;
#define HAVE_REENTRANT_FUNCTIONS 1
LDAP_END_DECL
#elif HAVE_NT_THREADS
#include <windows.h>
#include <process.h>
LDAP_BEGIN_DECL
typedef HANDLE ldap_pvt_thread_t;
typedef HANDLE ldap_pvt_thread_mutex_t;
typedef HANDLE ldap_pvt_thread_cond_t;
LDAP_END_DECL
#else
/***********************************
* *
* thread definitions for no *
* underlying library support *
* *
***********************************/
LDAP_BEGIN_DECL
#ifndef NO_THREADS
#define NO_THREADS 1
#endif
typedef int ldap_pvt_thread_t;
typedef int ldap_pvt_thread_mutex_t;
typedef int ldap_pvt_thread_cond_t;
LDAP_END_DECL
#endif /* no threads support */
#ifndef NO_THREADS
# define HAVE_THREADS 1
#endif
LDAP_BEGIN_DECL
LDAP_F int
ldap_pvt_thread_initialize LDAP_P(( void ));
LDAP_F unsigned int
ldap_pvt_thread_sleep LDAP_P(( unsigned int s ));
#ifdef HAVE_GETCONCURRENCY
LDAP_F int
ldap_pvt_thread_getconcurrency LDAP_P(( void ));
#endif
#ifdef HAVE_SETCONCURRENCY
# ifndef LDAP_THREAD_CONCURRENCY
/* three concurrent threads should be enough */
# define LDAP_THREAD_CONCURRENCY 3
# endif
LDAP_F int
ldap_pvt_thread_setconcurrency LDAP_P(( int ));
#endif
LDAP_F int
ldap_pvt_thread_create LDAP_P((
ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void * ),
void *arg));
LDAP_F void
ldap_pvt_thread_exit LDAP_P(( void *retval ));
LDAP_F int
ldap_pvt_thread_join LDAP_P(( ldap_pvt_thread_t thread, void **status ));
LDAP_F int
ldap_pvt_thread_kill LDAP_P(( ldap_pvt_thread_t thread, int signo ));
LDAP_F int
ldap_pvt_thread_yield LDAP_P(( void ));
LDAP_F int
ldap_pvt_thread_cond_init LDAP_P(( ldap_pvt_thread_cond_t *cond ));
LDAP_F int
ldap_pvt_thread_cond_signal LDAP_P(( ldap_pvt_thread_cond_t *cond ));
LDAP_F int
ldap_pvt_thread_cond_broadcast LDAP_P(( ldap_pvt_thread_cond_t *cond ));
LDAP_F int
ldap_pvt_thread_cond_wait LDAP_P((
ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex ));
LDAP_F int
ldap_pvt_thread_mutex_init LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
LDAP_F int
ldap_pvt_thread_mutex_destroy LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
LDAP_F int
ldap_pvt_thread_mutex_lock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
LDAP_F int
ldap_pvt_thread_mutex_trylock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
LDAP_F int
ldap_pvt_thread_mutex_unlock LDAP_P(( ldap_pvt_thread_mutex_t *mutex ));
typedef struct ldap_pvt_thread_rdwr_var {
int lt_readers_reading;
int lt_writer_writing;
ldap_pvt_thread_mutex_t lt_mutex;
ldap_pvt_thread_cond_t lt_lock_free;
} ldap_pvt_thread_rdwr_t;
#define LDAP_PVT_THREAD_CREATE_DETACHED 1
#define LDAP_PVT_THREAD_CREATE_JOINABLE 0
LDAP_F int
ldap_pvt_thread_rdwr_init LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
LDAP_F int
ldap_pvt_thread_rdwr_rlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
LDAP_F int
ldap_pvt_thread_rdwr_runlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
LDAP_F int
ldap_pvt_thread_rdwr_wlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
LDAP_F int
ldap_pvt_thread_rdwr_wunlock LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
#ifdef LDAP_DEBUG
LDAP_F int
ldap_pvt_thread_rdwr_rchk LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
LDAP_F int
ldap_pvt_thread_rdwr_wchk LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
LDAP_F int
ldap_pvt_thread_rdwr_rwchk LDAP_P((ldap_pvt_thread_rdwr_t *rdwrp));
#endif /* LDAP_DEBUG */
LDAP_END_DECL
#endif /* _LDAP_THREAD_H */

241
include/lthread.h
View file

@ -1,241 +0,0 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
/* lthread.h - ldap threads header file */
#ifndef _LTHREAD_H
#define _LTHREAD_H
#include "portable.h"
#if defined( HAVE_PTHREADS )
/**********************************
* *
* definitions for POSIX Threads *
* *
**********************************/
#include <pthread.h>
#ifdef HAVE_SCHED_H
#include <sched.h>
#endif
LDAP_BEGIN_DECL
#if !defined( HAVE_PTHREAD_ATTR_INIT ) && \
defined( HAVE_PTHREAD_ATTR_CREATE )
#define pthread_attr_init( a ) pthread_attr_create( a )
#endif
#if !defined( HAVE_PTHREAD_ATTR_DESTROY ) && \
defined( HAVE_PTHREAD_ATTR_DELETE )
#define pthread_attr_destroy( a ) pthread_attr_delete( a )
#endif
#if !defined( HAVE_PTHREAD_ATTR_SETDETACHSTATE ) && \
defined( HAVE_PTHREAD_ATTR_SETDETACH_NP )
#define pthread_attr_setdetachstate( a, b ) \
pthread_attr_setdetach_np( a, b )
#endif
#ifndef HAVE_PTHREAD_KILL
/* missing pthread_kill(), define prototype */
LDAP_F void pthread_kill LDAP_P(( pthread_t tid, int sig ));
#endif
#ifndef HAVE_PTHREADS_D4
#define pthread_mutexattr_default NULL
#define pthread_condattr_default NULL
#ifdef HAVE_SCHED_YIELD
#define pthread_yield sched_yield
#endif
#endif
LDAP_END_DECL
#elif defined ( HAVE_MACH_CTHREADS )
/**********************************
* *
* definitions for Mach CThreads *
* *
**********************************/
#include <mach/cthreads.h>
LDAP_BEGIN_DECL
typedef cthread_fn_t VFP;
typedef int pthread_attr_t;
typedef cthread_t pthread_t;
/* default attr states */
#define pthread_mutexattr_default NULL
#define pthread_condattr_default NULL
/* thread state - joinable or not */
#define PTHREAD_CREATE_JOINABLE 0
#define PTHREAD_CREATE_DETACHED 1
/* thread scope - who is in scheduling pool */
#define PTHREAD_SCOPE_PROCESS 0
#define PTHREAD_SCOPE_SYSTEM 1
/* mutex attributes and mutex type */
typedef int pthread_mutexattr_t;
typedef struct mutex pthread_mutex_t;
/* mutex and condition variable scope - process or system */
#define PTHREAD_SHARE_PRIVATE 0
#define PTHREAD_SHARE_PROCESS 1
/* condition variable attributes and condition variable type */
typedef int pthread_condattr_t;
typedef struct condition pthread_cond_t;
LDAP_END_DECL
#elif defined( HAVE_THR )
/**************************************
* *
* thread definitions for Solaris LWP *
* *
**************************************/
#include <thread.h>
#include <synch.h>
LDAP_BEGIN_DECL
typedef void *(*VFP)();
/* default attr states */
#define pthread_mutexattr_default NULL
#define pthread_condattr_default NULL
/* thread state - joinable or not */
#define PTHREAD_CREATE_JOINABLE 0
#define PTHREAD_CREATE_DETACHED THR_DETACHED
/* thread scope - who is in scheduling pool */
#define PTHREAD_SCOPE_PROCESS 0
#define PTHREAD_SCOPE_SYSTEM THR_BOUND
/* mutex and condition variable scope - process or system */
#define PTHREAD_SHARE_PRIVATE USYNC_THREAD
#define PTHREAD_SHARE_PROCESS USYNC_PROCESS
/* thread attributes and thread type */
typedef int pthread_attr_t;
typedef thread_t pthread_t;
/* mutex attributes and mutex type */
typedef int pthread_mutexattr_t;
typedef mutex_t pthread_mutex_t;
/* condition variable attributes and condition variable type */
typedef int pthread_condattr_t;
typedef cond_t pthread_cond_t;
LDAP_END_DECL
#elif defined( HAVE_LWP )
/*************************************
* *
* thread definitions for SunOS LWP *
* *
*************************************/
#include <lwp/lwp.h>
#include <lwp/stackdep.h>
LDAP_BEGIN_DECL
stkalign_t *get_stack( int *stacknop );
void free_stack( int *stackno );
typedef void *(*VFP)();
/* thread attributes and thread type */
typedef int pthread_attr_t;
typedef thread_t pthread_t;
/* default attr states */
#define pthread_mutexattr_default NULL
#define pthread_condattr_default NULL
/* thread state - joinable or not */
#define PTHREAD_CREATE_JOINABLE 0
#define PTHREAD_CREATE_DETACHED 1
/* thread scope - who is in scheduling pool */
#define PTHREAD_SCOPE_PROCESS 0
#define PTHREAD_SCOPE_SYSTEM 1
/* mutex attributes and mutex type */
typedef int pthread_mutexattr_t;
typedef mon_t pthread_mutex_t;
/* mutex and condition variable scope - process or system */
#define PTHREAD_SHARE_PRIVATE 0
#define PTHREAD_SHARE_PROCESS 1
/* condition variable attributes and condition variable type */
typedef int pthread_condattr_t;
typedef struct lwpcv {
int lcv_created;
cv_t lcv_cv;
} pthread_cond_t;
LDAP_END_DECL
#else
/***********************************
* *
* thread definitions for no *
* underlying library support *
* *
***********************************/
LDAP_BEGIN_DECL
#ifndef NO_THREADS
#define NO_THREADS 1
#endif
typedef void *(*VFP)();
/* thread attributes and thread type */
typedef int pthread_attr_t;
typedef int pthread_t;
/* default attr states */
#define pthread_mutexattr_default NULL
#define pthread_condattr_default NULL
/* thread state - joinable or not */
#define PTHREAD_CREATE_JOINABLE 0
#define PTHREAD_CREATE_DETACHED 0
/* thread scope - who is in scheduling pool */
#define PTHREAD_SCOPE_PROCESS 0
#define PTHREAD_SCOPE_SYSTEM 0
/* mutex attributes and mutex type */
typedef int pthread_mutexattr_t;
typedef int pthread_mutex_t;
/* mutex and condition variable scope - process or system */
#define PTHREAD_SHARE_PRIVATE 0
#define PTHREAD_SHARE_PROCESS 0
/* condition variable attributes and condition variable type */
typedef int pthread_condattr_t;
typedef int pthread_cond_t;
LDAP_END_DECL
#endif /* no threads support */
#endif /* _LTHREAD_H */

56
include/lthread_rdwr.h
View file

@ -1,56 +0,0 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
#ifndef _LTHREAD_RDWR_H
#define _LTHREAD_RDWR_H 1
/********************************************************
* An example source module to accompany...
*
* "Using POSIX Threads: Programming with Pthreads"
* by Brad nichols, Dick Buttlar, Jackie Farrell
* O'Reilly & Associates, Inc.
*
********************************************************
*
* Include file for reader/writer locks
*
*/
#include <ldap_cdefs.h>
LDAP_BEGIN_DECL
typedef struct rdwr_var {
int readers_reading;
int writer_writing;
pthread_mutex_t mutex;
pthread_cond_t lock_free;
} pthread_rdwr_t;
typedef void * pthread_rdwrattr_t;
#define pthread_rdwrattr_default NULL;
LDAP_F int pthread_rdwr_init_np LDAP_P((pthread_rdwr_t *rdwrp, pthread_rdwrattr_t *attrp));
LDAP_F int pthread_rdwr_rlock_np LDAP_P((pthread_rdwr_t *rdwrp));
LDAP_F int pthread_rdwr_runlock_np LDAP_P((pthread_rdwr_t *rdwrp));
LDAP_F int pthread_rdwr_wlock_np LDAP_P((pthread_rdwr_t *rdwrp));
LDAP_F int pthread_rdwr_wunlock_np LDAP_P((pthread_rdwr_t *rdwrp));
#ifdef LDAP_DEBUG
LDAP_F int pthread_rdwr_rchk_np LDAP_P((pthread_rdwr_t *rdwrp));
LDAP_F int pthread_rdwr_wchk_np LDAP_P((pthread_rdwr_t *rdwrp));
LDAP_F int pthread_rdwr_rwchk_np LDAP_P((pthread_rdwr_t *rdwrp));
#endif /* LDAP_DEBUG */
LDAP_END_DECL
#endif /* _LTHREAD_RDWR_H */

30
include/portable.h.in
View file

@ -305,27 +305,12 @@
/* Define if you have the mkstemp function. */
#undef HAVE_MKSTEMP
/* Define if you have the pthread_attr_create function. */
#undef HAVE_PTHREAD_ATTR_CREATE
/* Define if you have the pthread_attr_delete function. */
#undef HAVE_PTHREAD_ATTR_DELETE
/* Define if you have the pthread_attr_destroy function. */
#undef HAVE_PTHREAD_ATTR_DESTROY
/* Define if you have the pthread_attr_init function. */
#undef HAVE_PTHREAD_ATTR_INIT
/* Define if you have the pthread_attr_setdetach_np function. */
#undef HAVE_PTHREAD_ATTR_SETDETACH_NP
/* Define if you have the pthread_attr_setdetachstate function. */
#undef HAVE_PTHREAD_ATTR_SETDETACHSTATE
/* Define if you have the pthread_detach function. */
#undef HAVE_PTHREAD_DETACH
/* Define if you have the pthread_getconcurrency function. */
#undef HAVE_PTHREAD_GETCONCURRENCY
/* Define if you have the pthread_kill function. */
#undef HAVE_PTHREAD_KILL
@ -401,6 +386,9 @@
/* Define if you have the thr_setconcurrency function. */
#undef HAVE_THR_SETCONCURRENCY
/* Define if you have the thr_yield function. */
#undef HAVE_THR_YIELD
/* Define if you have the vsnprintf function. */
#undef HAVE_VSNPRINTF
@ -425,6 +413,9 @@
/* Define if you have the <dirent.h> header file. */
#undef HAVE_DIRENT_H
/* Define if you have the <dmalloc.h> header file. */
#undef HAVE_DMALLOC_H
/* Define if you have the <errno.h> header file. */
#undef HAVE_ERRNO_H
@ -569,6 +560,9 @@
/* Define if you have the bind library (-lbind). */
#undef HAVE_LIBBIND
/* Define if you have the dmalloc library (-ldmalloc). */
#undef HAVE_LIBDMALLOC
/* Define if you have the gen library (-lgen). */
#undef HAVE_LIBGEN

26
libraries/libldbm/ldbm.c
View file

@ -19,7 +19,7 @@
#include <ac/errno.h>
#include "ldbm.h"
#include "lthread.h"
#include "ldap_pvt_thread.h"
#if defined( LDBM_USE_DBHASH ) || defined( LDBM_USE_DBBTREE )
@ -87,9 +87,9 @@ void ldbm_initialize( void )
#else
/* DB 1.85 is non-reentrant */
static pthread_mutex_t ldbm_big_mutex;
#define LDBM_LOCK (pthread_mutex_lock(&ldbm_big_mutex))
#define LDBM_UNLOCK (pthread_mutex_unlock(&ldbm_big_mutex))
static ldap_pvt_thread_mutex_t ldbm_big_mutex;
#define LDBM_LOCK (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
#define LDBM_UNLOCK (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
void ldbm_initialize( void )
{
@ -97,7 +97,7 @@ void ldbm_initialize( void )
if(initialized++) return;
pthread_mutex_init( &ldbm_big_mutex, pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
}
#endif
@ -373,9 +373,9 @@ ldbm_errno( LDBM ldbm )
#include <sys/stat.h>
/* GDBM is non-reentrant */
static pthread_mutex_t ldbm_big_mutex;
#define LDBM_LOCK (pthread_mutex_lock(&ldbm_big_mutex))
#define LDBM_UNLOCK (pthread_mutex_unlock(&ldbm_big_mutex))
static ldap_pvt_thread_mutex_t ldbm_big_mutex;
#define LDBM_LOCK (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
#define LDBM_UNLOCK (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
void ldbm_initialize( void )
{
@ -383,7 +383,7 @@ void ldbm_initialize( void )
if(initialized++) return;
pthread_mutex_init( &ldbm_big_mutex, pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
}
/*****************************************************************
@ -521,9 +521,9 @@ ldbm_errno( LDBM ldbm )
#elif defined( HAVE_NDBM )
/* GDBM is non-reentrant */
static pthread_mutex_t ldbm_big_mutex;
#define LDBM_LOCK (pthread_mutex_lock(&ldbm_big_mutex))
#define LDBM_UNLOCK (pthread_mutex_unlock(&ldbm_big_mutex))
static ldap_pvt_thread_mutex_t ldbm_big_mutex;
#define LDBM_LOCK (ldap_pvt_thread_mutex_lock(&ldbm_big_mutex))
#define LDBM_UNLOCK (ldap_pvt_thread_mutex_unlock(&ldbm_big_mutex))
void ldbm_initialize( void )
{
@ -531,7 +531,7 @@ void ldbm_initialize( void )
if(initialized++) return;
pthread_mutex_init( &ldbm_big_mutex, pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &ldbm_big_mutex );
}
/*****************************************************************

8
libraries/liblthread/Makefile.in
View file

@ -4,8 +4,12 @@
LIBRARY = liblthread.a
XSRCS = version.c
SRCS = rdwr.c thread.c stack.c
OBJS = rdwr.o thread.o stack.o
SRCS = rdwr.c thr_sleep.c thr_stub.c \
thr_cthreads.c thr_lwp.c thr_nt.c thr_posix.c thr_thr.c
OBJS = rdwr.o thr_sleep.o thr_stub.o \
thr_cthreads.o thr_lwp.o thr_nt.o thr_posix.o thr_thr.o
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries

96
libraries/liblthread/rdwr.c
View file

@ -18,70 +18,81 @@
* Library of functions implementing reader/writer locks
*/
#include <portable.h>
#include "portable.h"
#include <stdlib.h>
#include <lthread.h>
#include <lthread_rdwr.h>
int pthread_rdwr_init_np(pthread_rdwr_t *rdwrp, pthread_rdwrattr_t *attrp)
#include "ldap_pvt_thread.h"
int
ldap_pvt_thread_rdwr_init(ldap_pvt_thread_rdwr_t *rdwrp )
{
rdwrp->readers_reading = 0;
rdwrp->writer_writing = 0;
pthread_mutex_init(&(rdwrp->mutex), pthread_mutexattr_default);
pthread_cond_init(&(rdwrp->lock_free), pthread_condattr_default);
rdwrp->lt_readers_reading = 0;
rdwrp->lt_writer_writing = 0;
ldap_pvt_thread_mutex_init(&(rdwrp->lt_mutex) );
ldap_pvt_thread_cond_init(&(rdwrp->lt_lock_free) );
return 0;
}
int pthread_rdwr_rlock_np(pthread_rdwr_t *rdwrp){
pthread_mutex_lock(&(rdwrp->mutex));
while(rdwrp->writer_writing) {
pthread_cond_wait(&(rdwrp->lock_free), &(rdwrp->mutex));
int
ldap_pvt_thread_rdwr_destroy(ldap_pvt_thread_rdwr_t *rdwrp )
{
ldap_pvt_thread_mutex_destroy(&(rdwrp->lt_mutex) );
ldap_pvt_thread_cond_destroy(&(rdwrp->lt_lock_free) );
return 0;
}
int ldap_pvt_thread_rdwr_rlock(ldap_pvt_thread_rdwr_t *rdwrp){
ldap_pvt_thread_mutex_lock(&(rdwrp->lt_mutex));
while(rdwrp->lt_writer_writing) {
ldap_pvt_thread_cond_wait(&(rdwrp->lt_lock_free),
&(rdwrp->lt_mutex));
}
rdwrp->readers_reading++;
pthread_mutex_unlock(&(rdwrp->mutex));
rdwrp->lt_readers_reading++;
ldap_pvt_thread_mutex_unlock(&(rdwrp->lt_mutex));
return 0;
}
int pthread_rdwr_runlock_np(pthread_rdwr_t *rdwrp)
int ldap_pvt_thread_rdwr_runlock(ldap_pvt_thread_rdwr_t *rdwrp)
{
pthread_mutex_lock(&(rdwrp->mutex));
if (rdwrp->readers_reading == 0) {
pthread_mutex_unlock(&(rdwrp->mutex));
ldap_pvt_thread_mutex_lock(&(rdwrp->lt_mutex));
if (rdwrp->lt_readers_reading == 0) {
ldap_pvt_thread_mutex_unlock(&(rdwrp->lt_mutex));
return -1;
}
else {
rdwrp->readers_reading--;
if (rdwrp->readers_reading == 0) {
pthread_cond_signal(&(rdwrp->lock_free));
rdwrp->lt_readers_reading--;
if (rdwrp->lt_readers_reading == 0) {
ldap_pvt_thread_cond_signal(&(rdwrp->lt_lock_free));
}
pthread_mutex_unlock(&(rdwrp->mutex));
ldap_pvt_thread_mutex_unlock(&(rdwrp->lt_mutex));
return 0;
}
}
int pthread_rdwr_wlock_np(pthread_rdwr_t *rdwrp)
int ldap_pvt_thread_rdwr_wlock(ldap_pvt_thread_rdwr_t *rdwrp)
{
pthread_mutex_lock(&(rdwrp->mutex));
while(rdwrp->writer_writing || rdwrp->readers_reading) {
pthread_cond_wait(&(rdwrp->lock_free), &(rdwrp->mutex));
ldap_pvt_thread_mutex_lock(&(rdwrp->lt_mutex));
while(rdwrp->lt_writer_writing || rdwrp->lt_readers_reading) {
ldap_pvt_thread_cond_wait(&(rdwrp->lt_lock_free),
&(rdwrp->lt_mutex));
}
rdwrp->writer_writing++;
pthread_mutex_unlock(&(rdwrp->mutex));
rdwrp->lt_writer_writing++;
ldap_pvt_thread_mutex_unlock(&(rdwrp->lt_mutex));
return 0;
}
int pthread_rdwr_wunlock_np(pthread_rdwr_t *rdwrp)
int ldap_pvt_thread_rdwr_wunlock(ldap_pvt_thread_rdwr_t *rdwrp)
{
pthread_mutex_lock(&(rdwrp->mutex));
if (rdwrp->writer_writing == 0) {
pthread_mutex_unlock(&(rdwrp->mutex));
ldap_pvt_thread_mutex_lock(&(rdwrp->lt_mutex));
if (rdwrp->lt_writer_writing == 0) {
ldap_pvt_thread_mutex_unlock(&(rdwrp->lt_mutex));
return -1;
}
else {
rdwrp->writer_writing = 0;
pthread_cond_broadcast(&(rdwrp->lock_free));
pthread_mutex_unlock(&(rdwrp->mutex));
rdwrp->lt_writer_writing = 0;
ldap_pvt_thread_cond_broadcast(&(rdwrp->lt_lock_free));
ldap_pvt_thread_mutex_unlock(&(rdwrp->lt_mutex));
return 0;
}
}
@ -89,7 +100,7 @@ int pthread_rdwr_wunlock_np(pthread_rdwr_t *rdwrp)
#ifdef LDAP_DEBUG
/* just for testing,
* return 0 if false, suitable for assert(pthread_rdwr_Xchk(rdwr))
* return 0 if false, suitable for assert(ldap_pvt_thread_rdwr_Xchk(rdwr))
*
* Currently they don't check if the calling thread is the one
* that has the lock, just that there is a reader or writer.
@ -98,18 +109,19 @@ int pthread_rdwr_wunlock_np(pthread_rdwr_t *rdwrp)
* a lock are caught.
*/
int pthread_rdwr_rchk_np(pthread_rdwr_t *rdwrp)
int ldap_pvt_thread_rdwr_rchk(ldap_pvt_thread_rdwr_t *rdwrp)
{
return(rdwrp->readers_reading!=0);
return(rdwrp->lt_readers_reading!=0);
}
int pthread_rdwr_wchk_np(pthread_rdwr_t *rdwrp)
int ldap_pvt_thread_rdwr_wchk(ldap_pvt_thread_rdwr_t *rdwrp)
{
return(rdwrp->writer_writing!=0);
return(rdwrp->lt_writer_writing!=0);
}
int pthread_rdwr_rwchk_np(pthread_rdwr_t *rdwrp)
int ldap_pvt_thread_rdwr_rwchk(ldap_pvt_thread_rdwr_t *rdwrp)
{
return(pthread_rdwr_rchk_np(rdwrp) || pthread_rdwr_wchk_np(rdwrp));
return(ldap_pvt_thread_rdwr_rchk(rdwrp) ||
ldap_pvt_thread_rdwr_wchk(rdwrp));
}
#endif /* LDAP_DEBUG */

75
libraries/liblthread/stack.c
View file

@ -1,75 +0,0 @@
/* stack.c - stack handling routines */
#include "portable.h"
#if defined( HAVE_LWP )
#include <stdio.h>
#include <ac/time.h>
#include <ac/socket.h>
#include "lber.h"
#include "ldap.h"
#include <lwp/lwp.h>
#include <lwp/stackdep.h>
#define MAX_STACK 51200
#define MAX_THREADS 20
struct stackinfo {
int stk_inuse;
stkalign_t *stk_stack;
};
static struct stackinfo *stacks;
stkalign_t *
get_stack( int *stacknop )
{
int i;
if ( stacks == NULL ) {
stacks = (struct stackinfo *) ch_calloc( 1, MAX_THREADS *
sizeof(struct stackinfo) );
}
for ( i = 0; i < MAX_THREADS; i++ ) {
if ( stacks[i].stk_inuse == 0 ) {
break;
}
}
if ( i == MAX_THREADS ) {
Debug( LDAP_DEBUG_ANY,
"no more stacks (max %d) - increase MAX_THREADS for more",
MAX_THREADS, 0, 0 );
return( NULL );
}
if ( stacks[i].stk_stack == NULL ) {
stacks[i].stk_stack = (stkalign_t *) malloc(
(MAX_STACK / sizeof(stkalign_t) + 1 )
* sizeof(stkalign_t) );
}
*stacknop = i;
stacks[i].stk_inuse = 1;
return( stacks[i].stk_stack + MAX_STACK / sizeof(stkalign_t) );
}
void
free_stack(
int stackno
)
{
if ( stackno < 0 || stackno > MAX_THREADS ) {
Debug( LDAP_DEBUG_ANY, "free_stack of bogus stack %d",
stackno, 0, 0 );
}
stacks[stackno].stk_inuse = 0;
}
#endif

142
libraries/liblthread/thr_cthreads.c Normal file
View file

@ -0,0 +1,142 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
/* thr_cthreads.c - wrapper for mach cthreads */
#include "portable.h"
#include "ldap_pvt_thread.h"
#if defined( HAVE_MACH_CTHREADS )
/***********************************************************************
* *
* under NEXTSTEP or OPENSTEP use CThreads *
* lukeh@xedoc.com.au *
* *
***********************************************************************/
int
ldap_pvt_thread_initialize( void )
{
return 0;
}
int
ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void *), void *arg)
{
*thread = cthread_fork( (cthread_fn_t) start_routine, arg);
return ( *thread == NULL ? -1 : 0 );
}
void
ldap_pvt_thread_exit( void *retval )
{
cthread_exit( (any_t) retval );
}
int
ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
{
void *status;
status = (void *) cthread_join ( tid );
if (thread_return != NULL)
{
*thread_return = status;
}
return 0;
}
int
ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
{
return 0;
}
int
ldap_pvt_thread_yield( void )
{
cthread_yield();
return 0;
}
int
ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
{
condition_init( cond );
return( 0 );
}
int
ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cond )
{
condition_clear( cond );
return( 0 );
}
int
ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
{
condition_signal( cond );
return( 0 );
}
int
ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
{
condition_broadcast( cond );
return( 0 );
}
int
ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex )
{
condition_wait( cond, mutex );
return( 0 );
}
int
ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
{
mutex_init( mutex );
mutex->name = NULL;
return ( 0 );
}
int
ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
{
mutex_clear( mutex );
return ( 0 );
}
int
ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
{
mutex_lock( mutex );
return ( 0 );
}
int
ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
{
mutex_unlock( mutex );
return ( 0 );
}
int
ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mutex )
{
return mutex_try_lock( mutex );
}
#endif /* HAVE_MACH_CTHREADS */

238
libraries/liblthread/thr_lwp.c Normal file
View file

@ -0,0 +1,238 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
/* thr_lwp.c - wrappers around SunOS LWP threads */
/* BUGS:
* - slurpd calls the get_stack/free_stack functions. Should be fixed, so
* they can become static.
*/
#include "portable.h"
#include "ldap_pvt_thread.h"
#if defined( HAVE_LWP )
/*************
* *
* SunOS LWP *
* *
*************/
#include <stdio.h>
#include <ac/time.h>
#include <ac/socket.h>
#include "lber.h"
#include "ldap.h"
#include "ldap_log.h"
#include <lwp/lwp.h>
#include <lwp/stackdep.h>
#define MAX_STACK 51200
#define MAX_THREADS 20
/*
* Initialize LWP by spinning of a schedular
*/
int
ldap_pvt_thread_initialize( void )
{
thread_t tid;
stkalign_t *stack;
int stackno;
if (( stack = get_stack( &stackno )) == NULL ) {
return -1;
}
lwp_create( &tid, lwp_scheduler, MINPRIO, 0, stack, 1, stackno );
return 0;
}
struct stackinfo {
int stk_inuse;
stkalign_t *stk_stack;
};
static struct stackinfo *stacks;
stkalign_t * ldap_pvt_thread_get_stack( int *stacknop )
{
int i;
if ( stacks == NULL ) {
stacks = (struct stackinfo *) ch_calloc( 1, MAX_THREADS *
sizeof(struct stackinfo) );
}
for ( i = 0; i < MAX_THREADS; i++ ) {
if ( stacks[i].stk_inuse == 0 ) {
break;
}
}
if ( i == MAX_THREADS ) {
Debug( LDAP_DEBUG_ANY,
"no more stacks (max %d) - increase MAX_THREADS for more",
MAX_THREADS, 0, 0 );
return( NULL );
}
if ( stacks[i].stk_stack == NULL ) {
stacks[i].stk_stack = (stkalign_t *) malloc(
(MAX_STACK / sizeof(stkalign_t) + 1 )
* sizeof(stkalign_t) );
}
*stacknop = i;
stacks[i].stk_inuse = 1;
return( stacks[i].stk_stack + MAX_STACK / sizeof(stkalign_t) );
}
void
ldap_pvt_thread_free_stack( int stackno )
{
if ( stackno < 0 || stackno > MAX_THREADS ) {
Debug( LDAP_DEBUG_ANY, "free_stack of bogus stack %d",
stackno, 0, 0 );
}
stacks[stackno].stk_inuse = 0;
}
static void
lwp_create_stack( void *(*func)(), void *arg, int stackno )
{
(*func)( arg );
ldap_pvt_thread_free_stack( stackno );
}
int
ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void *),
void *arg)
{
stkalign_t *stack;
int stackno;
if ( (stack = ldap_pvt_thread_get_stack( &stackno )) == NULL ) {
return( -1 );
}
return( lwp_create( thread, lwp_create_stack, MINPRIO, 0,
stack, 3, start_routine, arg, stackno ) );
}
void
ldap_pvt_thread_exit( void *retval )
{
lwp_destroy( SELF );
}
int
ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
{
lwp_join( thread );
return 0;
}
int
ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
{
return 0;
}
int
ldap_pvt_thread_yield( void )
{
lwp_yield( SELF );
return 0;
}
int
ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
{
/*
* lwp cv_create requires the monitor id be passed in
* when the cv is created, pthreads passes it when the
* condition is waited for. so, we fake the creation
* here and actually do it when the cv is waited for
* later.
*/
cond->lcv_created = 0;
return( 0 );
}
int
ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
{
return( cond->lcv_created ? cv_notify( cv->lcv_cv ) : 0 );
}
int
ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex )
{
if ( ! cond->lcv_created ) {
cv_create( &cond->lcv_cv, *mutex );
cond->lcv_created = 1;
}
return( cv_wait( cond->lcv_cv ) );
}
int
ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
{
return( mon_create( mutex ) );
}
int
ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
{
return( mon_destroy( *mutex ) );
}
int
ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
{
return( mon_enter( *mutex ) );
}
int
ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
{
return( mon_exit( *mutex ) );
}
int
ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mp )
{
return( mon_cond_enter( *mp ) );
}
int
ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cv )
{
return( cv->lcv_created ? cv_destroy( cv->lcv_cv ) : 0 );
}
int
ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cv )
{
return( cv->lcv_created ? cv_broadcast( cv->lcv_cv ) : 0 );
}
#endif /* HAVE_LWP */

142
libraries/liblthread/thr_nt.c Normal file
View file

@ -0,0 +1,142 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
/* thr_nt.c - wrapper around NT threads */
#include "portable.h"
#include "ldap_pvt_thread.h"
#if defined( HAVE_NT_THREADS )
int
ldap_pvt_thread_initialize( void )
{
return 0;
}
int
ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void *),
void *arg)
{
*thread = (ldap_pvt_thread_t)_beginthread( (void *) start_routine,
0, arg );
return ( (unsigned long)*thread == -1 ? -1 : 0 );
}
void
ldap_pvt_thread_exit( void *retval )
{
_endthread( );
}
int
ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
{
DWORD status;
status = WaitForSingleObject( thread, INFINITE );
if (status == WAIT_FAILED) {
return -1;
}
return 0;
}
int
ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
{
return 0;
}
int
ldap_pvt_thread_yield( void )
{
return 0;
}
int
ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
{
*cond = CreateEvent( NULL, FALSE, FALSE, NULL );
return( 0 );
}
int
ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cv )
{
CloseHandle( *cv );
return( 0 );
}
int
ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
{
SetEvent( *cond );
return( 0 );
}
int
ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex )
{
ReleaseMutex( *mutex );
WaitForSingleObject( *cond, INFINITE );
WaitForSingleObject( *mutex, INFINITE );
return( 0 );
}
int
ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cv )
{
SetEvent( *cv );
return( 0 );
}
int
ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
{
*mutex = CreateMutex( NULL, 0, NULL );
return ( 0 );
}
int
ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
{
CloseHandle( *mutex );
return ( 0 );
}
int
ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
{
WaitForSingleObject( *mutex, INFINITE );
return ( 0 );
}
int
ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
{
ReleaseMutex( *mutex );
return ( 0 );
}
int
ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mp )
{
DWORD status;
status = WaitForSingleObject( *mp, 0 );
if ( (status == WAIT_FAILED) || (status == WAIT_TIMEOUT) )
return 0;
else
return 1;
}
#endif

174
libraries/liblthread/thr_posix.c Normal file
View file

@ -0,0 +1,174 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
/* thr_posix.c - wrapper around posix and posixish thread implementations.
*/
#include "portable.h"
#include "ldap_pvt_thread.h"
#if defined( HAVE_PTHREADS )
int
ldap_pvt_thread_initialize( void )
{
#if defined( LDAP_THREAD_CONCURRENCY ) && HAVE_PTHREAD_SETCONCURRENCY
ldap_pvt_thread_setconcurrency( LDAP_THREAD_CONCURRENCY );
#endif
return 0;
}
#ifdef HAVE_PTHREAD_SETCONCURRENCY
int
ldap_pvt_thread_set_concurrency(int n)
{
#ifdef HAVE_PTHREAD_SETCONCURRENCY
return pthread_setconcurrency( n );
#elif HAVE_THR_SETCONCURRENCY
return pthread_setconcurrency( n );
#else
return 0;
#endif
}
#endif
#ifdef HAVE_PTHREAD_GETCONCURRENCY
int
ldap_pvt_thread_get_concurrency(void)
{
#ifdef HAVE_PTHREAD_GETCONCURRENCY
return pthread_getconcurrency();
#elif HAVE_THR_GETCONCURRENCY
return pthread_getconcurrency();
#else
return 0;
#endif
}
#endif
int
ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void * ),
void *arg)
{
int rtn = pthread_create( thread, NULL, start_routine, arg );
if( detach ) {
#ifdef HAVE_PTHREADS_FINAL
pthread_detach( *thread );
#else
pthread_detach( thread );
#endif
}
return rtn;
}
void
ldap_pvt_thread_exit( void *retval )
{
pthread_exit( retval );
}
int
ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
{
#if !defined( HAVE_PTHREADS_FINAL )
void *dummy;
if (thread_return==NULL)
thread_return=&dummy;
#endif
return pthread_join( thread, thread_return );
}
int
ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
{
#ifdef HAVE_PTHREAD_KILL
return pthread_kill( thread, signo );
#else
/* pthread package with DCE */
if (kill( getpid(), sig )<0)
return errno;
return 0;
#endif
}
int
ldap_pvt_thread_yield( void )
{
#ifdef HAVE_SCHED_YIELD
return sched_yield();
#elif HAVE_PTHREAD_YIELD
return pthread_yield();
#elif HAVE_THR_YIELD
return thr_yield();
#else
return 0;
#endif
}
int
ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
{
return pthread_cond_init( cond, NULL );
}
int
ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cond )
{
return pthread_cond_destroy( cond );
}
int
ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
{
return pthread_cond_signal( cond );
}
int
ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
{
return pthread_cond_broadcast( cond );
}
int
ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex )
{
return pthread_cond_wait( cond, mutex );
}
int
ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
{
return pthread_mutex_init( mutex, NULL );
}
int
ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
{
return pthread_mutex_destroy( mutex );
}
int
ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
{
return pthread_mutex_lock( mutex );
}
int
ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
{
return pthread_mutex_unlock( mutex );
}
#endif /* HAVE_PTHREADS */

151
libraries/liblthread/thr_sleep.c Normal file
View file

@ -0,0 +1,151 @@
/*
* Copyright (c) 1996 Regents of the University of Michigan.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that this notice is preserved and that due credit is given
* to the University of Michigan at Ann Arbor. The name of the University
* may not be used to endorse or promote products derived from this
* software without specific prior written permission. This software
* is provided ``as is'' without express or implied warranty.
*/
/*
* ldap_pvt_thread_sleep.c - allow a thread to sleep without putting
* the whole process (e.g. pod under lwp) to sleep.
*
* Contains platform-specific code to allow this:
*
* Under non-preemptive threads packages like SunOS lwp, tsleep() adds
* the thread to a list of sleepers. The lwp_scheduler process takes
* care of resuming suspended threads.
*
* Under a fully-preemptive threads package, like Solaris threads,
* tsleep just calls sleep(), and there is no scheduler thread. Life
* is so much simpler...
*/
#include "portable.h"
#include <stdio.h>
#include <stdlib.h>
#include <ac/unistd.h> /* get sleep() */
#if !defined( HAVE_LWP )
/*
* Here we assume we have fully preemptive threads and that sleep()
* does the right thing.
*/
unsigned int
ldap_pvt_thread_sleep(
unsigned int interval
)
{
sleep( interval );
return 0;
}
#else
unsigned int
ldap_pvt_thread_sleep(
unsigned int interval
)
{
thread_t mylwp;
tl_t *t, *nt;
time_t now;
if ( lwp_self( &mylwp ) < 0 ) {
return -1;
}
time( &now );
mon_enter( &sglob->tsl_mon );
if ( sglob->tsl_list != NULL ) {
for ( t = sglob->tsl_list; t != NULL; t = t->tl_next ) {
if ( SAMETHREAD( t->tl_tid, mylwp )) {
/* We're already sleeping? */
t->tl_wake = now + interval;
mon_exit( &sglob->tsl_mon );
lwp_suspend( mylwp );
return 0;
}
}
}
nt = (tl_t *) malloc( sizeof( tl_t ));
nt->tl_next = sglob->tsl_list;
nt->tl_wake = now + interval;
nt->tl_tid = mylwp;
sglob->tsl_list = nt;
mon_exit( &sglob->tsl_mon );
lwp_suspend( mylwp );
return 0;
}
/*
* The lwp_scheduler thread periodically checks to see if any threads
* are due to be resumed. If there are, it resumes them. Otherwise,
* it computes the lesser of ( 1 second ) or ( the minimum time until
* a thread need to be resumed ) and puts itself to sleep for that amount
* of time.
*/
void
lwp_scheduler(
int stackno
)
{
time_t now, min;
struct timeval interval;
tl_t *t;
while ( !sglob->slurpd_shutdown ) {
mon_enter( &sglob->tsl_mon );
time( &now );
min = 0L;
if ( sglob->tsl_list != NULL ) {
for ( t = sglob->tsl_list; t != NULL; t = t->tl_next ) {
if (( t->tl_wake > 0L ) && ( t->tl_wake < now )) {
lwp_resume( t->tl_tid );
t->tl_wake = 0L;
}
if (( t->tl_wake > now ) && ( t->tl_wake < min )) {
min = t->tl_wake;
}
}
}
mon_exit( &sglob->tsl_mon );
interval.tv_usec = 0L;
if ( min == 0L ) {
interval.tv_sec = 1L;
} else {
interval.tv_sec = min;
}
lwp_sleep( &interval );
}
mon_enter( &sglob->tsl_mon );
for ( t = sglob->tsl_list; t != NULL; t = t->tl_next ) {
lwp_resume( t->tl_tid );
}
mon_exit( &sglob->tsl_mon );
free_stack( stackno );
}
#endif /* HAVE_LWP */

127
libraries/liblthread/thr_stub.c Normal file
View file

@ -0,0 +1,127 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
/* thr_stub.c - stubs for the threads */
#include "portable.h"
#include "ldap_pvt_thread.h"
#if defined( NO_THREADS )
/***********************************************************************
* *
* no threads package defined for this system - fake ok returns from *
* all threads routines (making it single-threaded). *
* *
***********************************************************************/
int
ldap_pvt_thread_initialize( void )
{
return 0;
}
static void* ldap_int_status = NULL;
int
ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)(void *),
void *arg)
{
if( ! detach ) ldap_int_status = NULL;
start_routine( arg );
return 0;
}
void
ldap_pvt_thread_exit( void *retval )
{
if( retval != NULL ) {
ldap_int_status = retval;
}
return;
}
int
ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **status )
{
if(status != NULL) *status = ldap_int_status;
return 0;
}
int
ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
{
return 0;
}
int
ldap_pvt_thread_yield( void )
{
return 0;
}
int
ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
{
return 0;
}
int
ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cond )
{
return 0;
}
int
ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
{
return 0;
}
int
ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
{
return 0;
}
int
ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex )
{
return 0;
}
int
ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
{
return 0;
}
int
ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
{
return 0;
}
int
ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
{
return 0;
}
int
ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
{
return 0;
}
#endif /* NO_THREADS */

143
libraries/liblthread/thr_thr.c Normal file
View file

@ -0,0 +1,143 @@
/*
* Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted only
* as authorized by the OpenLDAP Public License. A copy of this
* license is available at http://www.OpenLDAP.org/license.html or
* in file LICENSE in the top-level directory of the distribution.
*/
/* thr_thr.c - wrappers around solaris threads */
#include "portable.h"
#include "ldap_pvt_thread.h"
#if defined( HAVE_THR )
/*******************
* *
* Solaris Threads *
* *
*******************/
int
ldap_pvt_thread_initialize( void )
{
#ifdef LDAP_THREAD_CONCURRENCY
thr_setconcurrency( LDAP_THREAD_CONCURRENCY );
#endif
return 0;
}
int
ldap_pvt_thread_set_concurrency(int n)
{
return thr_setconcurrency( n );
}
int
ldap_pvt_thread_get_concurrency(void)
{
return thr_getconcurrency();
}
int
ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
int detach,
void *(*start_routine)( void *),
void *arg)
{
return( thr_create( NULL, 0, start_routine, arg,
detach ? THR_DETACHED : 0,
thread ) );
}
void
ldap_pvt_thread_exit( void *retval )
{
thr_exit( NULL );
}
int ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
{
thr_join( thread, NULL, thread_return );
return 0;
}
int
ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
{
thr_kill( thread, signo );
return 0;
}
int
ldap_pvt_thread_yield( void )
{
thr_yield();
return 0;
}
int
ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond )
{
return( cond_init( cond, USYNC_THREAD, NULL ) );
}
int
ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
{
return( cond_signal( cond ) );
}
int
ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cv )
{
return( cond_broadcast( cv ) );
}
int
ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond,
ldap_pvt_thread_mutex_t *mutex )
{
return( cond_wait( cond, mutex ) );
}
int
ldap_pvt_thread_cond_destroy( ldap_pvt_thread_cond_t *cv )
{
return( cond_destroy( cv ) );
}
int
ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex )
{
return( mutex_init( mutex, USYNC_THREAD, NULL ) );
}
int
ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
{
return( mutex_destroy( mutex ) );
}
int
ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
{
return( mutex_lock( mutex ) );
}
int
ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
{
return( mutex_unlock( mutex ) );
}
int
ldap_pvt_thread_mutex_trylock( ldap_pvt_thread_mutex_t *mp )
{
return( mutex_trylock( mp ) );
}
#endif /* HAVE_THR */

634
libraries/liblthread/thread.c
View file

@ -1,634 +0,0 @@
/* thread.c - glue routines to provide a consistent thread interface */
#include "portable.h"
#include <lthread.h>
#if defined( HAVE_PTHREADS )
#ifndef HAVE_PTHREAD_KILL
/*
* Some pthreads packages (ie: DCE) don't have pthread_kill()
* pthread_kill() routine)
*
*/
/* ARGSUSED */
void
pthread_kill( pthread_t tid, int sig )
{
kill( getpid(), sig );
}
#endif /* HAVE_PTHREAD_KILL */
#if !defined(HAVE_SCHED_YIELD) && !defined(HAVE_PTHREAD_YIELD)
/*
* Some pthreads packages don't have sched_yield() nor
* the draft4 pthread_kill() routine, assume it's not
* needed.
*/
void
pthread_yield( void )
{
/* assume pthread implementation is preemptive */
}
#endif /* missing sched_yield() */
#elif defined( HAVE_MACH_CTHREADS )
/***********************************************************************
* *
* under NEXTSTEP or OPENSTEP use CThreads *
* lukeh@xedoc.com.au *
* *
***********************************************************************/
int
pthread_attr_init( pthread_attr_t *attr )
{
*attr = 0;
return( 0 );
}
int
pthread_attr_destroy( pthread_attr_t *attr )
{
return( 0 );
}
int
pthread_attr_getdetachstate( pthread_attr_t *attr, int *detachstate )
{
*detachstate = *attr;
return( 0 );
}
int
pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate )
{
*attr = detachstate;
return( 0 );
}
/* ARGSUSED */
int
pthread_create(
pthread_t *tid,
pthread_attr_t *attr,
VFP func,
void *arg
)
{
*tid = cthread_fork(func, arg);
return ( *tid == NULL ? -1 : 0 );
}
void
pthread_yield( void )
{
cthread_yield();
}
void
pthread_exit( any_t a )
{
cthread_exit( a );
}
void
pthread_join( pthread_t tid, int *pStatus )
{
int status;
status = (int) cthread_join ( tid );
if (pStatus != NULL)
{
*pStatus = status;
}
}
/* ARGSUSED */
void
pthread_kill( pthread_t tid, int sig )
{
return;
}
/* ARGSUSED */
int
pthread_mutex_init( pthread_mutex_t *mp, pthread_mutexattr_t *attr )
{
mutex_init( mp );
mp->name = NULL;
return ( 0 );
}
int
pthread_mutex_destroy( pthread_mutex_t *mp )
{
mutex_clear( mp );
return ( 0 );
}
int
pthread_mutex_lock( pthread_mutex_t *mp )
{
mutex_lock( mp );
return ( 0 );
}
int
pthread_mutex_unlock( pthread_mutex_t *mp )
{
mutex_unlock( mp );
return ( 0 );
}
int
pthread_mutex_trylock( pthread_mutex_t *mp )
{
return mutex_try_lock( mp );
}
int
pthread_cond_init( pthread_cond_t *cv, pthread_condattr_t *attr )
{
condition_init( cv );
return( 0 );
}
int
pthread_cond_destroy( pthread_cond_t *cv )
{
condition_clear( cv );
return( 0 );
}
int
pthread_cond_wait( pthread_cond_t *cv, pthread_mutex_t *mp )
{
condition_wait( cv, mp );
return( 0 );
}
int
pthread_cond_signal( pthread_cond_t *cv )
{
condition_signal( cv );
return( 0 );
}
int
pthread_cond_broadcast( pthread_cond_t *cv )
{
condition_broadcast( cv );
return( 0 );
}
#elif defined( HAVE_THR )
/*******************
* *
* Solaris Threads *
* *
*******************/
#if !defined(__SunOS_5_6)
int
pthread_attr_init( pthread_attr_t *attr )
{
*attr = 0;
return( 0 );
}
int
pthread_attr_destroy( pthread_attr_t *attr )
{
*attr = 0;
return( 0 );
}
int
pthread_attr_getdetachstate( pthread_attr_t *attr, int *detachstate )
{
*detachstate = *attr;
return( 0 );
}
int
pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate )
{
*attr = detachstate;
return( 0 );
}
/* ARGSUSED */
int
pthread_create(
pthread_t *tid,
pthread_attr_t *attr,
VFP func,
void *arg
)
{
return( thr_create( NULL, 0, func, arg, *attr, tid ) );
}
#endif /* ! sunos56 */
void
pthread_yield( void )
{
thr_yield();
}
#if !defined(__SunOS_5_6)
void
pthread_exit()
{
thr_exit( NULL );
}
void
pthread_join( pthread_t tid, int *status )
{
thr_join( tid, NULL, (void **) status );
}
void
pthread_kill( pthread_t tid, int sig )
{
thr_kill( tid, sig );
}
/* ARGSUSED */
int
pthread_mutex_init( pthread_mutex_t *mp, pthread_mutexattr_t *attr )
{
return( mutex_init( mp, attr ? *attr : USYNC_THREAD, NULL ) );
}
int
pthread_mutex_destroy( pthread_mutex_t *mp )
{
return( mutex_destroy( mp ) );
}
int
pthread_mutex_lock( pthread_mutex_t *mp )
{
return( mutex_lock( mp ) );
}
int
pthread_mutex_unlock( pthread_mutex_t *mp )
{
return( mutex_unlock( mp ) );
}
int
pthread_mutex_trylock( pthread_mutex_t *mp )
{
return( mutex_trylock( mp ) );
}
int
pthread_cond_init( pthread_cond_t *cv, pthread_condattr_t *attr )
{
return( cond_init( cv, attr ? *attr : USYNC_THREAD, NULL ) );
}
int
pthread_cond_destroy( pthread_cond_t *cv )
{
return( cond_destroy( cv ) );
}
int
pthread_cond_wait( pthread_cond_t *cv, pthread_mutex_t *mp )
{
return( cond_wait( cv, mp ) );
}
int
pthread_cond_signal( pthread_cond_t *cv )
{
return( cond_signal( cv ) );
}
int
pthread_cond_broadcast( pthread_cond_t *cv )
{
return( cond_broadcast( cv ) );
}
#endif /* ! sunos56 */
#elif defined( HAVE_LWP )
/*************
* *
* SunOS LWP *
* *
*************/
int
pthread_attr_init( pthread_attr_t *attr )
{
*attr = 0;
return( 0 );
}
int
pthread_attr_destroy( pthread_attr_t *attr )
{
return( 0 );
}
int
pthread_attr_getdetachstate( pthread_attr_t *attr, int *detachstate )
{
*detachstate = *attr;
return( 0 );
}
int
pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate )
{
*attr = detachstate;
return( 0 );
}
static void
lwp_create_stack( VFP func, void *arg, int stackno )
{
(*func)( arg );
free_stack( stackno );
}
/* ARGSUSED */
int
pthread_create(
pthread_t *tid,
pthread_attr_t *attr,
VFP func,
void *arg
)
{
stkalign_t *stack;
int stackno;
if ( (stack = get_stack( &stackno )) == NULL ) {
return( -1 );
}
return( lwp_create( tid, lwp_create_stack, MINPRIO, 0, stack, 3, func,
arg, stackno ) );
}
void
pthread_yield( void )
{
lwp_yield( SELF );
}
void
pthread_exit()
{
lwp_destroy( SELF );
}
void
pthread_join( pthread_t tid, int *status )
{
lwp_join( tid );
}
/* ARGSUSED */
void
pthread_kill( pthread_t tid, int sig )
{
return;
}
/* ARGSUSED */
int
pthread_mutex_init( pthread_mutex_t *mp, pthread_mutexattr_t *attr )
{
return( mon_create( mp ) );
}
int
pthread_mutex_destroy( pthread_mutex_t *mp )
{
return( mon_destroy( *mp ) );
}
int
pthread_mutex_lock( pthread_mutex_t *mp )
{
return( mon_enter( *mp ) );
}
int
pthread_mutex_unlock( pthread_mutex_t *mp )
{
return( mon_exit( *mp ) );
}
int
pthread_mutex_trylock( pthread_mutex_t *mp )
{
return( mon_cond_enter( *mp ) );
}
int
pthread_cond_init( pthread_cond_t *cv, pthread_condattr_t *attr )
{
/*
* lwp cv_create requires the monitor id be passed in
* when the cv is created, pthreads passes it when the
* condition is waited for. so, we fake the creation
* here and actually do it when the cv is waited for
* later.
*/
cv->lcv_created = 0;
return( 0 );
}
int
pthread_cond_destroy( pthread_cond_t *cv )
{
return( cv->lcv_created ? cv_destroy( cv->lcv_cv ) : 0 );
}
int
pthread_cond_wait( pthread_cond_t *cv, pthread_mutex_t *mp )
{
if ( ! cv->lcv_created ) {
cv_create( &cv->lcv_cv, *mp );
cv->lcv_created = 1;
}
return( cv_wait( cv->lcv_cv ) );
}
int
pthread_cond_signal( pthread_cond_t *cv )
{
return( cv->lcv_created ? cv_notify( cv->lcv_cv ) : 0 );
}
int
pthread_cond_broadcast( pthread_cond_t *cv )
{
return( cv->lcv_created ? cv_broadcast( cv->lcv_cv ) : 0 );
}
#else
/***********************************************************************
* *
* no threads package defined for this system - fake ok returns from *
* all threads routines (making it single-threaded). *
* *
***********************************************************************/
/* ARGSUSED */
int
pthread_attr_init( pthread_attr_t *attr )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_attr_destroy( pthread_attr_t *attr )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_attr_getdetachstate( pthread_attr_t *attr, int *detachstate )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_create(
pthread_t *tid,
pthread_attr_t *attr,
VFP func,
void *arg
)
{
(*func)( arg );
return( 0 );
}
void
pthread_yield( void )
{
return;
}
void
pthread_exit()
{
return;
}
/* ARGSUSED */
void
pthread_kill( pthread_t tid, int sig )
{
return;
}
void
pthread_join( pthread_t tid, int *status )
{
return;
}
/* ARGSUSED */
int
pthread_mutex_init( pthread_mutex_t *mp, pthread_mutexattr_t *attr )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_mutex_destroy( pthread_mutex_t *mp )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_mutex_lock( pthread_mutex_t *mp )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_mutex_unlock( pthread_mutex_t *mp )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_mutex_trylock( pthread_mutex_t *mp )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_cond_init( pthread_cond_t *cv, pthread_condattr_t *attr )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_cond_destroy( pthread_cond_t *cv )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_cond_wait( pthread_cond_t *cv, pthread_mutex_t *mp )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_cond_signal( pthread_cond_t *cv )
{
return( 0 );
}
/* ARGSUSED */
int
pthread_cond_broadcast( pthread_cond_t *cv )
{
return( 0 );
}
#endif /* no threads package */

8
servers/slapd/abandon.c
View file

@ -50,19 +50,19 @@ do_abandon(
* flag and abort the operation at a convenient time.
*/
pthread_mutex_lock( &conn->c_opsmutex );
ldap_pvt_thread_mutex_lock( &conn->c_opsmutex );
for ( o = conn->c_ops; o != NULL; o = o->o_next ) {
if ( o->o_msgid == id )
break;
}
if ( o != NULL ) {
pthread_mutex_lock( &o->o_abandonmutex );
ldap_pvt_thread_mutex_lock( &o->o_abandonmutex );
o->o_abandon = 1;
pthread_mutex_unlock( &o->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &o->o_abandonmutex );
} else {
Debug( LDAP_DEBUG_TRACE, "do_abandon: op not found\n", 0, 0,
0 );
}
pthread_mutex_unlock( &conn->c_opsmutex );
ldap_pvt_thread_mutex_unlock( &conn->c_opsmutex );
}

4
servers/slapd/add.c
View file

@ -181,7 +181,7 @@ add_created_attrs( Operation *op, Entry *e )
}
attr_merge( e, "creatorsname", bvals );
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
#ifndef LDAP_LOCALTIME
ltm = gmtime( &currenttime );
strftime( buf, sizeof(buf), "%Y%m%d%H%M%SZ", ltm );
@ -189,7 +189,7 @@ add_created_attrs( Operation *op, Entry *e )
ltm = localtime( &currenttime );
strftime( buf, sizeof(buf), "%y%m%d%H%M%SZ", ltm );
#endif
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
bv.bv_val = buf;
bv.bv_len = strlen( bv.bv_val );

22
servers/slapd/back-ldbm/add.c
View file

@ -28,17 +28,17 @@ ldbm_back_add(
Debug(LDAP_DEBUG_ARGS, "==> ldbm_back_add: %s\n", e->e_dn, 0, 0);
/* nobody else can add until we lock our parent */
pthread_mutex_lock(&li->li_add_mutex);
ldap_pvt_thread_mutex_lock(&li->li_add_mutex);
if ( ( dn2id( be, e->e_ndn ) ) != NOID ) {
pthread_mutex_unlock(&li->li_add_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
entry_free( e );
send_ldap_result( conn, op, LDAP_ALREADY_EXISTS, "", "" );
return( -1 );
}
if ( global_schemacheck && oc_schema_check( e ) != 0 ) {
pthread_mutex_unlock(&li->li_add_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
Debug( LDAP_DEBUG_TRACE, "entry failed schema check\n",
0, 0, 0 );
@ -60,7 +60,7 @@ ldbm_back_add(
/* get parent with writer lock */
if ( (p = dn2entry_w( be, pdn, &matched )) == NULL ) {
pthread_mutex_unlock(&li->li_add_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
Debug( LDAP_DEBUG_TRACE, "parent does not exist\n", 0,
0, 0 );
send_ldap_result( conn, op, LDAP_NO_SUCH_OBJECT,
@ -76,7 +76,7 @@ ldbm_back_add(
}
/* don't need the add lock anymore */
pthread_mutex_unlock(&li->li_add_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
free(pdn);
@ -102,7 +102,7 @@ ldbm_back_add(
} else {
/* no parent, must be adding entry to root */
if ( ! be_isroot( be, op->o_ndn ) ) {
pthread_mutex_unlock(&li->li_add_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
Debug( LDAP_DEBUG_TRACE, "no parent & not root\n", 0,
0, 0 );
send_ldap_result( conn, op, LDAP_INSUFFICIENT_ACCESS,
@ -116,9 +116,9 @@ ldbm_back_add(
* no parent, acquire the root write lock
* and release the add lock.
*/
pthread_mutex_lock(&li->li_root_mutex);
ldap_pvt_thread_mutex_lock(&li->li_root_mutex);
rootlock = 1;
pthread_mutex_unlock(&li->li_add_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_add_mutex);
}
/* acquire required reader/writer lock */
@ -130,7 +130,7 @@ ldbm_back_add(
if ( rootlock ) {
/* release root lock */
pthread_mutex_unlock(&li->li_root_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
}
Debug( LDAP_DEBUG_ANY, "add: could not lock entry\n",
@ -156,7 +156,7 @@ ldbm_back_add(
}
if ( rootlock ) {
/* release root lock */
pthread_mutex_unlock(&li->li_root_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
}
Debug( LDAP_DEBUG_ANY, "cache_add_entry_lock failed\n", 0, 0,
@ -226,7 +226,7 @@ return_results:;
if ( rootlock ) {
/* release root lock */
pthread_mutex_unlock(&li->li_root_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
}
cache_set_state( &li->li_cache, e, 0 );

12
servers/slapd/back-ldbm/back-ldbm.h
View file

@ -66,7 +66,7 @@ struct cache {
Avlnode *c_idtree;
Entry *c_lruhead; /* lru - add accessed entries here */
Entry *c_lrutail; /* lru - rem lru entries from here */
pthread_mutex_t c_mutex;
ldap_pvt_thread_mutex_t c_mutex;
};
/* for the cache of open index files */
@ -112,9 +112,9 @@ struct ldbminfo {
ID li_nextid_wrote;
#endif
char *li_nextid_file;
pthread_mutex_t li_root_mutex;
pthread_mutex_t li_add_mutex;
pthread_mutex_t li_nextid_mutex;
ldap_pvt_thread_mutex_t li_root_mutex;
ldap_pvt_thread_mutex_t li_add_mutex;
ldap_pvt_thread_mutex_t li_nextid_mutex;
int li_mode;
char *li_directory;
struct cache li_cache;
@ -122,8 +122,8 @@ struct ldbminfo {
int li_dbcachesize;
int li_dbcachewsync;
struct dbcache li_dbcache[MAXDBCACHE];
pthread_mutex_t li_dbcache_mutex;
pthread_cond_t li_dbcache_cv;
ldap_pvt_thread_mutex_t li_dbcache_mutex;
ldap_pvt_thread_cond_t li_dbcache_cv;
};
#include "proto-back-ldbm.h"

4
servers/slapd/back-ldbm/bind.c
View file

@ -34,7 +34,7 @@ crypted_value_find(
int result;
#ifdef SLAPD_CRYPT
pthread_mutex_lock( &crypt_mutex );
ldap_pvt_thread_mutex_lock( &crypt_mutex );
#endif
result = lutil_passwd(
@ -42,7 +42,7 @@ crypted_value_find(
(char*) vals[i]->bv_val);
#ifdef SLAPD_CRYPT
pthread_mutex_unlock( &crypt_mutex );
ldap_pvt_thread_mutex_unlock( &crypt_mutex );
#endif
return result;

44
servers/slapd/back-ldbm/cache.c
View file

@ -50,26 +50,26 @@ void
cache_set_state( struct cache *cache, Entry *e, int state )
{
/* set cache mutex */
pthread_mutex_lock( &cache->c_mutex );
ldap_pvt_thread_mutex_lock( &cache->c_mutex );
e->e_state = state;
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
}
static void
cache_return_entry( struct cache *cache, Entry *e )
{
/* set cache mutex */
pthread_mutex_lock( &cache->c_mutex );
ldap_pvt_thread_mutex_lock( &cache->c_mutex );
if ( --e->e_refcnt == 0 && e->e_state == ENTRY_STATE_DELETED ) {
entry_free( e );
}
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
}
static void
@ -136,7 +136,7 @@ cache_add_entry_lock(
Entry *ee;
/* set cache mutex */
pthread_mutex_lock( &cache->c_mutex );
ldap_pvt_thread_mutex_lock( &cache->c_mutex );
if ( avl_insert( &cache->c_dntree, (caddr_t) e,
cache_entrydn_cmp, avl_dup_error ) != 0 )
@ -146,7 +146,7 @@ cache_add_entry_lock(
e->e_dn, e->e_id, 0 );
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( 1 );
}
@ -167,7 +167,7 @@ cache_add_entry_lock(
}
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( -1 );
}
@ -202,7 +202,7 @@ cache_add_entry_lock(
/* XXX check for writer lock - should also check no readers pending */
#ifdef LDAP_DEBUG
assert(!pthread_rdwr_rwchk_np(&e->e_rdwr));
assert(!ldap_pvt_thread_rdwr_rwchk(&e->e_rdwr));
#endif
/* delete from cache and lru q */
@ -213,7 +213,7 @@ cache_add_entry_lock(
}
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( 0 );
}
@ -233,7 +233,7 @@ cache_find_entry_dn2id(
ID id;
/* set cache mutex */
pthread_mutex_lock( &cache->c_mutex );
ldap_pvt_thread_mutex_lock( &cache->c_mutex );
e.e_dn = dn;
e.e_ndn = dn_normalize_case( ch_strdup( dn ) );
@ -253,7 +253,7 @@ cache_find_entry_dn2id(
ep->e_state == ENTRY_STATE_CREATING )
{
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( NOID );
}
@ -277,7 +277,7 @@ cache_find_entry_dn2id(
/* free reader lock */
entry_rdwr_unlock(ep, 0);
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( NOID );
}
@ -289,7 +289,7 @@ cache_find_entry_dn2id(
entry_rdwr_unlock(ep, 0);
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
cache_return_entry( &li->li_cache, ep );
@ -299,7 +299,7 @@ cache_find_entry_dn2id(
free(e.e_ndn);
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( NOID );
}
@ -319,7 +319,7 @@ cache_find_entry_id(
Entry *ep;
/* set cache mutex */
pthread_mutex_lock( &cache->c_mutex );
ldap_pvt_thread_mutex_lock( &cache->c_mutex );
e.e_id = id;
@ -337,7 +337,7 @@ cache_find_entry_id(
ep->e_state == ENTRY_STATE_CREATING )
{
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( NULL );
}
/* XXX is this safe without writer lock? */
@ -361,7 +361,7 @@ cache_find_entry_id(
entry_rdwr_unlock(ep, 0);
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( NULL );
}
@ -371,13 +371,13 @@ cache_find_entry_id(
}
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( ep );
}
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( NULL );
}
@ -405,16 +405,16 @@ cache_delete_entry(
/* XXX check for writer lock - should also check no readers pending */
#ifdef LDAP_DEBUG
assert(pthread_rdwr_wchk_np(&e->e_rdwr));
assert(ldap_pvt_thread_rdwr_wchk(&e->e_rdwr));
#endif
/* set cache mutex */
pthread_mutex_lock( &cache->c_mutex );
ldap_pvt_thread_mutex_lock( &cache->c_mutex );
rc = cache_delete_entry_internal( cache, e );
/* free cache mutex */
pthread_mutex_unlock( &cache->c_mutex );
ldap_pvt_thread_mutex_unlock( &cache->c_mutex );
return( rc );
}

30
servers/slapd/back-ldbm/dbcache.c
View file

@ -40,12 +40,12 @@ ldbm_cache_open(
flags, li->li_mode );
lru = 0;
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
curtime = currenttime;
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
oldtime = curtime;
pthread_mutex_lock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_lock( &li->li_dbcache_mutex );
for ( i = 0; i < MAXDBCACHE && li->li_dbcache[i].dbc_name != NULL;
i++ ) {
/* already open - return it */
@ -53,7 +53,7 @@ ldbm_cache_open(
li->li_dbcache[i].dbc_refcnt++;
Debug( LDAP_DEBUG_TRACE,
"<= ldbm_cache_open (cache %d)\n", i, 0, 0 );
pthread_mutex_unlock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_dbcache_mutex );
return( &li->li_dbcache[i] );
}
@ -74,7 +74,7 @@ ldbm_cache_open(
0, 0, 0 );
lru = -1;
while ( lru == -1 ) {
pthread_cond_wait( &li->li_dbcache_cv,
ldap_pvt_thread_cond_wait( &li->li_dbcache_cv,
&li->li_dbcache_mutex );
for ( i = 0; i < MAXDBCACHE; i++ ) {
if ( li->li_dbcache[i].dbc_refcnt
@ -97,7 +97,7 @@ ldbm_cache_open(
"<= ldbm_cache_open NULL \"%s\" errno %d reason \"%s\")\n",
buf, errno, errno > -1 && errno < sys_nerr ?
sys_errlist[errno] : "unknown" );
pthread_mutex_unlock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_dbcache_mutex );
return( NULL );
}
li->li_dbcache[i].dbc_name = ch_strdup( buf );
@ -118,7 +118,7 @@ ldbm_cache_open(
li->li_dbcache[i].dbc_blksize, li->li_dbcache[i].dbc_maxids,
li->li_dbcache[i].dbc_maxindirect );
Debug( LDAP_DEBUG_TRACE, "<= ldbm_cache_open (opened %d)\n", i, 0, 0 );
pthread_mutex_unlock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_dbcache_mutex );
return( &li->li_dbcache[i] );
}
@ -127,11 +127,11 @@ ldbm_cache_close( Backend *be, struct dbcache *db )
{
struct ldbminfo *li = (struct ldbminfo *) be->be_private;
pthread_mutex_lock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_lock( &li->li_dbcache_mutex );
if ( --db->dbc_refcnt == 0 ) {
pthread_cond_signal( &li->li_dbcache_cv );
ldap_pvt_thread_cond_signal( &li->li_dbcache_cv );
}
pthread_mutex_unlock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_dbcache_mutex );
}
void
@ -139,14 +139,14 @@ ldbm_cache_really_close( Backend *be, struct dbcache *db )
{
struct ldbminfo *li = (struct ldbminfo *) be->be_private;
pthread_mutex_lock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_lock( &li->li_dbcache_mutex );
if ( --db->dbc_refcnt == 0 ) {
pthread_cond_signal( &li->li_dbcache_cv );
ldap_pvt_thread_cond_signal( &li->li_dbcache_cv );
ldbm_close( db->dbc_db );
free( db->dbc_name );
db->dbc_name = NULL;
}
pthread_mutex_unlock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_dbcache_mutex );
}
void
@ -155,7 +155,7 @@ ldbm_cache_flush_all( Backend *be )
struct ldbminfo *li = (struct ldbminfo *) be->be_private;
int i;
pthread_mutex_lock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_lock( &li->li_dbcache_mutex );
for ( i = 0; i < MAXDBCACHE; i++ ) {
if ( li->li_dbcache[i].dbc_name != NULL ) {
Debug( LDAP_DEBUG_TRACE, "ldbm flushing db (%s)\n",
@ -163,7 +163,7 @@ ldbm_cache_flush_all( Backend *be )
ldbm_sync( li->li_dbcache[i].dbc_db );
}
}
pthread_mutex_unlock( &li->li_dbcache_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_dbcache_mutex );
}
Datum

17
servers/slapd/back-ldbm/delete.c
View file

@ -41,7 +41,7 @@ ldbm_back_delete(
Debug (LDAP_DEBUG_TRACE,
"rdwr_Xchk: readers_reading: %d writer_writing: %d\n",
e->e_rdwr.readers_reading, e->e_rdwr.writer_writing, 0);
e->e_rdwr.lt_readers_reading, e->e_rdwr.lt_writer_writing, 0);
/* check for deleted */
@ -67,12 +67,13 @@ ldbm_back_delete(
Debug (LDAP_DEBUG_TRACE,
"rdwr_Xchk: readers_reading: %d writer_writing: %d\n",
e->e_rdwr.readers_reading, e->e_rdwr.writer_writing, 0);
e->e_rdwr.lt_readers_reading, e->e_rdwr.lt_writer_writing, 0);
/* delete from parent's id2children entry */
if( (pdn = dn_parent( be, e->e_ndn )) != NULL ) {
if( (p = dn2entry_w( be, pdn, &matched )) == NULL) {
Debug( LDAP_DEBUG_TRACE, "parent does not exist\n",
Debug( LDAP_DEBUG_TRACE,
"<=- ldbm_back_delete: parent does not exist\n",
0, 0, 0);
send_ldap_result( conn, op, LDAP_OPERATIONS_ERROR,
"", "");
@ -84,7 +85,8 @@ ldbm_back_delete(
if ( ! access_allowed( be, conn, op, p,
"children", NULL, ACL_WRITE ) )
{
Debug( LDAP_DEBUG_TRACE, "no access to parent\n", 0,
Debug( LDAP_DEBUG_TRACE,
"<=- ldbm_back_delete: no access to parent\n", 0,
0, 0 );
send_ldap_result( conn, op, LDAP_INSUFFICIENT_ACCESS,
"", "" );
@ -95,14 +97,15 @@ ldbm_back_delete(
} else {
/* no parent, must be root to delete */
if( ! be_isroot( be, op->o_ndn ) ) {
Debug( LDAP_DEBUG_TRACE, "no parent & not root\n",
Debug( LDAP_DEBUG_TRACE,
"<=- ldbm_back_delete: no parent & not root\n",
0, 0, 0);
send_ldap_result( conn, op, LDAP_INSUFFICIENT_ACCESS,
"", "");
goto return_results;
}
pthread_mutex_lock(&li->li_root_mutex);
ldap_pvt_thread_mutex_lock(&li->li_root_mutex);
rootlock = 1;
}
@ -145,7 +148,7 @@ return_results:;
if ( rootlock ) {
/* release root lock */
pthread_mutex_unlock(&li->li_root_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
}
/* free entry and writer lock */

8
servers/slapd/back-ldbm/id2entry.c
View file

@ -33,7 +33,7 @@ id2entry_add( Backend *be, Entry *e )
key.dptr = (char *) &e->e_id;
key.dsize = sizeof(ID);
pthread_mutex_lock( &entry2str_mutex );
ldap_pvt_thread_mutex_lock( &entry2str_mutex );
data.dptr = entry2str( e, &len, 1 );
data.dsize = len + 1;
@ -42,7 +42,7 @@ id2entry_add( Backend *be, Entry *e )
if ( li->li_dbcachewsync ) flags |= LDBM_SYNC;
rc = ldbm_cache_store( db, key, data, flags );
pthread_mutex_unlock( &entry2str_mutex );
ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
ldbm_cache_close( be, db );
(void) cache_add_entry_lock( &li->li_cache, e, 0 );
@ -66,7 +66,7 @@ id2entry_delete( Backend *be, Entry *e )
/* XXX - check for writer lock - should also check no reader pending */
#ifdef LDAP_DEBUG
assert(pthread_rdwr_wchk_np(&e->e_rdwr));
assert(ldap_pvt_thread_rdwr_wchk(&e->e_rdwr));
#endif
ldbm_datum_init( key );
@ -74,7 +74,7 @@ id2entry_delete( Backend *be, Entry *e )
/* XXX - check for writer lock - should also check no reader pending */
Debug (LDAP_DEBUG_TRACE,
"rdwr_Xchk: readers_reading: %d writer_writing: %d\n",
e->e_rdwr.readers_reading, e->e_rdwr.writer_writing, 0);
e->e_rdwr.lt_readers_reading, e->e_rdwr.lt_writer_writing, 0);
if ( (db = ldbm_cache_open( be, "id2entry", LDBM_SUFFIX, LDBM_WRCREAT ))
== NULL ) {

2
servers/slapd/back-ldbm/index.c
View file

@ -203,7 +203,7 @@ add_value(
}
idl_free( idl );
pthread_yield();
ldap_pvt_thread_yield();
/* Debug( LDAP_DEBUG_TRACE, "<= add_value %d\n", rc, 0, 0 ); */
return( rc );

12
servers/slapd/back-ldbm/init.c
View file

@ -70,12 +70,12 @@ ldbm_back_init(
free( argv[ 1 ] );
/* initialize various mutex locks & condition variables */
pthread_mutex_init( &li->li_root_mutex, pthread_mutexattr_default );
pthread_mutex_init( &li->li_add_mutex, pthread_mutexattr_default );
pthread_mutex_init( &li->li_cache.c_mutex, pthread_mutexattr_default );
pthread_mutex_init( &li->li_nextid_mutex, pthread_mutexattr_default );
pthread_mutex_init( &li->li_dbcache_mutex, pthread_mutexattr_default );
pthread_cond_init( &li->li_dbcache_cv, pthread_condattr_default );
ldap_pvt_thread_mutex_init( &li->li_root_mutex );
ldap_pvt_thread_mutex_init( &li->li_add_mutex );
ldap_pvt_thread_mutex_init( &li->li_cache.c_mutex );
ldap_pvt_thread_mutex_init( &li->li_nextid_mutex );
ldap_pvt_thread_mutex_init( &li->li_dbcache_mutex );
ldap_pvt_thread_cond_init( &li->li_dbcache_cv );
be->be_private = li;
}

12
servers/slapd/back-ldbm/modify.c
View file

@ -77,12 +77,12 @@ ldbm_back_modify(
}
/* check for abandon */
pthread_mutex_lock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
if ( op->o_abandon ) {
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
goto error_return;
}
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
/* modify indexes */
if ( index_add_mods( be, mods, e->e_id ) != 0 ) {
@ -91,12 +91,12 @@ ldbm_back_modify(
}
/* check for abandon */
pthread_mutex_lock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
if ( op->o_abandon ) {
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
goto error_return;
}
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
/* change the entry itself */
if ( id2entry_add( be, e ) != 0 ) {

10
servers/slapd/back-ldbm/modrdn.c
View file

@ -107,7 +107,7 @@ ldbm_back_modrdn(
goto return_results;
}
pthread_mutex_lock(&li->li_root_mutex);
ldap_pvt_thread_mutex_lock(&li->li_root_mutex);
rootlock = 1;
new_dn = ch_strdup( newrdn );
@ -121,12 +121,12 @@ ldbm_back_modrdn(
}
/* check for abandon */
pthread_mutex_lock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
if ( op->o_abandon ) {
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
goto return_results;
}
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
/* add new one */
if ( dn2id_add( be, new_ndn, e->e_id ) != 0 ) {
@ -180,7 +180,7 @@ return_results:
if ( rootlock ) {
/* release root writer lock */
pthread_mutex_unlock(&li->li_root_mutex);
ldap_pvt_thread_mutex_unlock(&li->li_root_mutex);
}
/* free entry and writer lock */

14
servers/slapd/back-ldbm/nextid.c
View file

@ -102,7 +102,7 @@ next_id( Backend *be )
struct ldbminfo *li = (struct ldbminfo *) be->be_private;
ID id;
pthread_mutex_lock( &li->li_nextid_mutex );
ldap_pvt_thread_mutex_lock( &li->li_nextid_mutex );
/* first time in here since startup - try to read the nexid */
if ( li->li_nextid == NOID ) {
@ -128,7 +128,7 @@ next_id( Backend *be )
(void) next_id_write( be, li->li_nextid );
#endif
pthread_mutex_unlock( &li->li_nextid_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_nextid_mutex );
return( id );
}
@ -138,10 +138,10 @@ next_id_return( Backend *be, ID id )
#ifdef SLAPD_NEXTID_RETURN
struct ldbminfo *li = (struct ldbminfo *) be->be_private;
pthread_mutex_lock( &li->li_nextid_mutex );
ldap_pvt_thread_mutex_lock( &li->li_nextid_mutex );
if ( id != li->li_nextid - 1 ) {
pthread_mutex_unlock( &li->li_nextid_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_nextid_mutex );
return;
}
@ -151,7 +151,7 @@ next_id_return( Backend *be, ID id )
(void) next_id_write( be, li->li_nextid );
#endif
pthread_mutex_unlock( &li->li_nextid_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_nextid_mutex );
#endif
}
@ -161,7 +161,7 @@ next_id_get( Backend *be )
struct ldbminfo *li = (struct ldbminfo *) be->be_private;
ID id;
pthread_mutex_lock( &li->li_nextid_mutex );
ldap_pvt_thread_mutex_lock( &li->li_nextid_mutex );
/* first time in here since startup - try to read the nexid */
if ( li->li_nextid == NOID ) {
@ -178,7 +178,7 @@ next_id_get( Backend *be )
id = li->li_nextid;
pthread_mutex_unlock( &li->li_nextid_mutex );
ldap_pvt_thread_mutex_unlock( &li->li_nextid_mutex );
return( id );
}

14
servers/slapd/back-ldbm/search.c
View file

@ -144,9 +144,9 @@ ldbm_back_search(
for ( id = idl_firstid( candidates ); id != NOID;
id = idl_nextid( candidates, id ) ) {
/* check for abandon */
pthread_mutex_lock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
if ( op->o_abandon ) {
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
idl_free( candidates );
free( rbuf );
if( realBase != NULL) {
@ -154,13 +154,13 @@ ldbm_back_search(
}
return( 0 );
}
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
/* check time limit */
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
time( &currenttime );
if ( tlimit != -1 && currenttime > stoptime ) {
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
send_ldap_search_result( conn, op,
LDAP_TIMELIMIT_EXCEEDED, NULL, nrefs > 0 ? rbuf :
NULL, nentries );
@ -171,7 +171,7 @@ ldbm_back_search(
}
return( 0 );
}
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
/* get the entry with reader lock */
if ( (e = id2entry_r( be, id )) == NULL ) {
@ -292,7 +292,7 @@ ldbm_back_search(
cache_return_entry_r( &li->li_cache, e );
}
pthread_yield();
ldap_pvt_thread_yield();
}
idl_free( candidates );
if ( nrefs > 0 ) {

12
servers/slapd/back-passwd/search.c
View file

@ -72,25 +72,25 @@ passwd_back_search(
for ( pw = getpwent(); pw != NULL; pw = getpwent() ) {
/* check for abandon */
pthread_mutex_lock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_lock( &op->o_abandonmutex );
if ( op->o_abandon ) {
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
endpwent();
return( -1 );
}
pthread_mutex_unlock( &op->o_abandonmutex );
ldap_pvt_thread_mutex_unlock( &op->o_abandonmutex );
/* check time limit */
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
time( &currenttime );
if ( currenttime > stoptime ) {
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
send_ldap_result( conn, op, LDAP_TIMELIMIT_EXCEEDED,
NULL, NULL );
endpwent();
return( 0 );
}
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
e = pw2entry( be, pw );

13
servers/slapd/back-shell/abandon.c
View file

@ -1,10 +1,13 @@
/* abandon.c - shell backend abandon function */
#include "portable.h"
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <signal.h>
#include <ac/socket.h>
#include <ac/string.h>
#include "slap.h"
#include "shell.h"
@ -23,7 +26,7 @@ shell_back_abandon(
/* no abandon command defined - just kill the process handling it */
if ( si->si_abandon == NULL ) {
pthread_mutex_lock( &conn->c_opsmutex );
ldap_pvt_thread_mutex_lock( &conn->c_opsmutex );
pid = -1;
for ( o = conn->c_ops; o != NULL; o = o->o_next ) {
if ( o->o_msgid == msgid ) {
@ -31,7 +34,7 @@ shell_back_abandon(
break;
}
}
pthread_mutex_unlock( &conn->c_opsmutex );
ldap_pvt_thread_mutex_unlock( &conn->c_opsmutex );
if ( pid != -1 ) {
Debug( LDAP_DEBUG_ARGS, "shell killing pid %d\n", pid,

4
servers/slapd/back-shell/add.c
View file

@ -38,9 +38,9 @@ shell_back_add(
fprintf( wfp, "ADD\n" );
fprintf( wfp, "msgid: %ld\n", op->o_msgid );
print_suffixes( wfp, be );
pthread_mutex_lock( &entry2str_mutex );
ldap_pvt_thread_mutex_lock( &entry2str_mutex );
fprintf( wfp, "%s", entry2str( e, &len, 0 ) );
pthread_mutex_unlock( &entry2str_mutex );
ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
fclose( wfp );
/* read in the result and send it along */

4
servers/slapd/backend.c
View file

@ -231,13 +231,13 @@ be_isroot_pw( Backend *be, char *ndn, struct berval *cred )
}
#ifdef SLAPD_CRYPT
pthread_mutex_lock( &crypt_mutex );
ldap_pvt_thread_mutex_lock( &crypt_mutex );
#endif
result = lutil_passwd( cred->bv_val, be->be_root_pw );
#ifdef SLAPD_CRYPT
pthread_mutex_unlock( &crypt_mutex );
ldap_pvt_thread_mutex_unlock( &crypt_mutex );
#endif
return result == 0;

12
servers/slapd/bind.c
View file

@ -135,7 +135,7 @@ do_bind(
free( cred.bv_val );
}
pthread_mutex_lock( &conn->c_dnmutex );
ldap_pvt_thread_mutex_lock( &conn->c_dnmutex );
if ( conn->c_cdn != NULL ) {
free( conn->c_cdn );
@ -147,7 +147,7 @@ do_bind(
conn->c_dn = NULL;
}
pthread_mutex_unlock( &conn->c_dnmutex );
ldap_pvt_thread_mutex_unlock( &conn->c_dnmutex );
send_ldap_result( conn, op, LDAP_SUCCESS, NULL, NULL );
return;
@ -166,7 +166,7 @@ do_bind(
free( cred.bv_val );
}
if ( cred.bv_len == 0 ) {
pthread_mutex_lock( &conn->c_dnmutex );
ldap_pvt_thread_mutex_lock( &conn->c_dnmutex );
if ( conn->c_cdn != NULL ) {
free( conn->c_cdn );
@ -178,7 +178,7 @@ do_bind(
conn->c_dn = NULL;
}
pthread_mutex_unlock( &conn->c_dnmutex );
ldap_pvt_thread_mutex_unlock( &conn->c_dnmutex );
send_ldap_result( conn, op, LDAP_SUCCESS,
NULL, NULL );
@ -199,7 +199,7 @@ do_bind(
ndn = suffixAlias( ndn, op, be );
if ( (*be->be_bind)( be, conn, op, ndn, method, &cred, &edn ) == 0 ) {
pthread_mutex_lock( &conn->c_dnmutex );
ldap_pvt_thread_mutex_lock( &conn->c_dnmutex );
if ( conn->c_cdn != NULL ) {
free( conn->c_cdn );
@ -222,7 +222,7 @@ do_bind(
Debug( LDAP_DEBUG_TRACE, "do_bind: bound \"%s\" to \"%s\"\n",
conn->c_cdn, conn->c_dn, method );
pthread_mutex_unlock( &conn->c_dnmutex );
ldap_pvt_thread_mutex_unlock( &conn->c_dnmutex );
/* send this here to avoid a race condition */
send_ldap_result( conn, op, LDAP_SUCCESS, NULL, NULL );

4
servers/slapd/charray.c
View file

@ -129,14 +129,14 @@ str2charray( char *str, char *brkstr )
res = (char **) ch_malloc( (i + 1) * sizeof(char *) );
i = 0;
pthread_mutex_lock(&strtok_mutex);
ldap_pvt_thread_mutex_lock(&strtok_mutex);
for ( s = strtok( str, brkstr ); s != NULL; s = strtok( NULL,
brkstr ) ) {
res[i++] = ch_strdup( s );
}
pthread_mutex_unlock(&strtok_mutex);
ldap_pvt_thread_mutex_unlock(&strtok_mutex);
res[i] = NULL;

80
servers/slapd/connection.c
View file

@ -27,13 +27,13 @@ connection_operation( void *arg_v )
struct co_arg *arg = arg_v;
unsigned long len;
pthread_mutex_lock( &arg->co_conn->c_opsmutex );
ldap_pvt_thread_mutex_lock( &arg->co_conn->c_opsmutex );
arg->co_conn->c_opsinitiated++;
pthread_mutex_unlock( &arg->co_conn->c_opsmutex );
ldap_pvt_thread_mutex_unlock( &arg->co_conn->c_opsmutex );
pthread_mutex_lock( &ops_mutex );
ldap_pvt_thread_mutex_lock( &ops_mutex );
ops_initiated++;
pthread_mutex_unlock( &ops_mutex );
ldap_pvt_thread_mutex_unlock( &ops_mutex );
switch ( arg->co_op->o_tag ) {
case LDAP_REQ_BIND:
@ -87,23 +87,23 @@ connection_operation( void *arg_v )
break;
}
pthread_mutex_lock( &arg->co_conn->c_opsmutex );
ldap_pvt_thread_mutex_lock( &arg->co_conn->c_opsmutex );
arg->co_conn->c_opscompleted++;
slap_op_delete( &arg->co_conn->c_ops, arg->co_op );
pthread_mutex_unlock( &arg->co_conn->c_opsmutex );
ldap_pvt_thread_mutex_unlock( &arg->co_conn->c_opsmutex );
free( (char *) arg );
pthread_mutex_lock( &ops_mutex );
ldap_pvt_thread_mutex_lock( &ops_mutex );
ops_completed++;
pthread_mutex_unlock( &ops_mutex );
ldap_pvt_thread_mutex_unlock( &ops_mutex );
pthread_mutex_lock( &active_threads_mutex );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
active_threads--;
if( active_threads < 1 ) {
pthread_cond_signal(&active_threads_cond);
ldap_pvt_thread_cond_signal(&active_threads_cond);
}
pthread_mutex_unlock( &active_threads_mutex );
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
return NULL;
}
@ -112,9 +112,6 @@ connection_activity(
Connection *conn
)
{
#ifndef HAVE_PTHREAD_DETACH
pthread_attr_t attr;
#endif
int status;
struct co_arg *arg;
unsigned long tag, len;
@ -181,68 +178,29 @@ connection_activity(
arg = (struct co_arg *) ch_malloc( sizeof(struct co_arg) );
arg->co_conn = conn;
pthread_mutex_lock( &conn->c_dnmutex );
ldap_pvt_thread_mutex_lock( &conn->c_dnmutex );
if ( conn->c_dn != NULL ) {
tmpdn = ch_strdup( conn->c_dn );
} else {
tmpdn = NULL;
}
pthread_mutex_unlock( &conn->c_dnmutex );
ldap_pvt_thread_mutex_unlock( &conn->c_dnmutex );
pthread_mutex_lock( &conn->c_opsmutex );
ldap_pvt_thread_mutex_lock( &conn->c_opsmutex );
arg->co_op = slap_op_add( &conn->c_ops, ber, msgid, tag, tmpdn,
conn->c_opsinitiated, conn->c_connid );
pthread_mutex_unlock( &conn->c_opsmutex );
ldap_pvt_thread_mutex_unlock( &conn->c_opsmutex );
if ( tmpdn != NULL ) {
free( tmpdn );
}
#ifdef HAVE_PTHREAD_DETACH
if ( status = pthread_create( &arg->co_op->o_tid, NULL,
if ( status = ldap_pvt_thread_create( &arg->co_op->o_tid, 1,
connection_operation, (void *) arg ) != 0 ) {
Debug( LDAP_DEBUG_ANY, "pthread_create failed (%d)\n", status, 0, 0 );
Debug( LDAP_DEBUG_ANY, "ldap_pvt_thread_create failed (%d)\n", status, 0, 0 );
} else {
pthread_mutex_lock( &active_threads_mutex );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
active_threads++;
pthread_mutex_unlock( &active_threads_mutex );
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
}
#if !defined(HAVE_PTHREADS_D4)
pthread_detach( arg->co_op->o_tid );
#else
pthread_detach( &arg->co_op->o_tid );
#endif
#else /* !pthread detach */
pthread_attr_init( &attr );
pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_DETACHED );
#if !defined(HAVE_PTHREADS_D4)
/* POSIX_THREADS or compatible
* This is a draft 10 or standard pthreads implementation
*/
if ( status = pthread_create( &arg->co_op->o_tid, &attr,
connection_operation, (void *) arg ) != 0 ) {
Debug( LDAP_DEBUG_ANY, "pthread_create failed (%d)\n", status, 0, 0 );
} else {
pthread_mutex_lock( &active_threads_mutex );
active_threads++;
pthread_mutex_unlock( &active_threads_mutex );
}
#else /* pthread draft4 */
/*
* This is a draft 4 or earlier pthreads implementation
*/
if ( status = pthread_create( &arg->co_op->o_tid, attr,
connection_operation, (void *) arg ) != 0 ) {
Debug( LDAP_DEBUG_ANY, "pthread_create failed (%d)\n", status, 0, 0 );
} else {
pthread_mutex_lock( &active_threads_mutex );
active_threads++;
pthread_mutex_unlock( &active_threads_mutex );
}
#endif /* pthread draft4 */
pthread_attr_destroy( &attr );
#endif
}

57
servers/slapd/daemon.c
View file

@ -90,13 +90,10 @@ slapd_daemon(
c[i].c_sb.sb_ber.ber_end = NULL;
c[i].c_writewaiter = 0;
c[i].c_connid = 0;
pthread_mutex_init( &c[i].c_dnmutex,
pthread_mutexattr_default );
pthread_mutex_init( &c[i].c_opsmutex,
pthread_mutexattr_default );
pthread_mutex_init( &c[i].c_pdumutex,
pthread_mutexattr_default );
pthread_cond_init( &c[i].c_wcv, pthread_condattr_default );
ldap_pvt_thread_mutex_init( &c[i].c_dnmutex );
ldap_pvt_thread_mutex_init( &c[i].c_opsmutex );
ldap_pvt_thread_mutex_init( &c[i].c_pdumutex );
ldap_pvt_thread_cond_init( &c[i].c_wcv );
}
if ( (tcps = socket( AF_INET, SOCK_STREAM, 0 )) == -1 ) {
@ -173,12 +170,12 @@ slapd_daemon(
zero.tv_sec = 0;
zero.tv_usec = 0;
pthread_mutex_lock( &active_threads_mutex );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
Debug( LDAP_DEBUG_CONNS,
"listening for connections on %d, activity on:",
tcps, 0, 0 );
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
for ( i = 0; i < dtblsize; i++ ) {
if ( c[i].c_sb.sb_sd != -1 ) {
FD_SET( c[i].c_sb.sb_sd, &readfds );
@ -191,7 +188,7 @@ slapd_daemon(
}
}
Debug( LDAP_DEBUG_CONNS, "\n", 0, 0, 0 );
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
Debug( LDAP_DEBUG_CONNS, "before select active_threads %d\n",
active_threads, 0, 0 );
@ -200,7 +197,7 @@ slapd_daemon(
#else
tvp = active_threads ? &zero : NULL;
#endif
pthread_mutex_unlock( &active_threads_mutex );
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
switch ( i = select( dtblsize, &readfds, &writefds, 0, tvp ) ) {
case -1: /* failure - try again */
@ -213,19 +210,19 @@ slapd_daemon(
case 0: /* timeout - let threads run */
Debug( LDAP_DEBUG_CONNS, "select timeout - yielding\n",
0, 0, 0 );
pthread_yield();
ldap_pvt_thread_yield();
continue;
default: /* something happened - deal with it */
Debug( LDAP_DEBUG_CONNS, "select activity on %d descriptors\n", i, 0, 0 );
; /* FALL */
}
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
time( &currenttime );
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
/* new connection */
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
if ( FD_ISSET( tcps, &readfds ) ) {
len = sizeof(from);
if ( (ns = accept( tcps, (struct sockaddr *) &from,
@ -234,7 +231,7 @@ slapd_daemon(
"accept() failed errno %d (%s)", errno,
errno > -1 && errno < sys_nerr ?
sys_errlist[errno] : "unknown", 0 );
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
continue;
}
if ( ioctl( ns, FIONBIO, (caddr_t) &on ) == -1 ) {
@ -292,15 +289,15 @@ slapd_daemon(
0, 0 );
close(ns);
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
continue;
}
#endif /* HAVE_TCPD */
c[ns].c_sb.sb_sd = ns;
pthread_mutex_lock( &ops_mutex );
ldap_pvt_thread_mutex_lock( &ops_mutex );
c[ns].c_connid = num_conns++;
pthread_mutex_unlock( &ops_mutex );
ldap_pvt_thread_mutex_unlock( &ops_mutex );
Statslog( LDAP_DEBUG_STATS,
"conn=%d fd=%d connection from %s (%s) accepted.\n",
@ -321,7 +318,7 @@ slapd_daemon(
c[ns].c_domain = ch_strdup( client_name == NULL
? "" : client_name );
pthread_mutex_lock( &c[ns].c_dnmutex );
ldap_pvt_thread_mutex_lock( &c[ns].c_dnmutex );
if ( c[ns].c_dn != NULL ) {
free( c[ns].c_dn );
c[ns].c_dn = NULL;
@ -330,12 +327,12 @@ slapd_daemon(
free( c[ns].c_cdn );
c[ns].c_cdn = NULL;
}
pthread_mutex_unlock( &c[ns].c_dnmutex );
ldap_pvt_thread_mutex_unlock( &c[ns].c_dnmutex );
c[ns].c_starttime = currenttime;
c[ns].c_opsinitiated = 0;
c[ns].c_opscompleted = 0;
}
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
Debug( LDAP_DEBUG_CONNS, "activity on:", 0, 0, 0 );
for ( i = 0; i < dtblsize; i++ ) {
@ -360,11 +357,11 @@ slapd_daemon(
Debug( LDAP_DEBUG_CONNS,
"signaling write waiter on %d\n", i, 0, 0 );
pthread_mutex_lock( &active_threads_mutex );
pthread_cond_signal( &c[i].c_wcv );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
ldap_pvt_thread_cond_signal( &c[i].c_wcv );
c[i].c_writewaiter = 0;
active_threads++;
pthread_mutex_unlock( &active_threads_mutex );
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
}
if ( FD_ISSET( i, &readfds ) ) {
@ -375,19 +372,19 @@ slapd_daemon(
}
}
pthread_yield();
ldap_pvt_thread_yield();
}
close( tcps );
pthread_mutex_lock( &active_threads_mutex );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
Debug( LDAP_DEBUG_ANY,
"slapd shutting down - waiting for %d threads to terminate\n",
active_threads, 0, 0 );
while ( active_threads > 0 ) {
pthread_cond_wait(&active_threads_cond, &active_threads_mutex);
ldap_pvt_thread_cond_wait(&active_threads_cond, &active_threads_mutex);
}
pthread_mutex_unlock( &active_threads_mutex );
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
/* let backends do whatever cleanup they need to do */
Debug( LDAP_DEBUG_TRACE,
@ -403,7 +400,7 @@ set_shutdown( int sig )
{
Debug( LDAP_DEBUG_ANY, "slapd got shutdown signal %d\n", sig, 0, 0 );
slapd_shutdown = 1;
pthread_kill( listener_tid, LDAP_SIGUSR1 );
ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
(void) SIGNAL( LDAP_SIGUSR2, set_shutdown );
(void) SIGNAL( SIGTERM, set_shutdown );
(void) SIGNAL( SIGINT, set_shutdown );

14
servers/slapd/entry.c
View file

@ -220,8 +220,8 @@ entry_free( Entry *e )
/* XXX check that no reader/writer locks exist */
#ifdef LDAP_DEBUG
assert( !pthread_rdwr_wchk_np(&e->e_rdwr) &&
!pthread_rdwr_rchk_np(&e->e_rdwr) );
assert( !ldap_pvt_thread_rdwr_wchk(&e->e_rdwr) &&
!ldap_pvt_thread_rdwr_rchk(&e->e_rdwr) );
#endif
if ( e->e_dn != NULL ) {
@ -243,9 +243,9 @@ entry_rdwr_lock(Entry *e, int rw)
Debug( LDAP_DEBUG_ARGS, "entry_rdwr_%slock: ID: %ld\n",
rw ? "w" : "r", e->e_id, 0);
if (rw)
return pthread_rdwr_wlock_np(&e->e_rdwr);
return ldap_pvt_thread_rdwr_wlock(&e->e_rdwr);
else
return pthread_rdwr_rlock_np(&e->e_rdwr);
return ldap_pvt_thread_rdwr_rlock(&e->e_rdwr);
}
int
@ -266,9 +266,9 @@ entry_rdwr_unlock(Entry *e, int rw)
Debug( LDAP_DEBUG_ARGS, "entry_rdwr_%sunlock: ID: %ld\n",
rw ? "w" : "r", e->e_id, 0);
if (rw)
return pthread_rdwr_wunlock_np(&e->e_rdwr);
return ldap_pvt_thread_rdwr_wunlock(&e->e_rdwr);
else
return pthread_rdwr_runlock_np(&e->e_rdwr);
return ldap_pvt_thread_rdwr_runlock(&e->e_rdwr);
}
int
@ -286,5 +286,5 @@ entry_rdwr_wunlock(Entry *e)
int
entry_rdwr_init(Entry *e)
{
return pthread_rdwr_init_np(&e->e_rdwr, NULL);
return ldap_pvt_thread_rdwr_init( &e->e_rdwr );
}

44
servers/slapd/init.c
View file

@ -26,7 +26,7 @@ int ldap_syslog;
int ldap_syslog_level = LOG_DEBUG;
char *default_referral;
time_t starttime;
pthread_t listener_tid;
ldap_pvt_thread_t listener_tid;
int g_argc;
char **g_argv;
@ -34,48 +34,50 @@ char **g_argv;
* global variables that need mutex protection
*/
int active_threads;
pthread_mutex_t active_threads_mutex;
pthread_cond_t active_threads_cond;
ldap_pvt_thread_mutex_t active_threads_mutex;
ldap_pvt_thread_cond_t active_threads_cond;
time_t currenttime;
pthread_mutex_t currenttime_mutex;
ldap_pvt_thread_mutex_t currenttime_mutex;
pthread_mutex_t new_conn_mutex;
ldap_pvt_thread_mutex_t new_conn_mutex;
#ifdef SLAPD_CRYPT
pthread_mutex_t crypt_mutex;
ldap_pvt_thread_mutex_t crypt_mutex;
#endif
pthread_mutex_t strtok_mutex;
ldap_pvt_thread_mutex_t strtok_mutex;
int num_conns;
long ops_initiated;
long ops_completed;
pthread_mutex_t ops_mutex;
ldap_pvt_thread_mutex_t ops_mutex;
long num_entries_sent;
long num_bytes_sent;
pthread_mutex_t num_sent_mutex;
ldap_pvt_thread_mutex_t num_sent_mutex;
/*
* these mutexes must be used when calling the entry2str()
* routine since it returns a pointer to static data.
*/
pthread_mutex_t entry2str_mutex;
pthread_mutex_t replog_mutex;
ldap_pvt_thread_mutex_t entry2str_mutex;
ldap_pvt_thread_mutex_t replog_mutex;
void
init( void )
{
pthread_mutex_init( &active_threads_mutex, pthread_mutexattr_default );
pthread_cond_init( &active_threads_cond, pthread_condattr_default );
(void) ldap_pvt_thread_initialize();
pthread_mutex_init( &new_conn_mutex, pthread_mutexattr_default );
pthread_mutex_init( &currenttime_mutex, pthread_mutexattr_default );
pthread_mutex_init( &strtok_mutex, pthread_mutexattr_default );
pthread_mutex_init( &entry2str_mutex, pthread_mutexattr_default );
pthread_mutex_init( &replog_mutex, pthread_mutexattr_default );
pthread_mutex_init( &ops_mutex, pthread_mutexattr_default );
pthread_mutex_init( &num_sent_mutex, pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &active_threads_mutex );
ldap_pvt_thread_cond_init( &active_threads_cond );
ldap_pvt_thread_mutex_init( &new_conn_mutex );
ldap_pvt_thread_mutex_init( &currenttime_mutex );
ldap_pvt_thread_mutex_init( &entry2str_mutex );
ldap_pvt_thread_mutex_init( &replog_mutex );
ldap_pvt_thread_mutex_init( &ops_mutex );
ldap_pvt_thread_mutex_init( &num_sent_mutex );
#ifdef SLAPD_CRYPT
pthread_mutex_init( &crypt_mutex, pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &crypt_mutex );
#endif
ldap_pvt_thread_mutex_init( &strtok_mutex );
}

23
servers/slapd/main.c
View file

@ -191,18 +191,15 @@ main( int argc, char **argv )
time( &starttime );
if ( pthread_create( &listener_tid, NULL, slapd_daemon,
(void *) port ) != 0 ) {
if ( status = ldap_pvt_thread_create( &listener_tid, 0,
slapd_daemon, (void *) port ) != 0 )
{
Debug( LDAP_DEBUG_ANY,
"listener pthread_create failed\n", 0, 0, 0 );
"listener ldap_pvt_thread_create failed (%d)\n", status, 0, 0 );
exit( 1 );
}
#ifdef HAVE_PTHREADS_FINAL
pthread_join( listener_tid, (void *) NULL );
#else
pthread_join( listener_tid, (void *) &status );
#endif
ldap_pvt_thread_join( listener_tid, (void *) NULL );
return 0;
@ -225,9 +222,9 @@ main( int argc, char **argv )
c.c_sb.sb_ber.ber_buf = NULL;
c.c_sb.sb_ber.ber_ptr = NULL;
c.c_sb.sb_ber.ber_end = NULL;
pthread_mutex_init( &c.c_dnmutex, pthread_mutexattr_default );
pthread_mutex_init( &c.c_opsmutex, pthread_mutexattr_default );
pthread_mutex_init( &c.c_pdumutex, pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &c.c_dnmutex );
ldap_pvt_thread_mutex_init( &c.c_opsmutex );
ldap_pvt_thread_mutex_init( &c.c_pdumutex );
#ifdef notdefcldap
c.c_sb.sb_addrs = (void **) saddrlist;
c.c_sb.sb_fromaddr = &faddr;
@ -256,9 +253,9 @@ main( int argc, char **argv )
ber_init( &ber, 0 );
while ( (tag = ber_get_next( &c.c_sb, &len, &ber ))
== LDAP_TAG_MESSAGE ) {
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
time( &currenttime );
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
if ( (tag = ber_get_int( &ber, &msgid ))
!= LDAP_TAG_MSGID ) {

4
servers/slapd/modify.c
View file

@ -245,7 +245,7 @@ add_lastmods( Operation *op, LDAPMod **mods )
tmp->mod_next = *mods;
*mods = tmp;
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
#ifndef LDAP_LOCALTIME
ltm = gmtime( &currenttime );
strftime( buf, sizeof(buf), "%Y%m%d%H%M%SZ", ltm );
@ -253,7 +253,7 @@ add_lastmods( Operation *op, LDAPMod **mods )
ltm = localtime( &currenttime );
strftime( buf, sizeof(buf), "%y%m%d%H%M%SZ", ltm );
#endif
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
bv.bv_val = buf;
bv.bv_len = strlen( bv.bv_val );
tmp = (LDAPMod *) ch_calloc( 1, sizeof(LDAPMod) );

24
servers/slapd/monitor.c
View file

@ -68,7 +68,7 @@ monitor_info( Connection *conn, Operation *op )
nwritewaiters = 0;
nreadwaiters = 0;
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
for ( i = 0; i < dtblsize; i++ ) {
if ( c[i].c_sb.sb_sd != -1 ) {
nconns++;
@ -78,7 +78,7 @@ monitor_info( Connection *conn, Operation *op )
if ( c[i].c_gettingber ) {
nreadwaiters++;
}
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
#ifndef LDAP_LOCALTIME
ltm = gmtime( &c[i].c_starttime );
strftime( buf2, sizeof(buf2), "%Y%m%d%H%M%SZ", ltm );
@ -86,21 +86,21 @@ monitor_info( Connection *conn, Operation *op )
ltm = localtime( &c[i].c_starttime );
strftime( buf2, sizeof(buf2), "%y%m%d%H%M%SZ", ltm );
#endif
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
pthread_mutex_lock( &c[i].c_dnmutex );
ldap_pvt_thread_mutex_lock( &c[i].c_dnmutex );
sprintf( buf, "%d : %s : %d : %d : %s : %s%s", i,
buf2, c[i].c_opsinitiated, c[i].c_opscompleted,
c[i].c_cdn ? c[i].c_cdn : "NULLDN",
c[i].c_gettingber ? "r" : "",
c[i].c_writewaiter ? "w" : "" );
pthread_mutex_unlock( &c[i].c_dnmutex );
ldap_pvt_thread_mutex_unlock( &c[i].c_dnmutex );
val.bv_val = buf;
val.bv_len = strlen( buf );
attr_merge( e, "connection", vals );
}
}
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
sprintf( buf, "%d", nconns );
val.bv_val = buf;
@ -147,7 +147,7 @@ monitor_info( Connection *conn, Operation *op )
val.bv_len = strlen( buf );
attr_merge( e, "bytessent", vals );
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
#ifndef LDAP_LOCALTIME
ltm = gmtime( &currenttime );
strftime( buf, sizeof(buf), "%Y%m%d%H%M%SZ", ltm );
@ -155,12 +155,12 @@ monitor_info( Connection *conn, Operation *op )
ltm = localtime( &currenttime );
strftime( buf, sizeof(buf), "%y%m%d%H%M%SZ", ltm );
#endif
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
val.bv_val = buf;
val.bv_len = strlen( buf );
attr_merge( e, "currenttime", vals );
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
#ifndef LDAP_LOCALTIME
ltm = gmtime( &starttime );
strftime( buf, sizeof(buf), "%Y%m%d%H%M%SZ", ltm );
@ -168,7 +168,7 @@ monitor_info( Connection *conn, Operation *op )
ltm = localtime( &starttime );
strftime( buf, sizeof(buf), "%y%m%d%H%M%SZ", ltm );
#endif
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
val.bv_val = buf;
val.bv_len = strlen( buf );
attr_merge( e, "starttime", vals );
@ -178,8 +178,8 @@ monitor_info( Connection *conn, Operation *op )
val.bv_len = strlen( buf );
attr_merge( e, "nbackends", vals );
#ifdef HAVE_THR
sprintf( buf, "%d", thr_getconcurrency() );
#ifdef HAVE_THREAD_CONCURRENCY
sprintf( buf, "%d", ldap_pvt_thread_getconcurrency() );
val.bv_val = buf;
val.bv_len = strlen( buf );
attr_merge( e, "concurrency", vals );

9
servers/slapd/operation.c
View file

@ -21,7 +21,7 @@ slap_op_free( Operation *op )
if ( op->o_ndn != NULL ) {
free( op->o_ndn );
}
/* pthread_mutex_destroy( &op->o_abandonmutex ); */
ldap_pvt_thread_mutex_destroy( &op->o_abandonmutex );
free( (char *) op );
}
@ -42,8 +42,7 @@ slap_op_add(
; /* NULL */
*tmp = (Operation *) calloc( 1, sizeof(Operation) );
pthread_mutex_init( &(*tmp)->o_abandonmutex,
pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &(*tmp)->o_abandonmutex );
(*tmp)->o_ber = ber;
(*tmp)->o_msgid = msgid;
(*tmp)->o_tag = tag;
@ -52,9 +51,9 @@ slap_op_add(
(*tmp)->o_dn = ch_strdup( dn != NULL ? dn : "" );
(*tmp)->o_ndn = dn_normalize_case( ch_strdup( (*tmp)->o_dn ) );
pthread_mutex_lock( &currenttime_mutex );
ldap_pvt_thread_mutex_lock( &currenttime_mutex );
(*tmp)->o_time = currenttime;
pthread_mutex_unlock( &currenttime_mutex );
ldap_pvt_thread_mutex_unlock( &currenttime_mutex );
(*tmp)->o_opid = id;
(*tmp)->o_connid = connid;
(*tmp)->o_next = NULL;

23
servers/slapd/proto-slap.h
View file

@ -245,20 +245,21 @@ extern long num_entries_sent;
extern long ops_completed;
extern long ops_initiated;
extern pthread_mutex_t active_threads_mutex;
extern pthread_cond_t active_threads_cond;
extern ldap_pvt_thread_mutex_t active_threads_mutex;
extern ldap_pvt_thread_cond_t active_threads_cond;
extern pthread_mutex_t currenttime_mutex;
extern pthread_mutex_t strtok_mutex;
extern pthread_mutex_t entry2str_mutex;
extern pthread_mutex_t new_conn_mutex;
extern pthread_mutex_t num_sent_mutex;
extern pthread_mutex_t ops_mutex;
extern pthread_mutex_t replog_mutex;
extern ldap_pvt_thread_mutex_t currenttime_mutex;
extern ldap_pvt_thread_mutex_t entry2str_mutex;
extern ldap_pvt_thread_mutex_t new_conn_mutex;
extern ldap_pvt_thread_mutex_t num_sent_mutex;
extern ldap_pvt_thread_mutex_t ops_mutex;
extern ldap_pvt_thread_mutex_t replog_mutex;
#ifdef SLAPD_CRYPT
extern pthread_mutex_t crypt_mutex;
extern ldap_pvt_thread_mutex_t crypt_mutex;
#endif
extern pthread_t listener_tid;
extern ldap_pvt_thread_mutex_t strtok_mutex;
extern ldap_pvt_thread_t listener_tid;
extern struct acl *global_acl;
extern struct objclass *global_oc;
extern time_t currenttime;

10
servers/slapd/repl.c
View file

@ -33,10 +33,10 @@ replog(
return;
}
pthread_mutex_lock( &replog_mutex );
ldap_pvt_thread_mutex_lock( &replog_mutex );
if ( (fp = lock_fopen( be->be_replogfile ? be->be_replogfile :
replogfile, "a", &lfp )) == NULL ) {
pthread_mutex_unlock( &replog_mutex );
ldap_pvt_thread_mutex_unlock( &replog_mutex );
return;
}
@ -92,7 +92,7 @@ replog(
case LDAP_REQ_ADD:
e = change;
fprintf( fp, "changetype: add\n" );
pthread_mutex_lock( &entry2str_mutex );
ldap_pvt_thread_mutex_lock( &entry2str_mutex );
tmp = entry2str( e, &len, 0 );
while ( (tmp = strchr( tmp, '\n' )) != NULL ) {
tmp++;
@ -100,7 +100,7 @@ replog(
break;
}
fprintf( fp, "%s", tmp );
pthread_mutex_unlock( &entry2str_mutex );
ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
break;
case LDAP_REQ_DELETE:
@ -116,5 +116,5 @@ replog(
fprintf( fp, "\n" );
lock_fclose( fp, lfp );
pthread_mutex_unlock( &replog_mutex );
ldap_pvt_thread_mutex_unlock( &replog_mutex );
}

68
servers/slapd/result.c
View file

@ -83,14 +83,14 @@ send_ldap_result2(
}
/* write only one pdu at a time - wait til it's our turn */
pthread_mutex_lock( &conn->c_pdumutex );
ldap_pvt_thread_mutex_lock( &conn->c_pdumutex );
/* write the pdu */
bytes = ber->ber_ptr - ber->ber_buf;
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
while ( conn->c_connid == op->o_connid && ber_flush( &conn->c_sb, ber,
1 ) != 0 ) {
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
/*
* we got an error. if it's ewouldblock, we need to
* wait on the socket being writable. otherwise, figure
@ -104,33 +104,33 @@ send_ldap_result2(
if ( errno != EWOULDBLOCK && errno != EAGAIN ) {
close_connection( conn, op->o_connid, op->o_opid );
pthread_mutex_unlock( &conn->c_pdumutex );
ldap_pvt_thread_mutex_unlock( &conn->c_pdumutex );
return;
}
/* wait for socket to be write-ready */
pthread_mutex_lock( &active_threads_mutex );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
active_threads--;
conn->c_writewaiter = 1;
pthread_kill( listener_tid, LDAP_SIGUSR1 );
ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
pthread_cond_wait( &conn->c_wcv, &active_threads_mutex );
ldap_pvt_thread_cond_wait( &conn->c_wcv, &active_threads_mutex );
if( active_threads < 1 ) {
pthread_cond_signal(&active_threads_cond);
ldap_pvt_thread_cond_signal(&active_threads_cond);
}
pthread_mutex_unlock( &active_threads_mutex );
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
pthread_yield();
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_yield();
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
}
pthread_mutex_unlock( &new_conn_mutex );
pthread_mutex_unlock( &conn->c_pdumutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &conn->c_pdumutex );
pthread_mutex_lock( &num_sent_mutex );
ldap_pvt_thread_mutex_lock( &num_sent_mutex );
num_bytes_sent += bytes;
pthread_mutex_unlock( &num_sent_mutex );
ldap_pvt_thread_mutex_unlock( &num_sent_mutex );
Statslog( LDAP_DEBUG_STATS,
"conn=%d op=%d RESULT err=%d tag=%d nentries=%d\n", conn->c_connid,
@ -319,13 +319,13 @@ send_search_entry(
}
/* write only one pdu at a time - wait til it's our turn */
pthread_mutex_lock( &conn->c_pdumutex );
ldap_pvt_thread_mutex_lock( &conn->c_pdumutex );
bytes = ber->ber_ptr - ber->ber_buf;
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
while ( conn->c_connid == op->o_connid && ber_flush( &conn->c_sb, ber,
1 ) != 0 ) {
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
/*
* we got an error. if it's ewouldblock, we need to
* wait on the socket being writable. otherwise, figure
@ -339,34 +339,34 @@ send_search_entry(
if ( errno != EWOULDBLOCK && errno != EAGAIN ) {
close_connection( conn, op->o_connid, op->o_opid );
pthread_mutex_unlock( &conn->c_pdumutex );
ldap_pvt_thread_mutex_unlock( &conn->c_pdumutex );
return( -1 );
}
/* wait for socket to be write-ready */
pthread_mutex_lock( &active_threads_mutex );
ldap_pvt_thread_mutex_lock( &active_threads_mutex );
active_threads--;
conn->c_writewaiter = 1;
pthread_kill( listener_tid, LDAP_SIGUSR1 );
pthread_cond_wait( &conn->c_wcv, &active_threads_mutex );
ldap_pvt_thread_kill( listener_tid, LDAP_SIGUSR1 );
ldap_pvt_thread_cond_wait( &conn->c_wcv, &active_threads_mutex );
if( active_threads < 1 ) {
pthread_cond_signal(&active_threads_cond);
ldap_pvt_thread_cond_signal(&active_threads_cond);
}
pthread_mutex_unlock( &active_threads_mutex );
ldap_pvt_thread_mutex_unlock( &active_threads_mutex );
pthread_yield();
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_yield();
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
}
pthread_mutex_unlock( &new_conn_mutex );
pthread_mutex_unlock( &conn->c_pdumutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &conn->c_pdumutex );
pthread_mutex_lock( &num_sent_mutex );
ldap_pvt_thread_mutex_lock( &num_sent_mutex );
num_bytes_sent += bytes;
num_entries_sent++;
pthread_mutex_unlock( &num_sent_mutex );
ldap_pvt_thread_mutex_unlock( &num_sent_mutex );
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
if ( conn->c_connid == op->o_connid ) {
rc = 0;
Statslog( LDAP_DEBUG_STATS2, "conn=%d op=%d ENTRY dn=\"%s\"\n",
@ -374,7 +374,7 @@ send_search_entry(
} else {
rc = -1;
}
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
Debug( LDAP_DEBUG_TRACE, "<= send_search_entry\n", 0, 0, 0 );
@ -447,7 +447,7 @@ str2result(
void
close_connection( Connection *conn, int opconnid, int opid )
{
pthread_mutex_lock( &new_conn_mutex );
ldap_pvt_thread_mutex_lock( &new_conn_mutex );
if ( conn->c_sb.sb_sd != -1 && conn->c_connid == opconnid ) {
Statslog( LDAP_DEBUG_STATS,
"conn=%d op=%d fd=%d closed errno=%d\n", conn->c_connid,
@ -456,5 +456,5 @@ close_connection( Connection *conn, int opconnid, int opid )
conn->c_sb.sb_sd = -1;
conn->c_version = 0;
}
pthread_mutex_unlock( &new_conn_mutex );
ldap_pvt_thread_mutex_unlock( &new_conn_mutex );
}

19
servers/slapd/slap.h
View file

@ -19,8 +19,9 @@
#include "avl.h"
#include "lber.h"
#include "ldap.h"
#include "lthread.h"
#include "lthread_rdwr.h"
#include "ldap_pvt_thread.h"
#include "ldif.h"
#ifdef f_next
#undef f_next /* name conflict between sys/file.h on SCO and struct filter */
@ -132,7 +133,7 @@ typedef struct entry {
/* really be private to back-ldbm */
char e_state; /* for the cache */
pthread_rdwr_t e_rdwr; /* reader/writer lock */
ldap_pvt_thread_rdwr_t e_rdwr; /* reader/writer lock */
#define ENTRY_STATE_DELETED 1
#define ENTRY_STATE_CREATING 2
@ -281,9 +282,9 @@ typedef struct slap_op {
char o_searchbase; /* search base if via CLDAP */
#endif
struct slap_op *o_next; /* next operation pending */
pthread_t o_tid; /* thread handling this op */
ldap_pvt_thread_t o_tid; /* thread handling this op */
int o_abandon; /* signals op has been abandoned */
pthread_mutex_t o_abandonmutex; /* signals op has been abandoned */
ldap_pvt_thread_mutex_t o_abandonmutex; /* signals op has been abandoned */
int o_private; /* anything the backend needs */
} Operation;
@ -296,7 +297,7 @@ typedef struct slap_conn {
Sockbuf c_sb; /* ber connection stuff */
char *c_cdn; /* DN provided by the client */
char *c_dn; /* DN bound to this conn */
pthread_mutex_t c_dnmutex; /* mutex for c_dn field */
ldap_pvt_thread_mutex_t c_dnmutex; /* mutex for c_dn field */
int c_authtype; /* auth method used to bind c_dn */
#ifdef LDAP_COMPAT
int c_version; /* for compatibility w/2.0, 3.0 */
@ -304,9 +305,9 @@ typedef struct slap_conn {
char *c_addr; /* address of client on this conn */
char *c_domain; /* domain of client on this conn */
Operation *c_ops; /* list of pending operations */
pthread_mutex_t c_opsmutex; /* mutex for c_ops list & stats */
pthread_mutex_t c_pdumutex; /* only one pdu written at a time */
pthread_cond_t c_wcv; /* used to wait for sd write-ready*/
ldap_pvt_thread_mutex_t c_opsmutex; /* mutex for c_ops list & stats */
ldap_pvt_thread_mutex_t c_pdumutex; /* only one pdu written at a time */
ldap_pvt_thread_cond_t c_wcv; /* used to wait for sd write-ready*/
int c_gettingber; /* in the middle of ber_get_next */
BerElement *c_currentber; /* ber we're getting */
int c_writewaiter; /* signals write-ready sd waiter */

6
servers/slurpd/Makefile.in
View file

@ -9,12 +9,10 @@ XSRCS = version.c
SRCS = admin.c args.c ch_malloc.c config.c \
fm.c globals.c ldap_op.c lock.c main.c re.c \
reject.c replica.c replog.c ri.c rq.c sanity.c st.c \
tsleep.c
reject.c replica.c replog.c ri.c rq.c sanity.c st.c
OBJS = admin.o args.o ch_malloc.o config.o \
fm.o globals.o ldap_op.o lock.o main.o re.o \
reject.o replica.o replog.o ri.o rq.o sanity.o st.o \
tsleep.o
reject.o replica.o replog.o ri.o rq.o sanity.o st.o
LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries

8
servers/slurpd/fm.c
View file

@ -99,7 +99,7 @@ fm(
}
}
} else {
tsleep( sglob->no_work_interval );
ldap_pvt_thread_sleep( sglob->no_work_interval );
}
/* Garbage-collect queue */
@ -135,9 +135,9 @@ set_shutdown(int x)
int i;
sglob->slurpd_shutdown = 1; /* set flag */
pthread_kill( sglob->fm_tid, LDAP_SIGUSR1 ); /* wake up file mgr */
ldap_pvt_thread_kill( sglob->fm_tid, LDAP_SIGUSR1 ); /* wake up file mgr */
sglob->rq->rq_lock( sglob->rq ); /* lock queue */
pthread_cond_broadcast( &(sglob->rq->rq_more) ); /* wake repl threads */
ldap_pvt_thread_cond_broadcast( &(sglob->rq->rq_more) ); /* wake repl threads */
for ( i = 0; i < sglob->num_replicas; i++ ) {
(sglob->replicas[ i ])->ri_wake( sglob->replicas[ i ]);
}
@ -203,7 +203,7 @@ populate_queue(
p, 0, 0 );
}
free( p );
pthread_yield();
ldap_pvt_thread_yield();
}
sglob->srpos = ftell( fp );
}

2
servers/slurpd/globals.c
View file

@ -60,7 +60,7 @@ init_globals( void )
fprintf( stderr, "Cannot initialize status data\n" );
exit( 1 );
}
pthread_mutex_init( &(g->rej_mutex), pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &(g->rej_mutex) );
if ( Rq_init( &(g->rq)) < 0 ) {
fprintf( stderr, "Cannot initialize queue\n" );
exit( 1 );

4
servers/slurpd/globals.h
View file

@ -23,7 +23,7 @@ LDAP_BEGIN_DECL
typedef struct globals {
/* Thread ID for file manager thread */
pthread_t fm_tid;
ldap_pvt_thread_t fm_tid;
/* The name of the slapd config file (which is also our config file) */
char *slapd_configfile;
/* How long the master slurpd sleeps when there's no work to do */
@ -49,7 +49,7 @@ typedef struct globals {
/* Current offset into slurpd replica logfile */
off_t srpos;
/* mutex to serialize access to reject file */
pthread_mutex_t rej_mutex;
ldap_pvt_thread_mutex_t rej_mutex;
/* pointer to status struct */
St *st;
/* Pointer to replication queue */

30
servers/slurpd/main.c
View file

@ -36,7 +36,6 @@ main(
return( 1 );
#else
pthread_attr_t attr;
int status;
int i;
@ -94,13 +93,8 @@ main(
#endif /* LDAP_DEBUG */
lutil_detach( 0, 0 );
#if defined( HAVE_LWP )
/*
* Need to start a scheduler thread under SunOS 4
*/
start_lwp_scheduler();
#endif /* HAVE_LWP */
/* initialize thread package */
ldap_pvt_thread_initialize();
/*
* Start threads - one thread for each replica
@ -112,9 +106,10 @@ main(
/*
* Start the main file manager thread (in fm.c).
*/
if ( pthread_create( &(sglob->fm_tid), NULL, fm, (void *) NULL )
!= 0 ) {
Debug( LDAP_DEBUG_ANY, "file manager pthread_create failed\n",
if ( ldap_pvt_thread_create( &(sglob->fm_tid),
0, fm, (void *) NULL ) != 0 )
{
Debug( LDAP_DEBUG_ANY, "file manager ldap_pvt_thread_create failed\n",
0, 0, 0 );
exit( 1 );
@ -123,20 +118,13 @@ main(
/*
* Wait for the fm thread to finish.
*/
#ifdef HAVE_PTHREADS_FINAL
pthread_join( sglob->fm_tid, (void *) NULL );
#else
pthread_join( sglob->fm_tid, (void *) &status );
#endif
ldap_pvt_thread_join( sglob->fm_tid, (void *) NULL );
/*
* Wait for the replica threads to finish.
*/
for ( i = 0; sglob->replicas[ i ] != NULL; i++ ) {
#ifdef HAVE_PTHREADS_FINAL
pthread_join( sglob->replicas[ i ]->ri_tid, (void *) NULL );
#else
pthread_join( sglob->replicas[ i ]->ri_tid, (void *) &status );
#endif
ldap_pvt_thread_join( sglob->replicas[ i ]->ri_tid, (void *) NULL );
}
Debug( LDAP_DEBUG_ANY, "slurpd: terminating normally\n", 0, 0, 0 );
sglob->slurpd_shutdown = 1;

8
servers/slurpd/re.c
View file

@ -81,7 +81,7 @@ Re_free(
}
#if !defined( HAVE_LWP )
/* This seems to have problems under SunOS lwp */
pthread_mutex_destroy( &re->re_mutex );
ldap_pvt_thread_mutex_destroy( &re->re_mutex );
#endif /* HAVE_LWP */
ch_free( re->re_timestamp );
if (( rh = re->re_replicas ) != NULL ) {
@ -641,7 +641,7 @@ Re_lock(
Re *re
)
{
return( pthread_mutex_lock( &re->re_mutex ));
return( ldap_pvt_thread_mutex_lock( &re->re_mutex ));
}
@ -655,7 +655,7 @@ Re_unlock(
Re *re
)
{
return( pthread_mutex_unlock( &re->re_mutex ));
return( ldap_pvt_thread_mutex_unlock( &re->re_mutex ));
}
@ -696,7 +696,7 @@ Re_init(
(*re)->re_mods = NULL;
(*re)->re_next = NULL;
pthread_mutex_init( &((*re)->re_mutex), pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &((*re)->re_mutex) );
return 0;
}

17
servers/slurpd/reject.c
View file

@ -17,21 +17,20 @@
* to a replica LDAP server.
*/
#include "portable.h"
#include <stdio.h>
#include <ac/errno.h>
#include <ac/unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "slurp.h"
#include "globals.h"
#ifndef SYSERRLIST_IN_STDIO
extern char *sys_errlist[];
#endif /* SYSERRLIST_IN_STDIO */
/*
* Write a replication record to a reject file. The reject file has the
* same name as the replica's private copy of the file but with ".rej"
@ -52,7 +51,7 @@ write_reject(
FILE *rfp, *lfp;
int rc;
pthread_mutex_lock( &sglob->rej_mutex );
ldap_pvt_thread_mutex_lock( &sglob->rej_mutex );
sprintf( rejfile, "%s/%s:%d.rej", sglob->slurpd_rdir,
ri->ri_hostname, ri->ri_port );
@ -64,7 +63,7 @@ write_reject(
Debug( LDAP_DEBUG_ANY,
"Error: write_reject: Cannot create \"%s\": %s\n",
rejfile, sys_errlist[ errno ], 0 );
pthread_mutex_unlock( &sglob->rej_mutex );
ldap_pvt_thread_mutex_unlock( &sglob->rej_mutex );
return;
} else {
close( rjfd );
@ -90,7 +89,7 @@ write_reject(
"Error: ldap operation failed, data written to \"%s\"\n",
rejfile, 0, 0 );
}
pthread_mutex_unlock( &sglob->rej_mutex );
ldap_pvt_thread_mutex_unlock( &sglob->rej_mutex );
return;
}

4
servers/slurpd/replica.c
View file

@ -55,9 +55,9 @@ start_replica_thread(
)
{
/* POSIX_THREADS or compatible */
if ( pthread_create( &(ri->ri_tid), NULL, replicate,
if ( ldap_pvt_thread_create( &(ri->ri_tid), NULL, replicate,
(void *) ri ) != 0 ) {
Debug( LDAP_DEBUG_ANY, "replica \"%s:%d\" pthread_create failed\n",
Debug( LDAP_DEBUG_ANY, "replica \"%s:%d\" ldap_pvt_thread_create failed\n",
ri->ri_hostname, ri->ri_port, 0 );
return -1;
}

8
servers/slurpd/ri.c
View file

@ -60,7 +60,7 @@ Ri_process(
while ( !sglob->slurpd_shutdown &&
(( re = rq->rq_gethead( rq )) == NULL )) {
/* No work - wait on condition variable */
pthread_cond_wait( &rq->rq_more, &rq->rq_mutex );
ldap_pvt_thread_cond_wait( &rq->rq_more, &rq->rq_mutex );
}
/*
@ -84,7 +84,7 @@ Ri_process(
rc = do_ldap( ri, re, &errmsg );
switch ( rc ) {
case DO_LDAP_ERR_RETRYABLE:
tsleep( RETRY_SLEEP_TIME );
ldap_pvt_thread_sleep( RETRY_SLEEP_TIME );
Debug( LDAP_DEBUG_ANY,
"Retrying operation for DN %s on replica %s:%d\n",
re->re_dn, ri->ri_hostname, ri->ri_port );
@ -118,7 +118,7 @@ Ri_process(
return 0;
}
/* No work - wait on condition variable */
pthread_cond_wait( &rq->rq_more, &rq->rq_mutex );
ldap_pvt_thread_cond_wait( &rq->rq_more, &rq->rq_mutex );
}
re->re_decrefcnt( re );
re = new_re;
@ -143,7 +143,7 @@ Ri_wake(
if ( ri == NULL ) {
return;
}
pthread_kill( ri->ri_tid, LDAP_SIGUSR1 );
ldap_pvt_thread_kill( ri->ri_tid, LDAP_SIGUSR1 );
(void) SIGNAL( LDAP_SIGUSR1, do_nothing );
}

10
servers/slurpd/rq.c
View file

@ -49,7 +49,7 @@ Rq_lock(
Rq *rq
)
{
return( pthread_mutex_lock( &rq->rq_mutex ));
return( ldap_pvt_thread_mutex_lock( &rq->rq_mutex ));
}
@ -61,7 +61,7 @@ Rq_unlock(
Rq *rq
)
{
return( pthread_mutex_unlock( &rq->rq_mutex ));
return( ldap_pvt_thread_mutex_unlock( &rq->rq_mutex ));
}
@ -184,7 +184,7 @@ Rq_add(
/* Increment count of items in queue */
rq->rq_nre++;
/* wake up any threads waiting for more work */
pthread_cond_broadcast( &rq->rq_more );
ldap_pvt_thread_cond_broadcast( &rq->rq_more );
/* ... and unlock the queue */
rq->rq_unlock( rq );
@ -397,8 +397,8 @@ Rq_init(
(*rq)->rq_getcount = Rq_getcount;
/* Initialize private data */
pthread_mutex_init( &((*rq)->rq_mutex), pthread_mutexattr_default );
pthread_cond_init( &((*rq)->rq_more), pthread_condattr_default );
ldap_pvt_thread_mutex_init( &((*rq)->rq_mutex) );
ldap_pvt_thread_cond_init( &((*rq)->rq_more) );
(*rq)->rq_head = NULL;
(*rq)->rq_tail = NULL;
(*rq)->rq_nre = 0;

14
servers/slurpd/slurp.h
View file

@ -27,11 +27,11 @@
#include "lber.h"
#include "ldap.h"
#include "lthread.h"
#include "ldap_pvt_thread.h"
#include "ldapconfig.h"
#include "ldif.h"
/* Default directory for slurpd's private copy of replication logs */
#define DEFAULT_SLURPD_REPLICA_DIR "/usr/tmp"
@ -180,7 +180,7 @@ struct ri {
struct stel *ri_stel; /* pointer to Stel for this replica */
unsigned long
ri_seq; /* seq number of last repl */
pthread_t ri_tid; /* ID of thread for this replica */
ldap_pvt_thread_t ri_tid; /* ID of thread for this replica */
/* Member functions */
int (*ri_process) LDAP_P(( Ri * )); /* process the next repl entry */
@ -214,7 +214,7 @@ typedef struct re Re;
struct re {
/* Private data */
pthread_mutex_t
ldap_pvt_thread_mutex_t
re_mutex; /* mutex for this Re */
int re_refcnt; /* ref count, 0 = done */
char *re_timestamp; /* timestamp of this re */
@ -259,9 +259,9 @@ struct rq {
time_t rq_lasttrim; /* Last time we trimmed file */
/* Public data */
pthread_mutex_t
ldap_pvt_thread_mutex_t
rq_mutex; /* mutex for whole queue */
pthread_cond_t
ldap_pvt_thread_cond_t
rq_more; /* condition var - more work added */
/* Member functions */
@ -306,7 +306,7 @@ typedef struct stel {
typedef struct st St;
struct st {
/* Private data */
pthread_mutex_t
ldap_pvt_thread_mutex_t
st_mutex; /* mutex to serialize access */
Stel **st_data; /* array of pointers to Stel structs */
int st_nreplicas; /* number of repl hosts */

36
servers/slurpd/st.c
View file

@ -43,19 +43,19 @@ St_add(
}
/* Serialize access to the St struct */
pthread_mutex_lock( &(st->st_mutex ));
ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
st->st_nreplicas++;
ind = st->st_nreplicas - 1;
st->st_data = ( Stel ** ) ch_realloc( st->st_data,
( st->st_nreplicas * sizeof( Stel * )));
if ( st->st_data == NULL ) {
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return NULL;
}
st->st_data[ ind ] = ( Stel * ) ch_malloc( sizeof( Stel ) );
if ( st->st_data[ ind ] == NULL ) {
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return NULL;
}
@ -64,7 +64,7 @@ St_add(
memset( st->st_data[ ind ]->last, 0, sizeof( st->st_data[ ind ]->last ));
st->st_data[ ind ]->seq = 0;
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return st->st_data[ ind ];
}
@ -85,7 +85,7 @@ St_write (
if ( st == NULL ) {
return -1;
}
pthread_mutex_lock( &(st->st_mutex ));
ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
if ( st->st_fp == NULL ) {
/* Open file */
if (( rc = acquire_lock( sglob->slurpd_status_file, &(st->st_fp),
@ -95,7 +95,7 @@ St_write (
"Error: cannot open status file \"%s\": %s\n",
sglob->slurpd_status_file, sys_errlist[ errno ], 0 );
st->st_err_logged = 1;
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return -1;
}
} else {
@ -113,7 +113,7 @@ St_write (
}
fflush( st->st_fp );
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return 0;
}
@ -135,10 +135,10 @@ St_update(
return -1;
}
pthread_mutex_lock( &(st->st_mutex ));
ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
strcpy( stel->last, re->re_timestamp );
stel->seq = re->re_seq;
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return 0;
}
@ -164,7 +164,7 @@ St_read(
if ( st == NULL ) {
return -1;
}
pthread_mutex_lock( &(st->st_mutex ));
ldap_pvt_thread_mutex_lock( &(st->st_mutex ));
if ( access( sglob->slurpd_status_file, F_OK ) < 0 ) {
/*
* File doesn't exist, so create it and return.
@ -172,17 +172,17 @@ St_read(
if (( fp = fopen( sglob->slurpd_status_file, "w" )) == NULL ) {
Debug( LDAP_DEBUG_ANY, "Error: cannot create status file \"%s\"\n",
sglob->slurpd_status_file, 0, 0 );
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return -1;
}
(void) fclose( fp );
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
Debug( LDAP_DEBUG_ARGS, "No status file found, defaulting values\n",
0, 0, 0 );
return 0;
}
if (( rc = acquire_lock( sglob->slurpd_status_file, &fp, &lfp)) < 0 ) {
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return 0;
}
while ( fgets( buf, sizeof( buf ), fp ) != NULL ) {
@ -232,12 +232,12 @@ St_read(
}
}
(void) relinquish_lock( sglob->slurpd_status_file, fp, lfp);
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return 0;
bad:
(void) relinquish_lock( sglob->slurpd_status_file, fp, lfp);
pthread_mutex_unlock( &(st->st_mutex ));
ldap_pvt_thread_mutex_unlock( &(st->st_mutex ));
return -1;
}
@ -252,7 +252,7 @@ St_lock(
St *st
)
{
return( pthread_mutex_lock( &st->st_mutex ));
return( ldap_pvt_thread_mutex_lock( &st->st_mutex ));
}
@ -266,7 +266,7 @@ St_unlock(
St *st
)
{
return( pthread_mutex_unlock( &st->st_mutex ));
return( ldap_pvt_thread_mutex_unlock( &st->st_mutex ));
}
@ -289,7 +289,7 @@ St_init(
return -1;
}
pthread_mutex_init( &((*st)->st_mutex), pthread_mutexattr_default );
ldap_pvt_thread_mutex_init( &((*st)->st_mutex) );
(*st)->st_data = NULL;
(*st)->st_fp = NULL;
(*st)->st_lfp = NULL;

158
servers/slurpd/tsleep.c
View file

@ -1,158 +0,0 @@
/*
* Copyright (c) 1996 Regents of the University of Michigan.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that this notice is preserved and that due credit is given
* to the University of Michigan at Ann Arbor. The name of the University
* may not be used to endorse or promote products derived from this
* software without specific prior written permission. This software
* is provided ``as is'' without express or implied warranty.
*/
/*
* tsleep.c - allow a thread to sleep without putting the whole process
* (e.g. pod under lwp) to sleep. Contains platform-specific code to
* allow this:
*
* Under non-preemptive threads packages like SunOS lwp, tsleep() adds
* the thread to a list of sleepers. The lwp_scheduler process takes
* care of resuming suspended threads.
*
* Under a fully-preemptive threads package, like Solaris threads,
* tsleep just calls sleep(), and there is no scheduler thread. Life
* is so much simpler...
*/
#include "portable.h"
#include <stdio.h>
#include <stdlib.h>
#include <ac/unistd.h> /* get sleep() */
#include "slurp.h"
#include "globals.h"
#if defined( HAVE_LWP )
int
tsleep(
time_t interval
)
{
thread_t mylwp;
tl_t *t, *nt;
time_t now;
if ( lwp_self( &mylwp ) < 0 ) {
return -1;
}
time( &now );
mon_enter( &sglob->tsl_mon );
if ( sglob->tsl_list != NULL ) {
for ( t = sglob->tsl_list; t != NULL; t = t->tl_next ) {
if ( SAMETHREAD( t->tl_tid, mylwp )) {
/* We're already sleeping? */
t->tl_wake = now + interval;
mon_exit( &sglob->tsl_mon );
lwp_suspend( mylwp );
return 0;
}
}
}
nt = (tl_t *) malloc( sizeof( tl_t ));
nt->tl_next = sglob->tsl_list;
nt->tl_wake = now + interval;
nt->tl_tid = mylwp;
sglob->tsl_list = nt;
mon_exit( &sglob->tsl_mon );
lwp_suspend( mylwp );
return 0;
}
/*
* The lwp_scheduler thread periodically checks to see if any threads
* are due to be resumed. If there are, it resumes them. Otherwise,
* it computes the lesser of ( 1 second ) or ( the minimum time until
* a thread need to be resumed ) and puts itself to sleep for that amount
* of time.
*/
void
lwp_scheduler(
int stackno
)
{
time_t now, min;
struct timeval interval;
tl_t *t;
while ( !sglob->slurpd_shutdown ) {
mon_enter( &sglob->tsl_mon );
time( &now );
min = 0L;
if ( sglob->tsl_list != NULL ) {
for ( t = sglob->tsl_list; t != NULL; t = t->tl_next ) {
if (( t->tl_wake > 0L ) && ( t->tl_wake < now )) {
lwp_resume( t->tl_tid );
t->tl_wake = 0L;
}
if (( t->tl_wake > now ) && ( t->tl_wake < min )) {
min = t->tl_wake;
}
}
}
mon_exit( &sglob->tsl_mon );
interval.tv_usec = 0L;
if ( min == 0L ) {
interval.tv_sec = 1L;
} else {
interval.tv_sec = min;
}
lwp_sleep( &interval );
}
mon_enter( &sglob->tsl_mon );
for ( t = sglob->tsl_list; t != NULL; t = t->tl_next ) {
lwp_resume( t->tl_tid );
}
mon_exit( &sglob->tsl_mon );
free_stack( stackno );
}
/*
* Create the lwp_scheduler thread.
*/
void
start_lwp_scheduler( void )
{
thread_t tid;
stkalign_t *stack;
int stackno;
if (( stack = get_stack( &stackno )) == NULL ) {
return;
}
lwp_create( &tid, lwp_scheduler, MINPRIO, 0, stack, 1, stackno );
return;
}
#else /* !HAVE_LWP */
/*
* Here we assume we have fully preemptive threads, and that sleep()
* does the right thing.
*/
int
tsleep(
time_t interval
)
{
sleep( interval );
return 0;
}
#endif /* !HAVE_LWP */