Add ldap_pvt_thread_destory() to un-ldap_pvt_thread_initialize().

Move all SunOS routines (ie: _sleep() and its helpers) to thr_lwp.c
so that it's internals can be 'static'.  Add 'static' to thr_lwp.c.
Add comment to LWP:  NEEDS WORK, may not compile!  Need some
SunOS user to sort out the details.  Volunteers?

include/ldap_pvt_thread.h

@@ -163,6 +163,8 @@ LDAP_BEGIN_DECL
 
 LDAP_F int
 ldap_pvt_thread_initialize LDAP_P(( void ));
+LDAP_F int
+ldap_pvt_thread_destory LDAP_P(( void ));
 
 LDAP_F unsigned int
 ldap_pvt_thread_sleep LDAP_P(( unsigned int s ));

libraries/libldap_r/thr_cthreads.c

@@ -28,6 +28,12 @@ ldap_pvt_thread_initialize( void )
 	return 0;
 }
 
+int
+ldap_pvt_thread_destroy( void )
+{
+	return 0;
+}
+
 int 
 ldap_pvt_thread_create( ldap_pvt_thread_t * thread, 
 	int detach,

libraries/libldap_r/thr_lwp.c

@@ -25,6 +25,9 @@
  * SunOS LWP *
  *           *
  *************/
+
+/* This implementation NEEDS WORK.   It currently does not compile */
+
 #include <stdio.h>
 
 #include <ac/time.h>
@@ -58,6 +61,14 @@ ldap_pvt_thread_initialize( void )
 	return 0;
 }
 
+int
+ldap_pvt_thread_destroy( void )
+{
+	/* need to destory lwp_scheduler thread and clean up private
+		variables */
+	return 0;
+}
+
 struct stackinfo {
 	int		stk_inuse;
 	stkalign_t	*stk_stack;
@@ -65,7 +76,7 @@ struct stackinfo {
 
 static struct stackinfo	*stacks;
 
-stkalign_t * ldap_pvt_thread_get_stack( int *stacknop )
+static stkalign_t * ldap_pvt_thread_get_stack( int *stacknop )
 {
 	int	i;
 
@@ -98,7 +109,7 @@ stkalign_t * ldap_pvt_thread_get_stack( int *stacknop )
 	return( stacks[i].stk_stack + MAX_STACK / sizeof(stkalign_t) );
 }
 
-void
+static void
 ldap_pvt_thread_free_stack( int	stackno )
 {
 	if ( stackno < 0 || stackno > MAX_THREADS ) {
@@ -109,7 +120,7 @@ ldap_pvt_thread_free_stack( int	stackno )
 	stacks[stackno].stk_inuse = 0;
 }
 
-static void
+static static void
 lwp_create_stack( void *(*func)(), void *arg, int stackno )
 {
 	(*func)( arg );
@@ -139,6 +150,106 @@ ldap_pvt_thread_exit( void *retval )
 	lwp_destroy( SELF );
 }
 
+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.
+ */
+static 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 );
+}
+
 int 
 ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
 {

libraries/libldap_r/thr_nt.c

@@ -22,6 +22,12 @@ ldap_pvt_thread_initialize( void )
 	return 0;
 }
 
+int
+ldap_pvt_thread_destroy( void )
+{
+	return 0;
+}
+
 int 
 ldap_pvt_thread_create( ldap_pvt_thread_t * thread, 
 	int detach,

libraries/libldap_r/thr_posix.c

@@ -39,6 +39,12 @@ ldap_pvt_thread_initialize( void )
 	return 0;
 }
 
+int
+ldap_pvt_thread_destroy( void )
+{
+	return 0;
+}
+
 #ifdef HAVE_PTHREAD_SETCONCURRENCY
 int
 ldap_pvt_thread_set_concurrency(int n)

libraries/libldap_r/thr_sleep.c

@@ -50,104 +50,6 @@ ldap_pvt_thread_sleep(
 
 #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 );
-}
+/* LWP implementation of sleep can be found in thr_lwp.c */
 
 #endif /* HAVE_LWP */

libraries/libldap_r/thr_stub.c

@@ -28,6 +28,12 @@ ldap_pvt_thread_initialize( void )
 	return 0;
 }
 
+int
+ldap_pvt_thread_destroy( void )
+{
+	return 0;
+}
+
 static void* ldap_int_status = NULL;
 
 int 

libraries/libldap_r/thr_thr.c

@@ -30,6 +30,12 @@ ldap_pvt_thread_initialize( void )
 	return 0;
 }
 
+int
+ldap_pvt_thread_destroy( void )
+{
+	return 0;
+}
+
 int
 ldap_pvt_thread_set_concurrency(int n)
 {

servers/slapd/init.c

@@ -154,6 +154,8 @@ int slap_destroy(void)
 
 	rc = backend_destroy();
 
+	ldap_pvt_thread_destroy();
+
 	/* should destory the above mutex */
 	return rc;
 }

servers/slurpd/main.c

@@ -125,6 +125,10 @@ main(
     for ( i = 0; sglob->replicas[ i ] != NULL; i++ ) {
 	ldap_pvt_thread_join( sglob->replicas[ i ]->ri_tid, (void *) NULL );
     }
+
+	/* destroy the thread package */
+	ldap_pvt_thread_destroy();
+
     Debug( LDAP_DEBUG_ANY, "slurpd: terminating normally\n", 0, 0, 0 );
     sglob->slurpd_shutdown = 1;