gl/glthread/lock.h

   1 /* Locking in multithreaded situations.
   2    Copyright (C) 2005-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>, 2005.
  18    Based on GCC's gthr-posix.h, gthr-posix95.h, gthr-win32.h.  */
  19
  20 /* This file contains locking primitives for use with a given thread library.
  21    It does not contain primitives for creating threads or for other
  22    synchronization primitives.
  23
  24    Normal (non-recursive) locks:
  25      Type:                gl_lock_t
  26      Declaration:         gl_lock_define(extern, name)
  27      Initializer:         gl_lock_define_initialized(, name)
  28      Initialization:      gl_lock_init (name);
  29      Taking the lock:     gl_lock_lock (name);
  30      Releasing the lock:  gl_lock_unlock (name);
  31      De-initialization:   gl_lock_destroy (name);
  32    Equivalent functions with control of error handling:
  33      Initialization:      err = glthread_lock_init (&name);
  34      Taking the lock:     err = glthread_lock_lock (&name);
  35      Releasing the lock:  err = glthread_lock_unlock (&name);
  36      De-initialization:   err = glthread_lock_destroy (&name);
  37
  38    Read-Write (non-recursive) locks:
  39      Type:                gl_rwlock_t
  40      Declaration:         gl_rwlock_define(extern, name)
  41      Initializer:         gl_rwlock_define_initialized(, name)
  42      Initialization:      gl_rwlock_init (name);
  43      Taking the lock:     gl_rwlock_rdlock (name);
  44                           gl_rwlock_wrlock (name);
  45      Releasing the lock:  gl_rwlock_unlock (name);
  46      De-initialization:   gl_rwlock_destroy (name);
  47    Equivalent functions with control of error handling:
  48      Initialization:      err = glthread_rwlock_init (&name);
  49      Taking the lock:     err = glthread_rwlock_rdlock (&name);
  50                           err = glthread_rwlock_wrlock (&name);
  51      Releasing the lock:  err = glthread_rwlock_unlock (&name);
  52      De-initialization:   err = glthread_rwlock_destroy (&name);
  53
  54    Recursive locks:
  55      Type:                gl_recursive_lock_t
  56      Declaration:         gl_recursive_lock_define(extern, name)
  57      Initializer:         gl_recursive_lock_define_initialized(, name)
  58      Initialization:      gl_recursive_lock_init (name);
  59      Taking the lock:     gl_recursive_lock_lock (name);
  60      Releasing the lock:  gl_recursive_lock_unlock (name);
  61      De-initialization:   gl_recursive_lock_destroy (name);
  62    Equivalent functions with control of error handling:
  63      Initialization:      err = glthread_recursive_lock_init (&name);
  64      Taking the lock:     err = glthread_recursive_lock_lock (&name);
  65      Releasing the lock:  err = glthread_recursive_lock_unlock (&name);
  66      De-initialization:   err = glthread_recursive_lock_destroy (&name);
  67
  68   Once-only execution:
  69      Type:                gl_once_t
  70      Initializer:         gl_once_define(extern, name)
  71      Execution:           gl_once (name, initfunction);
  72    Equivalent functions with control of error handling:
  73      Execution:           err = glthread_once (&name, initfunction);
  74 */
  75
  76
  77 #ifndef _LOCK_H
  78 #define _LOCK_H
  79
  80 /* This file uses HAVE_THREADS_H, HAVE_PTHREAD_RWLOCK,
  81    HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER,
  82    PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP,
  83    HAVE_PTHREAD_MUTEX_RECURSIVE.  */
  84 #if !_GL_CONFIG_H_INCLUDED
  85  #error "Please include config.h first."
  86 #endif
  87
  88 #include <errno.h>
  89 #include <stdlib.h>
  90
  91 #if !defined c11_threads_in_use
  92 # if HAVE_THREADS_H && USE_POSIX_THREADS_FROM_LIBC
  93 #  define c11_threads_in_use() 1
  94 # elif HAVE_THREADS_H && USE_POSIX_THREADS_WEAK
  95 #  include <threads.h>
  96 #  pragma weak thrd_exit
  97 #  define c11_threads_in_use() (thrd_exit != NULL)
  98 # else
  99 #  define c11_threads_in_use() 0
 100 # endif
 101 #endif
 102
 103 /* ========================================================================= */
 104
 105 #if USE_ISOC_THREADS || USE_ISOC_AND_POSIX_THREADS
 106
 107 /* Use the ISO C threads library.  */
 108
 109 # include <threads.h>
 110
 111 # ifdef __cplusplus
 112 extern "C" {
 113 # endif
 114
 115 /* -------------------------- gl_lock_t datatype -------------------------- */
 116
 117 typedef struct
 118         {
 119           int volatile init_needed;
 120           once_flag init_once;
 121           void (*init_func) (void);
 122           mtx_t mutex;
 123         }
 124         gl_lock_t;
 125 # define gl_lock_define(STORAGECLASS, NAME) \
 126     STORAGECLASS gl_lock_t NAME;
 127 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
 128     static void _atomic_init_##NAME (void);       \
 129     STORAGECLASS gl_lock_t NAME =                 \
 130       { 1, ONCE_FLAG_INIT, _atomic_init_##NAME }; \
 131     static void _atomic_init_##NAME (void)        \
 132     {                                             \
 133       if (glthread_lock_init (&(NAME)))           \
 134         abort ();                                 \
 135     }
 136 extern int glthread_lock_init (gl_lock_t *lock);
 137 extern int glthread_lock_lock (gl_lock_t *lock);
 138 extern int glthread_lock_unlock (gl_lock_t *lock);
 139 extern int glthread_lock_destroy (gl_lock_t *lock);
 140
 141 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 142
 143 typedef struct
 144         {
 145           int volatile init_needed;
 146           once_flag init_once;
 147           void (*init_func) (void);
 148           mtx_t lock; /* protects the remaining fields */
 149           cnd_t waiting_readers; /* waiting readers */
 150           cnd_t waiting_writers; /* waiting writers */
 151           unsigned int waiting_writers_count; /* number of waiting writers */
 152           int runcount; /* number of readers running, or -1 when a writer runs */
 153         }
 154         gl_rwlock_t;
 155 # define gl_rwlock_define(STORAGECLASS, NAME) \
 156     STORAGECLASS gl_rwlock_t NAME;
 157 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 158     static void _atomic_init_##NAME (void);       \
 159     STORAGECLASS gl_rwlock_t NAME =               \
 160       { 1, ONCE_FLAG_INIT, _atomic_init_##NAME }; \
 161     static void _atomic_init_##NAME (void)        \
 162     {                                             \
 163       if (glthread_rwlock_init (&(NAME)))         \
 164         abort ();                                 \
 165     }
 166 extern int glthread_rwlock_init (gl_rwlock_t *lock);
 167 extern int glthread_rwlock_rdlock (gl_rwlock_t *lock);
 168 extern int glthread_rwlock_wrlock (gl_rwlock_t *lock);
 169 extern int glthread_rwlock_unlock (gl_rwlock_t *lock);
 170 extern int glthread_rwlock_destroy (gl_rwlock_t *lock);
 171
 172 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 173
 174 typedef struct
 175         {
 176           int volatile init_needed;
 177           once_flag init_once;
 178           void (*init_func) (void);
 179           mtx_t mutex;
 180         }
 181         gl_recursive_lock_t;
 182 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
 183     STORAGECLASS gl_recursive_lock_t NAME;
 184 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 185     static void _atomic_init_##NAME (void);       \
 186     STORAGECLASS gl_recursive_lock_t NAME =       \
 187       { 1, ONCE_FLAG_INIT, _atomic_init_##NAME }; \
 188     static void _atomic_init_##NAME (void)        \
 189     {                                             \
 190       if (glthread_recursive_lock_init (&(NAME))) \
 191         abort ();                                 \
 192     }
 193 extern int glthread_recursive_lock_init (gl_recursive_lock_t *lock);
 194 extern int glthread_recursive_lock_lock (gl_recursive_lock_t *lock);
 195 extern int glthread_recursive_lock_unlock (gl_recursive_lock_t *lock);
 196 extern int glthread_recursive_lock_destroy (gl_recursive_lock_t *lock);
 197
 198 /* -------------------------- gl_once_t datatype -------------------------- */
 199
 200 typedef once_flag gl_once_t;
 201 # define gl_once_define(STORAGECLASS, NAME) \
 202     STORAGECLASS once_flag NAME = ONCE_FLAG_INIT;
 203 # define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 204     (call_once (ONCE_CONTROL, INITFUNCTION), 0)
 205
 206 # ifdef __cplusplus
 207 }
 208 # endif
 209
 210 #endif
 211
 212 /* ========================================================================= */
 213
 214 #if USE_POSIX_THREADS
 215
 216 /* Use the POSIX threads library.  */
 217
 218 # include <pthread.h>
 219
 220 # ifdef __cplusplus
 221 extern "C" {
 222 # endif
 223
 224 # if PTHREAD_IN_USE_DETECTION_HARD
 225
 226 /* The pthread_in_use() detection needs to be done at runtime.  */
 227 #  define pthread_in_use() \
 228      glthread_in_use ()
 229 extern int glthread_in_use (void);
 230
 231 # endif
 232
 233 # if USE_POSIX_THREADS_WEAK
 234
 235 /* Use weak references to the POSIX threads library.  */
 236
 237 /* Weak references avoid dragging in external libraries if the other parts
 238    of the program don't use them.  Here we use them, because we don't want
 239    every program that uses libintl to depend on libpthread.  This assumes
 240    that libpthread would not be loaded after libintl; i.e. if libintl is
 241    loaded first, by an executable that does not depend on libpthread, and
 242    then a module is dynamically loaded that depends on libpthread, libintl
 243    will not be multithread-safe.  */
 244
 245 /* The way to test at runtime whether libpthread is present is to test
 246    whether a function pointer's value, such as &pthread_mutex_init, is
 247    non-NULL.  However, some versions of GCC have a bug through which, in
 248    PIC mode, &foo != NULL always evaluates to true if there is a direct
 249    call to foo(...) in the same function.  To avoid this, we test the
 250    address of a function in libpthread that we don't use.  */
 251
 252 #  pragma weak pthread_mutex_init
 253 #  pragma weak pthread_mutex_lock
 254 #  pragma weak pthread_mutex_unlock
 255 #  pragma weak pthread_mutex_destroy
 256 #  pragma weak pthread_rwlock_init
 257 #  pragma weak pthread_rwlock_rdlock
 258 #  pragma weak pthread_rwlock_wrlock
 259 #  pragma weak pthread_rwlock_unlock
 260 #  pragma weak pthread_rwlock_destroy
 261 #  pragma weak pthread_once
 262 #  pragma weak pthread_cond_init
 263 #  pragma weak pthread_cond_wait
 264 #  pragma weak pthread_cond_signal
 265 #  pragma weak pthread_cond_broadcast
 266 #  pragma weak pthread_cond_destroy
 267 #  pragma weak pthread_mutexattr_init
 268 #  pragma weak pthread_mutexattr_settype
 269 #  pragma weak pthread_mutexattr_destroy
 270 #  pragma weak pthread_rwlockattr_init
 271 #  if __GNU_LIBRARY__ > 1
 272 #   pragma weak pthread_rwlockattr_setkind_np
 273 #  endif
 274 #  pragma weak pthread_rwlockattr_destroy
 275 #  ifndef pthread_self
 276 #   pragma weak pthread_self
 277 #  endif
 278
 279 #  if !PTHREAD_IN_USE_DETECTION_HARD
 280     /* Considering all platforms with USE_POSIX_THREADS_WEAK, only few symbols
 281        can be used to determine whether libpthread is in use.  These are:
 282          pthread_mutexattr_gettype
 283          pthread_rwlockattr_destroy
 284          pthread_rwlockattr_init
 285      */
 286 #   pragma weak pthread_mutexattr_gettype
 287 #   define pthread_in_use() \
 288       (pthread_mutexattr_gettype != NULL || c11_threads_in_use ())
 289 #  endif
 290
 291 # else
 292
 293 #  if !PTHREAD_IN_USE_DETECTION_HARD
 294 #   define pthread_in_use() 1
 295 #  endif
 296
 297 # endif
 298
 299 /* -------------------------- gl_lock_t datatype -------------------------- */
 300
 301 typedef pthread_mutex_t gl_lock_t;
 302 # define gl_lock_define(STORAGECLASS, NAME) \
 303     STORAGECLASS pthread_mutex_t NAME;
 304 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
 305     STORAGECLASS pthread_mutex_t NAME = gl_lock_initializer;
 306 # define gl_lock_initializer \
 307     PTHREAD_MUTEX_INITIALIZER
 308 # define glthread_lock_init(LOCK) \
 309     (pthread_in_use () ? pthread_mutex_init (LOCK, NULL) : 0)
 310 # define glthread_lock_lock(LOCK) \
 311     (pthread_in_use () ? pthread_mutex_lock (LOCK) : 0)
 312 # define glthread_lock_unlock(LOCK) \
 313     (pthread_in_use () ? pthread_mutex_unlock (LOCK) : 0)
 314 # define glthread_lock_destroy(LOCK) \
 315     (pthread_in_use () ? pthread_mutex_destroy (LOCK) : 0)
 316
 317 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 318
 319 # if HAVE_PTHREAD_RWLOCK && (HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER || (defined PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP && (__GNU_LIBRARY__ > 1)))
 320
 321 #  if defined PTHREAD_RWLOCK_INITIALIZER || defined PTHREAD_RWLOCK_INITIALIZER_NP
 322
 323 typedef pthread_rwlock_t gl_rwlock_t;
 324 #   define gl_rwlock_define(STORAGECLASS, NAME) \
 325       STORAGECLASS pthread_rwlock_t NAME;
 326 #   define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 327       STORAGECLASS pthread_rwlock_t NAME = gl_rwlock_initializer;
 328 #   if HAVE_PTHREAD_RWLOCK_RDLOCK_PREFER_WRITER
 329 #    if defined PTHREAD_RWLOCK_INITIALIZER
 330 #     define gl_rwlock_initializer \
 331         PTHREAD_RWLOCK_INITIALIZER
 332 #    else
 333 #     define gl_rwlock_initializer \
 334         PTHREAD_RWLOCK_INITIALIZER_NP
 335 #    endif
 336 #    define glthread_rwlock_init(LOCK) \
 337        (pthread_in_use () ? pthread_rwlock_init (LOCK, NULL) : 0)
 338 #   else /* glibc with bug https://sourceware.org/bugzilla/show_bug.cgi?id=13701 */
 339 #    define gl_rwlock_initializer \
 340        PTHREAD_RWLOCK_WRITER_NONRECURSIVE_INITIALIZER_NP
 341 #    define glthread_rwlock_init(LOCK) \
 342        (pthread_in_use () ? glthread_rwlock_init_for_glibc (LOCK) : 0)
 343 extern int glthread_rwlock_init_for_glibc (pthread_rwlock_t *lock);
 344 #   endif
 345 #   define glthread_rwlock_rdlock(LOCK) \
 346       (pthread_in_use () ? pthread_rwlock_rdlock (LOCK) : 0)
 347 #   define glthread_rwlock_wrlock(LOCK) \
 348       (pthread_in_use () ? pthread_rwlock_wrlock (LOCK) : 0)
 349 #   define glthread_rwlock_unlock(LOCK) \
 350       (pthread_in_use () ? pthread_rwlock_unlock (LOCK) : 0)
 351 #   define glthread_rwlock_destroy(LOCK) \
 352       (pthread_in_use () ? pthread_rwlock_destroy (LOCK) : 0)
 353
 354 #  else
 355
 356 typedef struct
 357         {
 358           int initialized;
 359           pthread_mutex_t guard;   /* protects the initialization */
 360           pthread_rwlock_t rwlock; /* read-write lock */
 361         }
 362         gl_rwlock_t;
 363 #   define gl_rwlock_define(STORAGECLASS, NAME) \
 364       STORAGECLASS gl_rwlock_t NAME;
 365 #   define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 366       STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
 367 #   define gl_rwlock_initializer \
 368       { 0, PTHREAD_MUTEX_INITIALIZER }
 369 #   define glthread_rwlock_init(LOCK) \
 370       (pthread_in_use () ? glthread_rwlock_init_multithreaded (LOCK) : 0)
 371 #   define glthread_rwlock_rdlock(LOCK) \
 372       (pthread_in_use () ? glthread_rwlock_rdlock_multithreaded (LOCK) : 0)
 373 #   define glthread_rwlock_wrlock(LOCK) \
 374       (pthread_in_use () ? glthread_rwlock_wrlock_multithreaded (LOCK) : 0)
 375 #   define glthread_rwlock_unlock(LOCK) \
 376       (pthread_in_use () ? glthread_rwlock_unlock_multithreaded (LOCK) : 0)
 377 #   define glthread_rwlock_destroy(LOCK) \
 378       (pthread_in_use () ? glthread_rwlock_destroy_multithreaded (LOCK) : 0)
 379 extern int glthread_rwlock_init_multithreaded (gl_rwlock_t *lock);
 380 extern int glthread_rwlock_rdlock_multithreaded (gl_rwlock_t *lock);
 381 extern int glthread_rwlock_wrlock_multithreaded (gl_rwlock_t *lock);
 382 extern int glthread_rwlock_unlock_multithreaded (gl_rwlock_t *lock);
 383 extern int glthread_rwlock_destroy_multithreaded (gl_rwlock_t *lock);
 384
 385 #  endif
 386
 387 # else
 388
 389 typedef struct
 390         {
 391           pthread_mutex_t lock; /* protects the remaining fields */
 392           pthread_cond_t waiting_readers; /* waiting readers */
 393           pthread_cond_t waiting_writers; /* waiting writers */
 394           unsigned int waiting_writers_count; /* number of waiting writers */
 395           int runcount; /* number of readers running, or -1 when a writer runs */
 396         }
 397         gl_rwlock_t;
 398 # define gl_rwlock_define(STORAGECLASS, NAME) \
 399     STORAGECLASS gl_rwlock_t NAME;
 400 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 401     STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
 402 # define gl_rwlock_initializer \
 403     { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, 0 }
 404 # define glthread_rwlock_init(LOCK) \
 405     (pthread_in_use () ? glthread_rwlock_init_multithreaded (LOCK) : 0)
 406 # define glthread_rwlock_rdlock(LOCK) \
 407     (pthread_in_use () ? glthread_rwlock_rdlock_multithreaded (LOCK) : 0)
 408 # define glthread_rwlock_wrlock(LOCK) \
 409     (pthread_in_use () ? glthread_rwlock_wrlock_multithreaded (LOCK) : 0)
 410 # define glthread_rwlock_unlock(LOCK) \
 411     (pthread_in_use () ? glthread_rwlock_unlock_multithreaded (LOCK) : 0)
 412 # define glthread_rwlock_destroy(LOCK) \
 413     (pthread_in_use () ? glthread_rwlock_destroy_multithreaded (LOCK) : 0)
 414 extern int glthread_rwlock_init_multithreaded (gl_rwlock_t *lock);
 415 extern int glthread_rwlock_rdlock_multithreaded (gl_rwlock_t *lock);
 416 extern int glthread_rwlock_wrlock_multithreaded (gl_rwlock_t *lock);
 417 extern int glthread_rwlock_unlock_multithreaded (gl_rwlock_t *lock);
 418 extern int glthread_rwlock_destroy_multithreaded (gl_rwlock_t *lock);
 419
 420 # endif
 421
 422 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 423
 424 # if HAVE_PTHREAD_MUTEX_RECURSIVE
 425
 426 #  if defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER || defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
 427
 428 typedef pthread_mutex_t gl_recursive_lock_t;
 429 #   define gl_recursive_lock_define(STORAGECLASS, NAME) \
 430       STORAGECLASS pthread_mutex_t NAME;
 431 #   define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 432       STORAGECLASS pthread_mutex_t NAME = gl_recursive_lock_initializer;
 433 #   ifdef PTHREAD_RECURSIVE_MUTEX_INITIALIZER
 434 #    define gl_recursive_lock_initializer \
 435        PTHREAD_RECURSIVE_MUTEX_INITIALIZER
 436 #   else
 437 #    define gl_recursive_lock_initializer \
 438        PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
 439 #   endif
 440 #   define glthread_recursive_lock_init(LOCK) \
 441       (pthread_in_use () ? glthread_recursive_lock_init_multithreaded (LOCK) : 0)
 442 #   define glthread_recursive_lock_lock(LOCK) \
 443       (pthread_in_use () ? pthread_mutex_lock (LOCK) : 0)
 444 #   define glthread_recursive_lock_unlock(LOCK) \
 445       (pthread_in_use () ? pthread_mutex_unlock (LOCK) : 0)
 446 #   define glthread_recursive_lock_destroy(LOCK) \
 447       (pthread_in_use () ? pthread_mutex_destroy (LOCK) : 0)
 448 extern int glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock);
 449
 450 #  else
 451
 452 typedef struct
 453         {
 454           pthread_mutex_t recmutex; /* recursive mutex */
 455           pthread_mutex_t guard;    /* protects the initialization */
 456           int initialized;
 457         }
 458         gl_recursive_lock_t;
 459 #   define gl_recursive_lock_define(STORAGECLASS, NAME) \
 460       STORAGECLASS gl_recursive_lock_t NAME;
 461 #   define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 462       STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
 463 #   define gl_recursive_lock_initializer \
 464       { PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, 0 }
 465 #   define glthread_recursive_lock_init(LOCK) \
 466       (pthread_in_use () ? glthread_recursive_lock_init_multithreaded (LOCK) : 0)
 467 #   define glthread_recursive_lock_lock(LOCK) \
 468       (pthread_in_use () ? glthread_recursive_lock_lock_multithreaded (LOCK) : 0)
 469 #   define glthread_recursive_lock_unlock(LOCK) \
 470       (pthread_in_use () ? glthread_recursive_lock_unlock_multithreaded (LOCK) : 0)
 471 #   define glthread_recursive_lock_destroy(LOCK) \
 472       (pthread_in_use () ? glthread_recursive_lock_destroy_multithreaded (LOCK) : 0)
 473 extern int glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock);
 474 extern int glthread_recursive_lock_lock_multithreaded (gl_recursive_lock_t *lock);
 475 extern int glthread_recursive_lock_unlock_multithreaded (gl_recursive_lock_t *lock);
 476 extern int glthread_recursive_lock_destroy_multithreaded (gl_recursive_lock_t *lock);
 477
 478 #  endif
 479
 480 # else
 481
 482 /* Old versions of POSIX threads on Solaris did not have recursive locks.
 483    We have to implement them ourselves.  */
 484
 485 typedef struct
 486         {
 487           pthread_mutex_t mutex;
 488           pthread_t owner;
 489           unsigned long depth;
 490         }
 491         gl_recursive_lock_t;
 492 #  define gl_recursive_lock_define(STORAGECLASS, NAME) \
 493      STORAGECLASS gl_recursive_lock_t NAME;
 494 #  define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 495      STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
 496 #  define gl_recursive_lock_initializer \
 497      { PTHREAD_MUTEX_INITIALIZER, (pthread_t) 0, 0 }
 498 #  define glthread_recursive_lock_init(LOCK) \
 499      (pthread_in_use () ? glthread_recursive_lock_init_multithreaded (LOCK) : 0)
 500 #  define glthread_recursive_lock_lock(LOCK) \
 501      (pthread_in_use () ? glthread_recursive_lock_lock_multithreaded (LOCK) : 0)
 502 #  define glthread_recursive_lock_unlock(LOCK) \
 503      (pthread_in_use () ? glthread_recursive_lock_unlock_multithreaded (LOCK) : 0)
 504 #  define glthread_recursive_lock_destroy(LOCK) \
 505      (pthread_in_use () ? glthread_recursive_lock_destroy_multithreaded (LOCK) : 0)
 506 extern int glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock);
 507 extern int glthread_recursive_lock_lock_multithreaded (gl_recursive_lock_t *lock);
 508 extern int glthread_recursive_lock_unlock_multithreaded (gl_recursive_lock_t *lock);
 509 extern int glthread_recursive_lock_destroy_multithreaded (gl_recursive_lock_t *lock);
 510
 511 # endif
 512
 513 /* -------------------------- gl_once_t datatype -------------------------- */
 514
 515 typedef pthread_once_t gl_once_t;
 516 # define gl_once_define(STORAGECLASS, NAME) \
 517     STORAGECLASS pthread_once_t NAME = PTHREAD_ONCE_INIT;
 518 # if PTHREAD_IN_USE_DETECTION_HARD || USE_POSIX_THREADS_WEAK
 519 #  define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 520      (pthread_in_use ()                                                        \
 521       ? pthread_once (ONCE_CONTROL, INITFUNCTION)                              \
 522       : (glthread_once_singlethreaded (ONCE_CONTROL) ? (INITFUNCTION (), 0) : 0))
 523 # else
 524 #  define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 525      (pthread_in_use ()                                                        \
 526       ? glthread_once_multithreaded (ONCE_CONTROL, INITFUNCTION)               \
 527       : (glthread_once_singlethreaded (ONCE_CONTROL) ? (INITFUNCTION (), 0) : 0))
 528 extern int glthread_once_multithreaded (pthread_once_t *once_control,
 529                                         void (*init_function) (void));
 530 # endif
 531 extern int glthread_once_singlethreaded (pthread_once_t *once_control);
 532
 533 # ifdef __cplusplus
 534 }
 535 # endif
 536
 537 #endif
 538
 539 /* ========================================================================= */
 540
 541 #if USE_WINDOWS_THREADS
 542
 543 # define WIN32_LEAN_AND_MEAN  /* avoid including junk */
 544 # include <windows.h>
 545
 546 # include "windows-mutex.h"
 547 # include "windows-rwlock.h"
 548 # include "windows-recmutex.h"
 549 # include "windows-once.h"
 550
 551 # ifdef __cplusplus
 552 extern "C" {
 553 # endif
 554
 555 /* We can use CRITICAL_SECTION directly, rather than the native Windows Event,
 556    Mutex, Semaphore types, because
 557      - we need only to synchronize inside a single process (address space),
 558        not inter-process locking,
 559      - we don't need to support trylock operations.  (TryEnterCriticalSection
 560        does not work on Windows 95/98/ME.  Packages that need trylock usually
 561        define their own mutex type.)  */
 562
 563 /* There is no way to statically initialize a CRITICAL_SECTION.  It needs
 564    to be done lazily, once only.  For this we need spinlocks.  */
 565
 566 /* -------------------------- gl_lock_t datatype -------------------------- */
 567
 568 typedef glwthread_mutex_t gl_lock_t;
 569 # define gl_lock_define(STORAGECLASS, NAME) \
 570     STORAGECLASS gl_lock_t NAME;
 571 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
 572     STORAGECLASS gl_lock_t NAME = gl_lock_initializer;
 573 # define gl_lock_initializer \
 574     GLWTHREAD_MUTEX_INIT
 575 # define glthread_lock_init(LOCK) \
 576     (glwthread_mutex_init (LOCK), 0)
 577 # define glthread_lock_lock(LOCK) \
 578     glwthread_mutex_lock (LOCK)
 579 # define glthread_lock_unlock(LOCK) \
 580     glwthread_mutex_unlock (LOCK)
 581 # define glthread_lock_destroy(LOCK) \
 582     glwthread_mutex_destroy (LOCK)
 583
 584 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 585
 586 typedef glwthread_rwlock_t gl_rwlock_t;
 587 # define gl_rwlock_define(STORAGECLASS, NAME) \
 588     STORAGECLASS gl_rwlock_t NAME;
 589 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 590     STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
 591 # define gl_rwlock_initializer \
 592     GLWTHREAD_RWLOCK_INIT
 593 # define glthread_rwlock_init(LOCK) \
 594     (glwthread_rwlock_init (LOCK), 0)
 595 # define glthread_rwlock_rdlock(LOCK) \
 596     glwthread_rwlock_rdlock (LOCK)
 597 # define glthread_rwlock_wrlock(LOCK) \
 598     glwthread_rwlock_wrlock (LOCK)
 599 # define glthread_rwlock_unlock(LOCK) \
 600     glwthread_rwlock_unlock (LOCK)
 601 # define glthread_rwlock_destroy(LOCK) \
 602     glwthread_rwlock_destroy (LOCK)
 603
 604 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 605
 606 typedef glwthread_recmutex_t gl_recursive_lock_t;
 607 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
 608     STORAGECLASS gl_recursive_lock_t NAME;
 609 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 610     STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
 611 # define gl_recursive_lock_initializer \
 612     GLWTHREAD_RECMUTEX_INIT
 613 # define glthread_recursive_lock_init(LOCK) \
 614     (glwthread_recmutex_init (LOCK), 0)
 615 # define glthread_recursive_lock_lock(LOCK) \
 616     glwthread_recmutex_lock (LOCK)
 617 # define glthread_recursive_lock_unlock(LOCK) \
 618     glwthread_recmutex_unlock (LOCK)
 619 # define glthread_recursive_lock_destroy(LOCK) \
 620     glwthread_recmutex_destroy (LOCK)
 621
 622 /* -------------------------- gl_once_t datatype -------------------------- */
 623
 624 typedef glwthread_once_t gl_once_t;
 625 # define gl_once_define(STORAGECLASS, NAME) \
 626     STORAGECLASS gl_once_t NAME = GLWTHREAD_ONCE_INIT;
 627 # define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 628     (glwthread_once (ONCE_CONTROL, INITFUNCTION), 0)
 629
 630 # ifdef __cplusplus
 631 }
 632 # endif
 633
 634 #endif
 635
 636 /* ========================================================================= */
 637
 638 #if !(USE_ISOC_THREADS || USE_POSIX_THREADS || USE_ISOC_AND_POSIX_THREADS || USE_WINDOWS_THREADS)
 639
 640 /* Provide dummy implementation if threads are not supported.  */
 641
 642 /* -------------------------- gl_lock_t datatype -------------------------- */
 643
 644 typedef int gl_lock_t;
 645 # define gl_lock_define(STORAGECLASS, NAME)
 646 # define gl_lock_define_initialized(STORAGECLASS, NAME)
 647 # define glthread_lock_init(NAME) 0
 648 # define glthread_lock_lock(NAME) 0
 649 # define glthread_lock_unlock(NAME) 0
 650 # define glthread_lock_destroy(NAME) 0
 651
 652 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 653
 654 typedef int gl_rwlock_t;
 655 # define gl_rwlock_define(STORAGECLASS, NAME)
 656 # define gl_rwlock_define_initialized(STORAGECLASS, NAME)
 657 # define glthread_rwlock_init(NAME) 0
 658 # define glthread_rwlock_rdlock(NAME) 0
 659 # define glthread_rwlock_wrlock(NAME) 0
 660 # define glthread_rwlock_unlock(NAME) 0
 661 # define glthread_rwlock_destroy(NAME) 0
 662
 663 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 664
 665 typedef int gl_recursive_lock_t;
 666 # define gl_recursive_lock_define(STORAGECLASS, NAME)
 667 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME)
 668 # define glthread_recursive_lock_init(NAME) 0
 669 # define glthread_recursive_lock_lock(NAME) 0
 670 # define glthread_recursive_lock_unlock(NAME) 0
 671 # define glthread_recursive_lock_destroy(NAME) 0
 672
 673 /* -------------------------- gl_once_t datatype -------------------------- */
 674
 675 typedef int gl_once_t;
 676 # define gl_once_define(STORAGECLASS, NAME) \
 677     STORAGECLASS gl_once_t NAME = 0;
 678 # define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 679     (*(ONCE_CONTROL) == 0 ? (*(ONCE_CONTROL) = ~ 0, INITFUNCTION (), 0) : 0)
 680
 681 #endif
 682
 683 /* ========================================================================= */
 684
 685 /* Macros with built-in error handling.  */
 686
 687 /* -------------------------- gl_lock_t datatype -------------------------- */
 688
 689 #define gl_lock_init(NAME) \
 690    do                                  \
 691      {                                 \
 692        if (glthread_lock_init (&NAME)) \
 693          abort ();                     \
 694      }                                 \
 695    while (0)
 696 #define gl_lock_lock(NAME) \
 697    do                                  \
 698      {                                 \
 699        if (glthread_lock_lock (&NAME)) \
 700          abort ();                     \
 701      }                                 \
 702    while (0)
 703 #define gl_lock_unlock(NAME) \
 704    do                                    \
 705      {                                   \
 706        if (glthread_lock_unlock (&NAME)) \
 707          abort ();                       \
 708      }                                   \
 709    while (0)
 710 #define gl_lock_destroy(NAME) \
 711    do                                     \
 712      {                                    \
 713        if (glthread_lock_destroy (&NAME)) \
 714          abort ();                        \
 715      }                                    \
 716    while (0)
 717
 718 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 719
 720 #define gl_rwlock_init(NAME) \
 721    do                                    \
 722      {                                   \
 723        if (glthread_rwlock_init (&NAME)) \
 724          abort ();                       \
 725      }                                   \
 726    while (0)
 727 #define gl_rwlock_rdlock(NAME) \
 728    do                                      \
 729      {                                     \
 730        if (glthread_rwlock_rdlock (&NAME)) \
 731          abort ();                         \
 732      }                                     \
 733    while (0)
 734 #define gl_rwlock_wrlock(NAME) \
 735    do                                      \
 736      {                                     \
 737        if (glthread_rwlock_wrlock (&NAME)) \
 738          abort ();                         \
 739      }                                     \
 740    while (0)
 741 #define gl_rwlock_unlock(NAME) \
 742    do                                      \
 743      {                                     \
 744        if (glthread_rwlock_unlock (&NAME)) \
 745          abort ();                         \
 746      }                                     \
 747    while (0)
 748 #define gl_rwlock_destroy(NAME) \
 749    do                                       \
 750      {                                      \
 751        if (glthread_rwlock_destroy (&NAME)) \
 752          abort ();                          \
 753      }                                      \
 754    while (0)
 755
 756 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 757
 758 #define gl_recursive_lock_init(NAME) \
 759    do                                            \
 760      {                                           \
 761        if (glthread_recursive_lock_init (&NAME)) \
 762          abort ();                               \
 763      }                                           \
 764    while (0)
 765 #define gl_recursive_lock_lock(NAME) \
 766    do                                            \
 767      {                                           \
 768        if (glthread_recursive_lock_lock (&NAME)) \
 769          abort ();                               \
 770      }                                           \
 771    while (0)
 772 #define gl_recursive_lock_unlock(NAME) \
 773    do                                              \
 774      {                                             \
 775        if (glthread_recursive_lock_unlock (&NAME)) \
 776          abort ();                                 \
 777      }                                             \
 778    while (0)
 779 #define gl_recursive_lock_destroy(NAME) \
 780    do                                               \
 781      {                                              \
 782        if (glthread_recursive_lock_destroy (&NAME)) \
 783          abort ();                                  \
 784      }                                              \
 785    while (0)
 786
 787 /* -------------------------- gl_once_t datatype -------------------------- */
 788
 789 #define gl_once(NAME, INITFUNCTION) \
 790    do                                           \
 791      {                                          \
 792        if (glthread_once (&NAME, INITFUNCTION)) \
 793          abort ();                              \
 794      }                                          \
 795    while (0)
 796
 797 /* ========================================================================= */
 798
 799 #endif /* _LOCK_H */