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

   1 /* $OpenLDAP$ */
   2 /*
   3 ** This is an improved implementation of Reader/Writer locks does
   4 ** not protect writers from starvation.  That is, if a writer is
   5 ** currently waiting on a reader, any new reader will get
   6 ** the lock before the writer.
   7 **
   8 ** Does not support cancellation nor does any status checking.
   9 */
  10 /* Adapted from publically available examples for:
  11  *      "Programming with Posix Threads"
  12  *              by David R Butenhof, Addison-Wesley
  13  *              http://cseng.aw.com/bookpage.taf?ISBN=0-201-63392-2
  14  */
  15
  16 #include "portable.h"
  17
  18 #include <ac/stdlib.h>
  19
  20 #include <ac/errno.h>
  21 #include <ac/string.h>
  22 #include <ac/time.h>
  23
  24 #include "ldap-int.h"
  25 #include "ldap_pvt_thread.h"
  26
  27 /*
  28  * implementations that provide their own compatible
  29  * reader/writer locks define LDAP_THREAD_HAVE_RDWR
  30  * in ldap_pvt_thread.h
  31  */
  32 #ifndef LDAP_THREAD_HAVE_RDWR
  33
  34 struct ldap_int_thread_rdwr_s {
  35         ldap_pvt_thread_mutex_t ltrw_mutex;
  36         ldap_pvt_thread_cond_t ltrw_read;       /* wait for read */
  37         ldap_pvt_thread_cond_t ltrw_write;      /* wait for write */
  38         int ltrw_valid;
  39 #define LDAP_PVT_THREAD_RDWR_VALID 0x0bad
  40         int ltrw_r_active;
  41         int ltrw_w_active;
  42         int ltrw_r_wait;
  43         int ltrw_w_wait;
  44 };
  45
  46 int
  47 ldap_pvt_thread_rdwr_init( ldap_pvt_thread_rdwr_t *rwlock )
  48 {
  49         struct ldap_int_thread_rdwr_s *rw;
  50
  51         assert( rwlock != NULL );
  52
  53         rw = (struct ldap_int_thread_rdwr_s *) LDAP_CALLOC( 1,
  54                 sizeof( struct ldap_int_thread_rdwr_s ) );
  55
  56         /* we should check return results */
  57         ldap_pvt_thread_mutex_init( &rw->ltrw_mutex );
  58         ldap_pvt_thread_cond_init( &rw->ltrw_read );
  59         ldap_pvt_thread_cond_init( &rw->ltrw_write );
  60
  61         rw->ltrw_valid = LDAP_PVT_THREAD_RDWR_VALID;
  62
  63         *rwlock = rw;
  64         return 0;
  65 }
  66
  67 int
  68 ldap_pvt_thread_rdwr_destroy( ldap_pvt_thread_rdwr_t *rwlock )
  69 {
  70         struct ldap_int_thread_rdwr_s *rw;
  71
  72         assert( rwlock != NULL );
  73         rw = *rwlock;
  74
  75         assert( rw != NULL );
  76         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
  77
  78         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
  79                 return LDAP_PVT_THREAD_EINVAL;
  80
  81         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
  82
  83         /* active threads? */
  84         if( rw->ltrw_r_active > 0 || rw->ltrw_w_active > 0) {
  85                 ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
  86                 return LDAP_PVT_THREAD_EBUSY;
  87         }
  88
  89         /* waiting threads? */
  90         if( rw->ltrw_r_wait > 0 || rw->ltrw_w_wait > 0) {
  91                 ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
  92                 return LDAP_PVT_THREAD_EBUSY;
  93         }
  94
  95         rw->ltrw_valid = 0;
  96
  97         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
  98
  99         ldap_pvt_thread_mutex_destroy( &rw->ltrw_mutex );
 100         ldap_pvt_thread_cond_destroy( &rw->ltrw_read );
 101         ldap_pvt_thread_cond_destroy( &rw->ltrw_write );
 102
 103         LDAP_FREE(rw);
 104         *rwlock = NULL;
 105         return 0;
 106 }
 107
 108 int ldap_pvt_thread_rdwr_rlock( ldap_pvt_thread_rdwr_t *rwlock )
 109 {
 110         struct ldap_int_thread_rdwr_s *rw;
 111
 112         assert( rwlock != NULL );
 113         rw = *rwlock;
 114
 115         assert( rw != NULL );
 116         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 117
 118         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 119                 return LDAP_PVT_THREAD_EINVAL;
 120
 121         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 122
 123         if( rw->ltrw_w_active > 0 ) {
 124                 /* writer is active */
 125
 126                 rw->ltrw_r_wait++;
 127
 128                 do {
 129                         ldap_pvt_thread_cond_wait(
 130                                 &rw->ltrw_read, &rw->ltrw_mutex );
 131                 } while( rw->ltrw_w_active > 0 );
 132
 133                 rw->ltrw_r_wait--;
 134         }
 135
 136         rw->ltrw_r_active++;
 137
 138         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 139
 140         return 0;
 141 }
 142
 143 int ldap_pvt_thread_rdwr_rtrylock( ldap_pvt_thread_rdwr_t *rwlock )
 144 {
 145         struct ldap_int_thread_rdwr_s *rw;
 146
 147         assert( rwlock != NULL );
 148         rw = *rwlock;
 149
 150         assert( rw != NULL );
 151         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 152
 153         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 154                 return LDAP_PVT_THREAD_EINVAL;
 155
 156         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 157
 158         if( rw->ltrw_w_active > 0) {
 159                 ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 160                 return LDAP_PVT_THREAD_EBUSY;
 161         }
 162
 163         rw->ltrw_r_active++;
 164
 165         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 166
 167         return 0;
 168 }
 169
 170 int ldap_pvt_thread_rdwr_runlock( ldap_pvt_thread_rdwr_t *rwlock )
 171 {
 172         struct ldap_int_thread_rdwr_s *rw;
 173
 174         assert( rwlock != NULL );
 175         rw = *rwlock;
 176
 177         assert( rw != NULL );
 178         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 179
 180         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 181                 return LDAP_PVT_THREAD_EINVAL;
 182
 183         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 184
 185         rw->ltrw_r_active--;
 186
 187         if (rw->ltrw_r_active == 0 && rw->ltrw_w_wait > 0 ) {
 188                 ldap_pvt_thread_cond_signal( &rw->ltrw_write );
 189         }
 190
 191         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 192
 193         return 0;
 194 }
 195
 196 int ldap_pvt_thread_rdwr_wlock( ldap_pvt_thread_rdwr_t *rwlock )
 197 {
 198         struct ldap_int_thread_rdwr_s *rw;
 199
 200         assert( rwlock != NULL );
 201         rw = *rwlock;
 202
 203         assert( rw != NULL );
 204         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 205
 206         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 207                 return LDAP_PVT_THREAD_EINVAL;
 208
 209         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 210
 211         if ( rw->ltrw_w_active > 0 || rw->ltrw_r_active > 0 ) {
 212                 rw->ltrw_w_wait++;
 213
 214                 do {
 215                         ldap_pvt_thread_cond_wait(
 216                                 &rw->ltrw_write, &rw->ltrw_mutex );
 217                 } while ( rw->ltrw_w_active > 0 || rw->ltrw_r_active > 0 );
 218
 219                 rw->ltrw_w_wait--;
 220         }
 221
 222         rw->ltrw_w_active++;
 223
 224         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 225
 226         return 0;
 227 }
 228
 229 int ldap_pvt_thread_rdwr_wtrylock( ldap_pvt_thread_rdwr_t *rwlock )
 230 {
 231         struct ldap_int_thread_rdwr_s *rw;
 232
 233         assert( rwlock != NULL );
 234         rw = *rwlock;
 235
 236         assert( rw != NULL );
 237         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 238
 239         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 240                 return LDAP_PVT_THREAD_EINVAL;
 241
 242         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 243
 244         if ( rw->ltrw_w_active > 0 || rw->ltrw_r_active > 0 ) {
 245                 ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 246                 return LDAP_PVT_THREAD_EBUSY;
 247         }
 248
 249         rw->ltrw_w_active++;
 250
 251         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 252
 253         return 0;
 254 }
 255
 256 int ldap_pvt_thread_rdwr_wunlock( ldap_pvt_thread_rdwr_t *rwlock )
 257 {
 258         struct ldap_int_thread_rdwr_s *rw;
 259
 260         assert( rwlock != NULL );
 261         rw = *rwlock;
 262
 263         assert( rw != NULL );
 264         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 265
 266         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 267                 return LDAP_PVT_THREAD_EINVAL;
 268
 269         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 270
 271         rw->ltrw_w_active--;
 272
 273         if (rw->ltrw_r_wait > 0) {
 274                 ldap_pvt_thread_cond_broadcast( &rw->ltrw_read );
 275
 276         } else if (rw->ltrw_w_wait > 0) {
 277                 ldap_pvt_thread_cond_signal( &rw->ltrw_write );
 278         }
 279
 280         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 281
 282         return 0;
 283 }
 284
 285 #ifdef LDAP_RDWR_DEBUG
 286
 287 /* just for testing,
 288  * return 0 if false, suitable for assert(ldap_pvt_thread_rdwr_Xchk(rdwr))
 289  *
 290  * Currently they don't check if the calling thread is the one
 291  * that has the lock, just that there is a reader or writer.
 292  *
 293  * Basically sufficent for testing that places that should have
 294  * a lock are caught.
 295  */
 296
 297 int ldap_pvt_thread_rdwr_readers(ldap_pvt_thread_rdwr_t *rwlock)
 298 {
 299         struct ldap_int_thread_rdwr_s *rw;
 300
 301         assert( rwlock != NULL );
 302         rw = *rwlock;
 303
 304         assert( rw != NULL );
 305         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 306
 307         return( rw->ltrw_r_active );
 308 }
 309
 310 int ldap_pvt_thread_rdwr_writers(ldap_pvt_thread_rdwr_t *rwlock)
 311 {
 312         struct ldap_int_thread_rdwr_s *rw;
 313
 314         assert( rwlock != NULL );
 315         rw = *rwlock;
 316
 317         assert( rw != NULL );
 318         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 319
 320         return( rw->ltrw_w_active );
 321 }
 322
 323 int ldap_pvt_thread_rdwr_active(ldap_pvt_thread_rdwr_t *rwlock)
 324 {
 325         struct ldap_int_thread_rdwr_s *rw;
 326
 327         assert( rwlock != NULL );
 328         rw = *rwlock;
 329
 330         assert( rw != NULL );
 331         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 332
 333         return(ldap_pvt_thread_rdwr_readers(rw) +
 334                ldap_pvt_thread_rdwr_writers(rw));
 335 }
 336
 337 #endif /* LDAP_DEBUG */
 338
 339 #endif /* LDAP_THREAD_HAVE_RDWR */