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

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