git.sur5r.net Git - openldap/blob - libraries/libldap_r/thr_posix.c

   1 /*
   2  * Copyright 1998,1999 The OpenLDAP Foundation, Redwood City, California, USA
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms are permitted only
   6  * as authorized by the OpenLDAP Public License.  A copy of this
   7  * license is available at http://www.OpenLDAP.org/license.html or
   8  * in file LICENSE in the top-level directory of the distribution.
   9  */
  10
  11 /* thr_posix.c - wrapper around posix and posixish thread implementations.
  12  */
  13
  14 #include "portable.h"
  15 #include "ldap_pvt_thread.h"
  16
  17 #if defined( HAVE_PTHREADS )
  18
  19 int
  20 ldap_pvt_thread_create( ldap_pvt_thread_t * thread,
  21                         ldap_pvt_thread_attr_t *attr,
  22                        void *(*start_routine)( void *), void *arg)
  23 {
  24 #if !defined( HAVE_PTHREADS_D4 )
  25         /* This is a standard pthreads implementation. */
  26         return pthread_create( thread, attr, start_routine, arg );
  27 #else
  28         /* This is a draft 4 or earlier implementation. */
  29         return pthread_create( thread, *attr, start_routine, arg );
  30 #endif
  31 }
  32
  33 void
  34 ldap_pvt_thread_exit( void *retval )
  35 {
  36         pthread_exit( retval );
  37 }
  38
  39 int
  40 ldap_pvt_thread_join( ldap_pvt_thread_t thread, void **thread_return )
  41 {
  42 #if !defined( HAVE_PTHREADS_FINAL )
  43         void *dummy;
  44         if (thread_return==NULL)
  45           thread_return=&dummy;
  46 #endif
  47         return pthread_join( thread, thread_return );
  48 }
  49
  50 int
  51 ldap_pvt_thread_kill( ldap_pvt_thread_t thread, int signo )
  52 {
  53 #ifdef HAVE_PTHREAD_KILL
  54         return pthread_kill( thread, signo );
  55 #else
  56         /* pthread package with DCE */
  57         if (kill( getpid(), sig )<0)
  58                 return errno;
  59         return 0;
  60 #endif
  61 }
  62
  63 int
  64 ldap_pvt_thread_yield( void )
  65 {
  66 #ifdef HAVE_SCHED_YIELD
  67         return sched_yield();
  68 #else
  69         return pthread_yield();
  70 #endif
  71 }
  72
  73 int
  74 ldap_pvt_thread_attr_init( ldap_pvt_thread_attr_t *attr )
  75 {
  76 #if defined( HAVE_PTHREAD_ATTR_INIT )
  77         return pthread_attr_init( attr );
  78 #elif defined( HAVE_PTHREAD_ATTR_CREATE )
  79         return pthread_attr_create( attr );
  80 #else
  81         No way to init attr, so cause an error.
  82 #endif
  83 }
  84
  85 int
  86 ldap_pvt_thread_attr_destroy( ldap_pvt_thread_attr_t *attr )
  87 {
  88 #if defined( HAVE_PTHREAD_ATTR_DESTROY )
  89         return pthread_attr_destroy( attr );
  90 #elif defined( HAVE_PTHREAD_ATTR_DELETE )
  91         return pthread_attr_delete( attr );
  92 #else
  93         No way to destroy attr, so cause an error.
  94 #endif
  95 }
  96
  97 int
  98 ldap_pvt_thread_attr_setdetachstate( ldap_pvt_thread_attr_t *attr, int dstate )
  99 {
 100 #if defined( HAVE_PTHREAD_ATTR_SETDETACHSTATE )
 101         return pthread_attr_setdetachstate( attr, dstate );
 102 #elif defined( HAVE_PTHREAD_ATTR_SETDETACH_NP )
 103         return pthread_attr_setdetach_np( attr, dstate );
 104 #else
 105         No way to set state, so cause an error.
 106 #endif
 107 }
 108
 109 int
 110 ldap_pvt_thread_cond_init( ldap_pvt_thread_cond_t *cond,
 111                           ldap_pvt_thread_condattr_t *attr )
 112 {
 113 #if defined( HAVE_PTHREADS_D4 )
 114         return pthread_cond_init( cond,
 115                                  attr ? attr : pthread_condattr_default );
 116 #else
 117         return pthread_cond_init( cond, attr );
 118 #endif
 119 }
 120
 121 int
 122 ldap_pvt_thread_cond_signal( ldap_pvt_thread_cond_t *cond )
 123 {
 124         return pthread_cond_signal( cond );
 125 }
 126
 127 int
 128 ldap_pvt_thread_cond_broadcast( ldap_pvt_thread_cond_t *cond )
 129 {
 130         return pthread_cond_broadcast( cond );
 131 }
 132
 133 int
 134 ldap_pvt_thread_cond_wait( ldap_pvt_thread_cond_t *cond,
 135                       ldap_pvt_thread_mutex_t *mutex )
 136 {
 137         return pthread_cond_wait( cond, mutex );
 138 }
 139
 140 int
 141 ldap_pvt_thread_mutex_init( ldap_pvt_thread_mutex_t *mutex,
 142                            ldap_pvt_thread_mutexattr_t *attr )
 143 {
 144 #if defined( HAVE_PTHREADS_D4 )
 145         return pthread_mutex_init( mutex,
 146                                   attr ? attr : pthread_mutexattr_default );
 147 #else
 148         return pthread_mutex_init( mutex, attr );
 149 #endif
 150 }
 151
 152 int
 153 ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
 154 {
 155         return pthread_mutex_destroy( mutex );
 156 }
 157
 158 int
 159 ldap_pvt_thread_mutex_lock( ldap_pvt_thread_mutex_t *mutex )
 160 {
 161         return pthread_mutex_lock( mutex );
 162 }
 163
 164 int
 165 ldap_pvt_thread_mutex_unlock( ldap_pvt_thread_mutex_t *mutex )
 166 {
 167         return pthread_mutex_unlock( mutex );
 168 }
 169
 170 #endif /* HAVE_PTHREADS */
 171