X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Fliblthread%2Fthread.c;h=af2a14eb88ca0abdbcd8a5516006e84f24d9ab45;hb=61e8984d7aaaada398c84bdd60d33bcba2c940e5;hp=89a85c70b44872819dda6da7b229cd9923323b94;hpb=42e0d83cb3a1a1c5b25183f1ab74ce7edbe25de7;p=openldap diff --git a/libraries/liblthread/thread.c b/libraries/liblthread/thread.c index 89a85c70b4..af2a14eb88 100644 --- a/libraries/liblthread/thread.c +++ b/libraries/liblthread/thread.c @@ -1,17 +1,35 @@ /* thread.c - glue routines to provide a consistent thread interface */ -#include -#include "lthread.h" -#if defined( THREAD_SUNOS4_LWP ) +#include "portable.h" +#include + +#if defined( HAVE_PTHREADS ) + +#ifndef HAVE_PTHREAD_KILL /*********************************************************************** * * - * under sunos 4 - use the built in non-preemptive lwp threads package * + * pthreads package with DCE - no mapping to do (except to create a * + * pthread_kill() routine) * * * ***********************************************************************/ -extern stkalign_t *get_stack(); -static void lwp_create_stack(); +/* ARGSUSED */ +void +pthread_kill( pthread_t tid, int sig ) +{ + kill( getpid(), sig ); +} +#endif /* HAVE_PTHREAD_KILL */ + +#elif defined( HAVE_MACH_CTHREADS ) + +/*********************************************************************** + * * + * under NEXTSTEP or OPENSTEP use CThreads * + * lukeh@xedoc.com.au * + * * + ***********************************************************************/ int pthread_attr_init( pthread_attr_t *attr ) @@ -44,19 +62,282 @@ pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) int pthread_create( pthread_t *tid, - pthread_attr_t attr, + pthread_attr_t *attr, VFP func, void *arg ) { - stkalign_t *stack; - int stackno; + *tid = cthread_fork(func, arg); + return ( *tid == NULL ? -1 : 0 ); +} - 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 ) +{ + 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 * + * * + *******************/ + +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 ) ); +} + +void +pthread_yield( void ) +{ + thr_yield(); +} + +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 ) ); +} + +#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 @@ -67,8 +348,27 @@ lwp_create_stack( VFP func, void *arg, int stackno ) 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() +pthread_yield( void ) { lwp_yield( SELF ); } @@ -168,15 +468,11 @@ pthread_cond_broadcast( pthread_cond_t *cv ) return( cv->lcv_created ? cv_broadcast( cv->lcv_cv ) : 0 ); } -#else /* end sunos4 */ -# if defined( THREAD_SUNOS5_LWP ) +#elif defined( HAVE_NT_MULTITHREADS ) -/*********************************************************************** - * * - * under sunos 5 - use the built in preemptive solaris threads package * - * * - ***********************************************************************/ +#include +#include int pthread_attr_init( pthread_attr_t *attr ) @@ -188,7 +484,6 @@ pthread_attr_init( pthread_attr_t *attr ) int pthread_attr_destroy( pthread_attr_t *attr ) { - *attr = 0; return( 0 ); } @@ -206,139 +501,130 @@ pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) return( 0 ); } -/* ARGSUSED */ int pthread_create( pthread_t *tid, - pthread_attr_t attr, + pthread_attr_t *attr, VFP func, void *arg ) { - return( thr_create( NULL, 0, func, arg, attr, tid ) ); + *tid = (pthread_t)_beginthread( (void *) func, 0, arg ); + return ( (unsigned long)*tid == -1 ? -1 : 0 ); } void pthread_yield() { - thr_yield(); + } void -pthread_exit() +pthread_exit( void ) { - thr_exit( NULL ); + _endthread( ); } void -pthread_join( pthread_t tid, int *status ) -{ - thr_join( tid, NULL, (void **) status ); +pthread_join( pthread_t tid, int *pStatus ) +{ + DWORD status; + status = WaitForSingleObject( tid, INFINITE ); + if ( pStatus != NULL) + { + if ( status != WAIT_FAILED ) + *pStatus = 0; + else + *pStatus = WAIT_ABANDONED; + } } + void pthread_kill( pthread_t tid, int sig ) { - thr_kill( tid, sig ); + return; } -/* ARGSUSED */ + int pthread_mutex_init( pthread_mutex_t *mp, pthread_mutexattr_t *attr ) { - return( mutex_init( mp, attr ? *attr : USYNC_THREAD, NULL ) ); + *mp = CreateMutex( NULL, 0, NULL ); + return ( 0 ); } int pthread_mutex_destroy( pthread_mutex_t *mp ) { - return( mutex_destroy( mp ) ); + CloseHandle( *mp ); + return ( 0 ); } int pthread_mutex_lock( pthread_mutex_t *mp ) { - return( mutex_lock( mp ) ); + WaitForSingleObject( *mp, INFINITE ); + return ( 0 ); } int pthread_mutex_unlock( pthread_mutex_t *mp ) { - return( mutex_unlock( mp ) ); + ReleaseMutex( *mp ); + return ( 0 ); } int pthread_mutex_trylock( pthread_mutex_t *mp ) { - return( mutex_trylock( mp ) ); + DWORD status; + + status = WaitForSingleObject( *mp, 0 ); + if ( (status == WAIT_FAILED) || (status == WAIT_TIMEOUT) ) + return 0; + else + return 1; } int pthread_cond_init( pthread_cond_t *cv, pthread_condattr_t *attr ) { - return( cond_init( cv, attr ? *attr : USYNC_THREAD, NULL ) ); + *cv = CreateEvent( NULL, FALSE, FALSE, NULL ); + return( 0 ); } int pthread_cond_destroy( pthread_cond_t *cv ) { - return( cond_destroy( cv ) ); + CloseHandle( *cv ); + return( 0 ); } int pthread_cond_wait( pthread_cond_t *cv, pthread_mutex_t *mp ) { - return( cond_wait( cv, mp ) ); + ReleaseMutex( *mp ); + WaitForSingleObject( *cv, INFINITE ); + WaitForSingleObject( *mp, INFINITE ); + return( 0 ); } int pthread_cond_signal( pthread_cond_t *cv ) { - return( cond_signal( cv ) ); + SetEvent( *cv ); + return( 0 ); } int pthread_cond_broadcast( pthread_cond_t *cv ) { - return( cond_broadcast( cv ) ); -} - - -#else /* end sunos5 threads */ - -#if defined( THREAD_MIT_PTHREADS ) - -/*********************************************************************** - * * - * pthreads package by Chris Provenzano of MIT - provides all the * - * pthreads calls already, so no mapping to do * - * * - ***********************************************************************/ - -#else /* end mit pthreads */ - -#if defined( THREAD_DCE_PTHREADS ) - -/*********************************************************************** - * * - * pthreads package with DCE - no mapping to do (except to create a * - * pthread_kill() routine) * - * * - ***********************************************************************/ - -/* ARGSUSED */ -void -pthread_kill( pthread_t tid, int sig ) -{ - kill( getpid(), sig ); + SetEvent( *cv ); + return( 0 ); } -#endif /* dce pthreads */ -#endif /* mit pthreads */ -#endif /* sunos5 lwp */ -#endif /* sunos4 lwp */ - -#ifndef _THREAD +#else /*********************************************************************** * * @@ -379,7 +665,7 @@ pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) int pthread_create( pthread_t *tid, - pthread_attr_t attr, + pthread_attr_t *attr, VFP func, void *arg ) @@ -390,7 +676,7 @@ pthread_create( } void -pthread_yield() +pthread_yield( void ) { return; }