From 73b846c0112a78033b93f647b85f1bfaa5ee97f2 Mon Sep 17 00:00:00 2001 From: Kurt Zeilenga Date: Tue, 6 Apr 1999 21:57:16 +0000 Subject: [PATCH] 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 | 2 + libraries/libldap_r/thr_cthreads.c | 6 ++ libraries/libldap_r/thr_lwp.c | 117 ++++++++++++++++++++++++++++- libraries/libldap_r/thr_nt.c | 6 ++ libraries/libldap_r/thr_posix.c | 6 ++ libraries/libldap_r/thr_sleep.c | 100 +----------------------- libraries/libldap_r/thr_stub.c | 6 ++ libraries/libldap_r/thr_thr.c | 6 ++ servers/slapd/init.c | 2 + servers/slurpd/main.c | 4 + 10 files changed, 153 insertions(+), 102 deletions(-) diff --git a/include/ldap_pvt_thread.h b/include/ldap_pvt_thread.h index 6024713bbc..d0d0b597fb 100644 --- a/include/ldap_pvt_thread.h +++ b/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 )); diff --git a/libraries/libldap_r/thr_cthreads.c b/libraries/libldap_r/thr_cthreads.c index 6eddb69317..a52c406a9c 100644 --- a/libraries/libldap_r/thr_cthreads.c +++ b/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, diff --git a/libraries/libldap_r/thr_lwp.c b/libraries/libldap_r/thr_lwp.c index 27be3a8d19..f9bc0b415f 100644 --- a/libraries/libldap_r/thr_lwp.c +++ b/libraries/libldap_r/thr_lwp.c @@ -25,6 +25,9 @@ * SunOS LWP * * * *************/ + +/* This implementation NEEDS WORK. It currently does not compile */ + #include #include @@ -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 ) { diff --git a/libraries/libldap_r/thr_nt.c b/libraries/libldap_r/thr_nt.c index f6be8e6ad0..1a884eba07 100644 --- a/libraries/libldap_r/thr_nt.c +++ b/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, diff --git a/libraries/libldap_r/thr_posix.c b/libraries/libldap_r/thr_posix.c index 96c5e8be99..da8ef99c43 100644 --- a/libraries/libldap_r/thr_posix.c +++ b/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) diff --git a/libraries/libldap_r/thr_sleep.c b/libraries/libldap_r/thr_sleep.c index 97ad586424..b6328fcd70 100644 --- a/libraries/libldap_r/thr_sleep.c +++ b/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 */ diff --git a/libraries/libldap_r/thr_stub.c b/libraries/libldap_r/thr_stub.c index 0b8f661d5b..7cd8e5f6be 100644 --- a/libraries/libldap_r/thr_stub.c +++ b/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 diff --git a/libraries/libldap_r/thr_thr.c b/libraries/libldap_r/thr_thr.c index 54f2b6ba94..29a6c390a2 100644 --- a/libraries/libldap_r/thr_thr.c +++ b/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) { diff --git a/servers/slapd/init.c b/servers/slapd/init.c index c807014185..0990d4b533 100644 --- a/servers/slapd/init.c +++ b/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; } diff --git a/servers/slurpd/main.c b/servers/slurpd/main.c index 3e3c811756..719633954a 100644 --- a/servers/slurpd/main.c +++ b/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; -- 2.39.5