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         assert( rw->ltrw_w_active >= 0 );
  84         assert( rw->ltrw_w_wait >= 0 );
  85         assert( rw->ltrw_r_active >= 0 );
  86         assert( rw->ltrw_r_wait >= 0 );
  87
  88         /* active threads? */
  89         if( rw->ltrw_r_active > 0 || rw->ltrw_w_active > 0) {
  90                 ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
  91                 return LDAP_PVT_THREAD_EBUSY;
  92         }
  93
  94         /* waiting threads? */
  95         if( rw->ltrw_r_wait > 0 || rw->ltrw_w_wait > 0) {
  96                 ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
  97                 return LDAP_PVT_THREAD_EBUSY;
  98         }
  99
 100         rw->ltrw_valid = 0;
 101
 102         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 103
 104         ldap_pvt_thread_mutex_destroy( &rw->ltrw_mutex );
 105         ldap_pvt_thread_cond_destroy( &rw->ltrw_read );
 106         ldap_pvt_thread_cond_destroy( &rw->ltrw_write );
 107
 108         LDAP_FREE(rw);
 109         *rwlock = NULL;
 110         return 0;
 111 }
 112
 113 int ldap_pvt_thread_rdwr_rlock( ldap_pvt_thread_rdwr_t *rwlock )
 114 {
 115         struct ldap_int_thread_rdwr_s *rw;
 116
 117         assert( rwlock != NULL );
 118         rw = *rwlock;
 119
 120         assert( rw != NULL );
 121         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 122
 123         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 124                 return LDAP_PVT_THREAD_EINVAL;
 125
 126         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 127
 128         assert( rw->ltrw_w_active >= 0 );
 129         assert( rw->ltrw_w_wait >= 0 );
 130         assert( rw->ltrw_r_active >= 0 );
 131         assert( rw->ltrw_r_wait >= 0 );
 132
 133         if( rw->ltrw_w_active > 0 ) {
 134                 /* writer is active */
 135
 136                 rw->ltrw_r_wait++;
 137
 138                 do {
 139                         ldap_pvt_thread_cond_wait(
 140                                 &rw->ltrw_read, &rw->ltrw_mutex );
 141                 } while( rw->ltrw_w_active > 0 );
 142
 143                 rw->ltrw_r_wait--;
 144                 assert( rw->ltrw_r_wait >= 0 );
 145         }
 146
 147         rw->ltrw_r_active++;
 148
 149         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 150
 151         return 0;
 152 }
 153
 154 int ldap_pvt_thread_rdwr_rtrylock( ldap_pvt_thread_rdwr_t *rwlock )
 155 {
 156         struct ldap_int_thread_rdwr_s *rw;
 157
 158         assert( rwlock != NULL );
 159         rw = *rwlock;
 160
 161         assert( rw != NULL );
 162         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 163
 164         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 165                 return LDAP_PVT_THREAD_EINVAL;
 166
 167         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 168
 169         assert( rw->ltrw_w_active >= 0 );
 170         assert( rw->ltrw_w_wait >= 0 );
 171         assert( rw->ltrw_r_active >= 0 );
 172         assert( rw->ltrw_r_wait >= 0 );
 173
 174         if( rw->ltrw_w_active > 0) {
 175                 ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 176                 return LDAP_PVT_THREAD_EBUSY;
 177         }
 178
 179         rw->ltrw_r_active++;
 180
 181         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 182
 183         return 0;
 184 }
 185
 186 int ldap_pvt_thread_rdwr_runlock( ldap_pvt_thread_rdwr_t *rwlock )
 187 {
 188         struct ldap_int_thread_rdwr_s *rw;
 189
 190         assert( rwlock != NULL );
 191         rw = *rwlock;
 192
 193         assert( rw != NULL );
 194         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 195
 196         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 197                 return LDAP_PVT_THREAD_EINVAL;
 198
 199         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 200
 201         rw->ltrw_r_active--;
 202
 203         assert( rw->ltrw_w_active >= 0 );
 204         assert( rw->ltrw_w_wait >= 0 );
 205         assert( rw->ltrw_r_active >= 0 );
 206         assert( rw->ltrw_r_wait >= 0 );
 207
 208         if (rw->ltrw_r_active == 0 && rw->ltrw_w_wait > 0 ) {
 209                 ldap_pvt_thread_cond_signal( &rw->ltrw_write );
 210         }
 211
 212         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 213
 214         return 0;
 215 }
 216
 217 int ldap_pvt_thread_rdwr_wlock( ldap_pvt_thread_rdwr_t *rwlock )
 218 {
 219         struct ldap_int_thread_rdwr_s *rw;
 220
 221         assert( rwlock != NULL );
 222         rw = *rwlock;
 223
 224         assert( rw != NULL );
 225         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 226
 227         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 228                 return LDAP_PVT_THREAD_EINVAL;
 229
 230         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 231
 232         assert( rw->ltrw_w_active >= 0 );
 233         assert( rw->ltrw_w_wait >= 0 );
 234         assert( rw->ltrw_r_active >= 0 );
 235         assert( rw->ltrw_r_wait >= 0 );
 236
 237         if ( rw->ltrw_w_active > 0 || rw->ltrw_r_active > 0 ) {
 238                 rw->ltrw_w_wait++;
 239
 240                 do {
 241                         ldap_pvt_thread_cond_wait(
 242                                 &rw->ltrw_write, &rw->ltrw_mutex );
 243                 } while ( rw->ltrw_w_active > 0 || rw->ltrw_r_active > 0 );
 244
 245                 rw->ltrw_w_wait--;
 246                 assert( rw->ltrw_w_wait >= 0 );
 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_wtrylock( 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         assert( rw->ltrw_w_active >= 0 );
 272         assert( rw->ltrw_w_wait >= 0 );
 273         assert( rw->ltrw_r_active >= 0 );
 274         assert( rw->ltrw_r_wait >= 0 );
 275
 276         if ( rw->ltrw_w_active > 0 || rw->ltrw_r_active > 0 ) {
 277                 ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 278                 return LDAP_PVT_THREAD_EBUSY;
 279         }
 280
 281         rw->ltrw_w_active++;
 282
 283         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 284
 285         return 0;
 286 }
 287
 288 int ldap_pvt_thread_rdwr_wunlock( ldap_pvt_thread_rdwr_t *rwlock )
 289 {
 290         struct ldap_int_thread_rdwr_s *rw;
 291
 292         assert( rwlock != NULL );
 293         rw = *rwlock;
 294
 295         assert( rw != NULL );
 296         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 297
 298         if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
 299                 return LDAP_PVT_THREAD_EINVAL;
 300
 301         ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
 302
 303         rw->ltrw_w_active--;
 304
 305         assert( rw->ltrw_w_active >= 0 );
 306         assert( rw->ltrw_w_wait >= 0 );
 307         assert( rw->ltrw_r_active >= 0 );
 308         assert( rw->ltrw_r_wait >= 0 );
 309
 310         if (rw->ltrw_r_wait > 0) {
 311                 ldap_pvt_thread_cond_broadcast( &rw->ltrw_read );
 312
 313         } else if (rw->ltrw_w_wait > 0) {
 314                 ldap_pvt_thread_cond_signal( &rw->ltrw_write );
 315         }
 316
 317         ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
 318
 319         return 0;
 320 }
 321
 322 #ifdef LDAP_RDWR_DEBUG
 323
 324 /* just for testing,
 325  * return 0 if false, suitable for assert(ldap_pvt_thread_rdwr_Xchk(rdwr))
 326  *
 327  * Currently they don't check if the calling thread is the one
 328  * that has the lock, just that there is a reader or writer.
 329  *
 330  * Basically sufficent for testing that places that should have
 331  * a lock are caught.
 332  */
 333
 334 int ldap_pvt_thread_rdwr_readers(ldap_pvt_thread_rdwr_t *rwlock)
 335 {
 336         struct ldap_int_thread_rdwr_s *rw;
 337
 338         assert( rwlock != NULL );
 339         rw = *rwlock;
 340
 341         assert( rw != NULL );
 342         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 343         assert( rw->ltrw_w_active >= 0 );
 344         assert( rw->ltrw_w_wait >= 0 );
 345         assert( rw->ltrw_r_active >= 0 );
 346         assert( rw->ltrw_r_wait >= 0 );
 347
 348         return( rw->ltrw_r_active );
 349 }
 350
 351 int ldap_pvt_thread_rdwr_writers(ldap_pvt_thread_rdwr_t *rwlock)
 352 {
 353         struct ldap_int_thread_rdwr_s *rw;
 354
 355         assert( rwlock != NULL );
 356         rw = *rwlock;
 357
 358         assert( rw != NULL );
 359         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 360         assert( rw->ltrw_w_active >= 0 );
 361         assert( rw->ltrw_w_wait >= 0 );
 362         assert( rw->ltrw_r_active >= 0 );
 363         assert( rw->ltrw_r_wait >= 0 );
 364
 365         return( rw->ltrw_w_active );
 366 }
 367
 368 int ldap_pvt_thread_rdwr_active(ldap_pvt_thread_rdwr_t *rwlock)
 369 {
 370         struct ldap_int_thread_rdwr_s *rw;
 371
 372         assert( rwlock != NULL );
 373         rw = *rwlock;
 374
 375         assert( rw != NULL );
 376         assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
 377         assert( rw->ltrw_w_active >= 0 );
 378         assert( rw->ltrw_w_wait >= 0 );
 379         assert( rw->ltrw_r_active >= 0 );
 380         assert( rw->ltrw_r_wait >= 0 );
 381
 382         return(ldap_pvt_thread_rdwr_readers(rw) +
 383                ldap_pvt_thread_rdwr_writers(rw));
 384 }
 385
 386 #endif /* LDAP_DEBUG */
 387
 388 #endif /* LDAP_THREAD_HAVE_RDWR */