lib/pthread-rwlock.c

   1 /* POSIX read-write locks.
   2    Copyright (C) 2019-2024 Free Software Foundation, Inc.
   3
   4    This file is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU Lesser General Public License as
   6    published by the Free Software Foundation; either version 2.1 of the
   7    License, or (at your option) any later version.
   8
   9    This file is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2019.  */
  18
  19 #include <config.h>
  20
  21 /* Specification.  */
  22 #include <pthread.h>
  23
  24 #if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
  25 # include "windows-timedrwlock.h"
  26 #else
  27 # include <errno.h>
  28 # include <limits.h>
  29 # include <sys/time.h>
  30 # include <time.h>
  31 #endif
  32
  33 #ifndef MIN
  34 # define MIN(a, b) ((a) < (b) ? (a) : (b))
  35 #endif
  36
  37 #if ((defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS) || !HAVE_PTHREAD_H
  38
  39 int
  40 pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
  41 {
  42   *attr = 0;
  43   return 0;
  44 }
  45
  46 int
  47 pthread_rwlockattr_destroy (_GL_UNUSED pthread_rwlockattr_t *attr)
  48 {
  49   return 0;
  50 }
  51
  52 #endif
  53
  54 #if (defined _WIN32 && ! defined __CYGWIN__) && USE_WINDOWS_THREADS
  55 /* Use Windows threads.  */
  56
  57 int
  58 pthread_rwlock_init (pthread_rwlock_t *lock,
  59                      _GL_UNUSED const pthread_rwlockattr_t *attr)
  60 {
  61   glwthread_timedrwlock_init (lock);
  62   return 0;
  63 }
  64
  65 int
  66 pthread_rwlock_rdlock (pthread_rwlock_t *lock)
  67 {
  68   return glwthread_timedrwlock_rdlock (lock);
  69 }
  70
  71 int
  72 pthread_rwlock_wrlock (pthread_rwlock_t *lock)
  73 {
  74   return glwthread_timedrwlock_wrlock (lock);
  75 }
  76
  77 int
  78 pthread_rwlock_tryrdlock (pthread_rwlock_t *lock)
  79 {
  80   return glwthread_timedrwlock_tryrdlock (lock);
  81 }
  82
  83 int
  84 pthread_rwlock_trywrlock (pthread_rwlock_t *lock)
  85 {
  86   return glwthread_timedrwlock_trywrlock (lock);
  87 }
  88
  89 int
  90 pthread_rwlock_timedrdlock (pthread_rwlock_t *lock,
  91                             const struct timespec *abstime)
  92 {
  93   return glwthread_timedrwlock_timedrdlock (lock, abstime);
  94 }
  95
  96 int
  97 pthread_rwlock_timedwrlock (pthread_rwlock_t *lock,
  98                             const struct timespec *abstime)
  99 {
 100   return glwthread_timedrwlock_timedwrlock (lock, abstime);
 101 }
 102
 103 int
 104 pthread_rwlock_unlock (pthread_rwlock_t *lock)
 105 {
 106   return glwthread_timedrwlock_unlock (lock);
 107 }
 108
 109 int
 110 pthread_rwlock_destroy (pthread_rwlock_t *lock)
 111 {
 112   return glwthread_timedrwlock_destroy (lock);
 113 }
 114
 115 #elif HAVE_PTHREAD_H
 116 /* Provide workarounds for POSIX threads.  */
 117
 118 # if PTHREAD_RWLOCK_UNIMPLEMENTED
 119
 120 int
 121 pthread_rwlock_init (pthread_rwlock_t *lock,
 122                      _GL_UNUSED const pthread_rwlockattr_t *attr)
 123 {
 124   int err;
 125
 126   err = pthread_mutex_init (&lock->lock, NULL);
 127   if (err != 0)
 128     return err;
 129   err = pthread_cond_init (&lock->waiting_readers, NULL);
 130   if (err != 0)
 131     return err;
 132   err = pthread_cond_init (&lock->waiting_writers, NULL);
 133   if (err != 0)
 134     return err;
 135   lock->waiting_writers_count = 0;
 136   lock->runcount = 0;
 137   return 0;
 138 }
 139
 140 int
 141 pthread_rwlock_rdlock (pthread_rwlock_t *lock)
 142 {
 143   int err;
 144
 145   err = pthread_mutex_lock (&lock->lock);
 146   if (err != 0)
 147     return err;
 148   /* Test whether only readers are currently running, and whether the runcount
 149      field will not overflow, and whether no writer is waiting.  The latter
 150      condition is because POSIX recommends that "write locks shall take
 151      precedence over read locks", to avoid "writer starvation".  */
 152   while (!(lock->runcount + 1 > 0 && lock->waiting_writers_count == 0))
 153     {
 154       /* This thread has to wait for a while.  Enqueue it among the
 155          waiting_readers.  */
 156       err = pthread_cond_wait (&lock->waiting_readers, &lock->lock);
 157       if (err != 0)
 158         {
 159           pthread_mutex_unlock (&lock->lock);
 160           return err;
 161         }
 162     }
 163   lock->runcount++;
 164   return pthread_mutex_unlock (&lock->lock);
 165 }
 166
 167 int
 168 pthread_rwlock_wrlock (pthread_rwlock_t *lock)
 169 {
 170   int err;
 171
 172   err = pthread_mutex_lock (&lock->lock);
 173   if (err != 0)
 174     return err;
 175   /* Test whether no readers or writers are currently running.  */
 176   while (!(lock->runcount == 0))
 177     {
 178       /* This thread has to wait for a while.  Enqueue it among the
 179          waiting_writers.  */
 180       lock->waiting_writers_count++;
 181       err = pthread_cond_wait (&lock->waiting_writers, &lock->lock);
 182       if (err != 0)
 183         {
 184           lock->waiting_writers_count--;
 185           pthread_mutex_unlock (&lock->lock);
 186           return err;
 187         }
 188       lock->waiting_writers_count--;
 189     }
 190   lock->runcount--; /* runcount becomes -1 */
 191   return pthread_mutex_unlock (&lock->lock);
 192 }
 193
 194 int
 195 pthread_rwlock_tryrdlock (pthread_rwlock_t *lock)
 196 {
 197   int err;
 198
 199   err = pthread_mutex_lock (&lock->lock);
 200   if (err != 0)
 201     return err;
 202   /* Test whether only readers are currently running, and whether the runcount
 203      field will not overflow, and whether no writer is waiting.  The latter
 204      condition is because POSIX recommends that "write locks shall take
 205      precedence over read locks", to avoid "writer starvation".  */
 206   if (!(lock->runcount + 1 > 0 && lock->waiting_writers_count == 0))
 207     {
 208       /* This thread would have to wait for a while.  Return instead.  */
 209       pthread_mutex_unlock (&lock->lock);
 210       return EBUSY;
 211     }
 212   lock->runcount++;
 213   return pthread_mutex_unlock (&lock->lock);
 214 }
 215
 216 int
 217 pthread_rwlock_trywrlock (pthread_rwlock_t *lock)
 218 {
 219   int err;
 220
 221   err = pthread_mutex_lock (&lock->lock);
 222   if (err != 0)
 223     return err;
 224   /* Test whether no readers or writers are currently running.  */
 225   if (!(lock->runcount == 0))
 226     {
 227       /* This thread would have to wait for a while.  Return instead.  */
 228       pthread_mutex_unlock (&lock->lock);
 229       return EBUSY;
 230     }
 231   lock->runcount--; /* runcount becomes -1 */
 232   return pthread_mutex_unlock (&lock->lock);
 233 }
 234
 235 int
 236 pthread_rwlock_timedrdlock (pthread_rwlock_t *lock,
 237                             const struct timespec *abstime)
 238 {
 239   int err;
 240
 241   err = pthread_mutex_lock (&lock->lock);
 242   if (err != 0)
 243     return err;
 244   /* Test whether only readers are currently running, and whether the runcount
 245      field will not overflow, and whether no writer is waiting.  The latter
 246      condition is because POSIX recommends that "write locks shall take
 247      precedence over read locks", to avoid "writer starvation".  */
 248   while (!(lock->runcount + 1 > 0 && lock->waiting_writers_count == 0))
 249     {
 250       /* This thread has to wait for a while.  Enqueue it among the
 251          waiting_readers.  */
 252       err = pthread_cond_timedwait (&lock->waiting_readers, &lock->lock,
 253                                     abstime);
 254       if (err != 0)
 255         {
 256           pthread_mutex_unlock (&lock->lock);
 257           return err;
 258         }
 259     }
 260   lock->runcount++;
 261   return pthread_mutex_unlock (&lock->lock);
 262 }
 263
 264 int
 265 pthread_rwlock_timedwrlock (pthread_rwlock_t *lock,
 266                             const struct timespec *abstime)
 267 {
 268   int err;
 269
 270   err = pthread_mutex_lock (&lock->lock);
 271   if (err != 0)
 272     return err;
 273   /* Test whether no readers or writers are currently running.  */
 274   while (!(lock->runcount == 0))
 275     {
 276       /* This thread has to wait for a while.  Enqueue it among the
 277          waiting_writers.  */
 278       lock->waiting_writers_count++;
 279       err = pthread_cond_timedwait (&lock->waiting_writers, &lock->lock,
 280                                     abstime);
 281       if (err != 0)
 282         {
 283           lock->waiting_writers_count--;
 284           pthread_mutex_unlock (&lock->lock);
 285           return err;
 286         }
 287       lock->waiting_writers_count--;
 288     }
 289   lock->runcount--; /* runcount becomes -1 */
 290   return pthread_mutex_unlock (&lock->lock);
 291 }
 292
 293 int
 294 pthread_rwlock_unlock (pthread_rwlock_t *lock)
 295 {
 296   int err;
 297
 298   err = pthread_mutex_lock (&lock->lock);
 299   if (err != 0)
 300     return err;
 301   if (lock->runcount < 0)
 302     {
 303       /* Drop a writer lock.  */
 304       if (!(lock->runcount == -1))
 305         {
 306           pthread_mutex_unlock (&lock->lock);
 307           return EINVAL;
 308         }
 309       lock->runcount = 0;
 310     }
 311   else
 312     {
 313       /* Drop a reader lock.  */
 314       if (!(lock->runcount > 0))
 315         {
 316           pthread_mutex_unlock (&lock->lock);
 317           return EINVAL;
 318         }
 319       lock->runcount--;
 320     }
 321   if (lock->runcount == 0)
 322     {
 323       /* POSIX recommends that "write locks shall take precedence over read
 324          locks", to avoid "writer starvation".  */
 325       if (lock->waiting_writers_count > 0)
 326         {
 327           /* Wake up one of the waiting writers.  */
 328           err = pthread_cond_signal (&lock->waiting_writers);
 329           if (err != 0)
 330             {
 331               pthread_mutex_unlock (&lock->lock);
 332               return err;
 333             }
 334         }
 335       else
 336         {
 337           /* Wake up all waiting readers.  */
 338           err = pthread_cond_broadcast (&lock->waiting_readers);
 339           if (err != 0)
 340             {
 341               pthread_mutex_unlock (&lock->lock);
 342               return err;
 343             }
 344         }
 345     }
 346   return pthread_mutex_unlock (&lock->lock);
 347 }
 348
 349 int
 350 pthread_rwlock_destroy (pthread_rwlock_t *lock)
 351 {
 352   int err;
 353
 354   err = pthread_mutex_destroy (&lock->lock);
 355   if (err != 0)
 356     return err;
 357   err = pthread_cond_destroy (&lock->waiting_readers);
 358   if (err != 0)
 359     return err;
 360   err = pthread_cond_destroy (&lock->waiting_writers);
 361   if (err != 0)
 362     return err;
 363   return 0;
 364 }
 365
 366 # elif PTHREAD_RWLOCK_LACKS_TIMEOUT
 367
 368 int
 369 pthread_rwlock_timedrdlock (pthread_rwlock_t *lock,
 370                             const struct timespec *abstime)
 371 {
 372   /* Poll the lock's state in regular intervals.  Ugh.  */
 373   for (;;)
 374     {
 375       int err;
 376       struct timeval currtime;
 377       unsigned long remaining;
 378
 379       err = pthread_rwlock_tryrdlock (lock);
 380       if (err != EBUSY)
 381         return err;
 382
 383       gettimeofday (&currtime, NULL);
 384
 385       if (currtime.tv_sec > abstime->tv_sec)
 386         remaining = 0;
 387       else
 388         {
 389           unsigned long seconds = abstime->tv_sec - currtime.tv_sec;
 390           remaining = seconds * 1000000000;
 391           if (remaining / 1000000000 != seconds) /* overflow? */
 392             remaining = ULONG_MAX;
 393           else
 394             {
 395               long nanoseconds =
 396                 abstime->tv_nsec - currtime.tv_usec * 1000;
 397               if (nanoseconds >= 0)
 398                 {
 399                   remaining += nanoseconds;
 400                   if (remaining < nanoseconds) /* overflow? */
 401                     remaining = ULONG_MAX;
 402                 }
 403               else
 404                 {
 405                   if (remaining >= - nanoseconds)
 406                     remaining -= (- nanoseconds);
 407                   else
 408                     remaining = 0;
 409                 }
 410             }
 411         }
 412       if (remaining == 0)
 413         return ETIMEDOUT;
 414
 415       /* Sleep 1 ms.  */
 416       struct timespec duration =
 417         {
 418           .tv_sec = 0,
 419           .tv_nsec = MIN (1000000, remaining)
 420         };
 421       nanosleep (&duration, NULL);
 422     }
 423 }
 424
 425 int
 426 pthread_rwlock_timedwrlock (pthread_rwlock_t *lock,
 427                             const struct timespec *abstime)
 428 {
 429   /* Poll the lock's state in regular intervals.  Ugh.  */
 430   for (;;)
 431     {
 432       int err;
 433       struct timeval currtime;
 434       unsigned long remaining;
 435
 436       err = pthread_rwlock_trywrlock (lock);
 437       if (err != EBUSY)
 438         return err;
 439
 440       gettimeofday (&currtime, NULL);
 441
 442       if (currtime.tv_sec > abstime->tv_sec)
 443         remaining = 0;
 444       else
 445         {
 446           unsigned long seconds = abstime->tv_sec - currtime.tv_sec;
 447           remaining = seconds * 1000000000;
 448           if (remaining / 1000000000 != seconds) /* overflow? */
 449             remaining = ULONG_MAX;
 450           else
 451             {
 452               long nanoseconds =
 453                 abstime->tv_nsec - currtime.tv_usec * 1000;
 454               if (nanoseconds >= 0)
 455                 {
 456                   remaining += nanoseconds;
 457                   if (remaining < nanoseconds) /* overflow? */
 458                     remaining = ULONG_MAX;
 459                 }
 460               else
 461                 {
 462                   if (remaining >= - nanoseconds)
 463                     remaining -= (- nanoseconds);
 464                   else
 465                     remaining = 0;
 466                 }
 467             }
 468         }
 469       if (remaining == 0)
 470         return ETIMEDOUT;
 471
 472       /* Sleep 1 ms.  */
 473       struct timespec duration =
 474         {
 475           .tv_sec = 0,
 476           .tv_nsec = MIN (1000000, remaining)
 477         };
 478       nanosleep (&duration, NULL);
 479     }
 480 }
 481
 482 # endif
 483
 484 #else
 485 /* Provide a dummy implementation for single-threaded applications.  */
 486
 487 /* The pthread_rwlock_t is an 'int', representing the number of readers running,
 488    or -1 when a writer runs.  */
 489
 490 int
 491 pthread_rwlock_init (pthread_rwlock_t *lock,
 492                      _GL_UNUSED const pthread_rwlockattr_t *attr)
 493 {
 494   *lock = 0;
 495   return 0;
 496 }
 497
 498 int
 499 pthread_rwlock_rdlock (pthread_rwlock_t *lock)
 500 {
 501   if (*lock < 0)
 502     return EDEADLK;
 503   (*lock)++;
 504   return 0;
 505 }
 506
 507 int
 508 pthread_rwlock_wrlock (pthread_rwlock_t *lock)
 509 {
 510   if (*lock != 0)
 511     return EDEADLK;
 512   *lock = -1;
 513   return 0;
 514 }
 515
 516 int
 517 pthread_rwlock_tryrdlock (pthread_rwlock_t *lock)
 518 {
 519   return pthread_rwlock_rdlock (lock);
 520 }
 521
 522 int
 523 pthread_rwlock_trywrlock (pthread_rwlock_t *lock)
 524 {
 525   return pthread_rwlock_wrlock (lock);
 526 }
 527
 528 int
 529 pthread_rwlock_timedrdlock (pthread_rwlock_t *lock,
 530                             _GL_UNUSED const struct timespec *abstime)
 531 {
 532   return pthread_rwlock_rdlock (lock);
 533 }
 534
 535 int
 536 pthread_rwlock_timedwrlock (pthread_rwlock_t *lock,
 537                             _GL_UNUSED const struct timespec *abstime)
 538 {
 539   return pthread_rwlock_wrlock (lock);
 540 }
 541
 542 int
 543 pthread_rwlock_unlock (pthread_rwlock_t *lock)
 544 {
 545   if (*lock == 0)
 546     return EPERM;
 547   if (*lock < 0)
 548     *lock = 0;
 549   else /* *lock > 0 */
 550     (*lock)--;
 551   return 0;
 552 }
 553
 554 int
 555 pthread_rwlock_destroy (pthread_rwlock_t *lock)
 556 {
 557   if (*lock)
 558     return EBUSY;
 559   return 0;
 560 }
 561
 562 #endif