contrib/grep/lib/glthread/lock.h

   1 /* Locking in multithreaded situations.
   2    Copyright (C) 2005-2014 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 3, or (at your option)
   7    any later version.
   8
   9    This program 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 General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, see <http://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-solaris.h,
  19    gthr-win32.h.  */
  20
  21 /* This file contains locking primitives for use with a given thread library.
  22    It does not contain primitives for creating threads or for other
  23    synchronization primitives.
  24
  25    Normal (non-recursive) locks:
  26      Type:                gl_lock_t
  27      Declaration:         gl_lock_define(extern, name)
  28      Initializer:         gl_lock_define_initialized(, name)
  29      Initialization:      gl_lock_init (name);
  30      Taking the lock:     gl_lock_lock (name);
  31      Releasing the lock:  gl_lock_unlock (name);
  32      De-initialization:   gl_lock_destroy (name);
  33    Equivalent functions with control of error handling:
  34      Initialization:      err = glthread_lock_init (&name);
  35      Taking the lock:     err = glthread_lock_lock (&name);
  36      Releasing the lock:  err = glthread_lock_unlock (&name);
  37      De-initialization:   err = glthread_lock_destroy (&name);
  38
  39    Read-Write (non-recursive) locks:
  40      Type:                gl_rwlock_t
  41      Declaration:         gl_rwlock_define(extern, name)
  42      Initializer:         gl_rwlock_define_initialized(, name)
  43      Initialization:      gl_rwlock_init (name);
  44      Taking the lock:     gl_rwlock_rdlock (name);
  45                           gl_rwlock_wrlock (name);
  46      Releasing the lock:  gl_rwlock_unlock (name);
  47      De-initialization:   gl_rwlock_destroy (name);
  48    Equivalent functions with control of error handling:
  49      Initialization:      err = glthread_rwlock_init (&name);
  50      Taking the lock:     err = glthread_rwlock_rdlock (&name);
  51                           err = glthread_rwlock_wrlock (&name);
  52      Releasing the lock:  err = glthread_rwlock_unlock (&name);
  53      De-initialization:   err = glthread_rwlock_destroy (&name);
  54
  55    Recursive locks:
  56      Type:                gl_recursive_lock_t
  57      Declaration:         gl_recursive_lock_define(extern, name)
  58      Initializer:         gl_recursive_lock_define_initialized(, name)
  59      Initialization:      gl_recursive_lock_init (name);
  60      Taking the lock:     gl_recursive_lock_lock (name);
  61      Releasing the lock:  gl_recursive_lock_unlock (name);
  62      De-initialization:   gl_recursive_lock_destroy (name);
  63    Equivalent functions with control of error handling:
  64      Initialization:      err = glthread_recursive_lock_init (&name);
  65      Taking the lock:     err = glthread_recursive_lock_lock (&name);
  66      Releasing the lock:  err = glthread_recursive_lock_unlock (&name);
  67      De-initialization:   err = glthread_recursive_lock_destroy (&name);
  68
  69   Once-only execution:
  70      Type:                gl_once_t
  71      Initializer:         gl_once_define(extern, name)
  72      Execution:           gl_once (name, initfunction);
  73    Equivalent functions with control of error handling:
  74      Execution:           err = glthread_once (&name, initfunction);
  75 */
  76
  77
  78 #ifndef _LOCK_H
  79 #define _LOCK_H
  80
  81 #include <errno.h>
  82 #include <stdlib.h>
  83
  84 /* ========================================================================= */
  85
  86 #if USE_POSIX_THREADS
  87
  88 /* Use the POSIX threads library.  */
  89
  90 # include <pthread.h>
  91
  92 # ifdef __cplusplus
  93 extern "C" {
  94 # endif
  95
  96 # if PTHREAD_IN_USE_DETECTION_HARD
  97
  98 /* The pthread_in_use() detection needs to be done at runtime.  */
  99 #  define pthread_in_use() \
 100      glthread_in_use ()
 101 extern int glthread_in_use (void);
 102
 103 # endif
 104
 105 # if USE_POSIX_THREADS_WEAK
 106
 107 /* Use weak references to the POSIX threads library.  */
 108
 109 /* Weak references avoid dragging in external libraries if the other parts
 110    of the program don't use them.  Here we use them, because we don't want
 111    every program that uses libintl to depend on libpthread.  This assumes
 112    that libpthread would not be loaded after libintl; i.e. if libintl is
 113    loaded first, by an executable that does not depend on libpthread, and
 114    then a module is dynamically loaded that depends on libpthread, libintl
 115    will not be multithread-safe.  */
 116
 117 /* The way to test at runtime whether libpthread is present is to test
 118    whether a function pointer's value, such as &pthread_mutex_init, is
 119    non-NULL.  However, some versions of GCC have a bug through which, in
 120    PIC mode, &foo != NULL always evaluates to true if there is a direct
 121    call to foo(...) in the same function.  To avoid this, we test the
 122    address of a function in libpthread that we don't use.  */
 123
 124 #  pragma weak pthread_mutex_init
 125 #  pragma weak pthread_mutex_lock
 126 #  pragma weak pthread_mutex_unlock
 127 #  pragma weak pthread_mutex_destroy
 128 #  pragma weak pthread_rwlock_init
 129 #  pragma weak pthread_rwlock_rdlock
 130 #  pragma weak pthread_rwlock_wrlock
 131 #  pragma weak pthread_rwlock_unlock
 132 #  pragma weak pthread_rwlock_destroy
 133 #  pragma weak pthread_once
 134 #  pragma weak pthread_cond_init
 135 #  pragma weak pthread_cond_wait
 136 #  pragma weak pthread_cond_signal
 137 #  pragma weak pthread_cond_broadcast
 138 #  pragma weak pthread_cond_destroy
 139 #  pragma weak pthread_mutexattr_init
 140 #  pragma weak pthread_mutexattr_settype
 141 #  pragma weak pthread_mutexattr_destroy
 142 #  ifndef pthread_self
 143 #   pragma weak pthread_self
 144 #  endif
 145
 146 #  if !PTHREAD_IN_USE_DETECTION_HARD
 147 #   pragma weak pthread_cancel
 148 #   define pthread_in_use() (pthread_cancel != NULL)
 149 #  endif
 150
 151 # else
 152
 153 #  if !PTHREAD_IN_USE_DETECTION_HARD
 154 #   define pthread_in_use() 1
 155 #  endif
 156
 157 # endif
 158
 159 /* -------------------------- gl_lock_t datatype -------------------------- */
 160
 161 typedef pthread_mutex_t gl_lock_t;
 162 # define gl_lock_define(STORAGECLASS, NAME) \
 163     STORAGECLASS pthread_mutex_t NAME;
 164 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
 165     STORAGECLASS pthread_mutex_t NAME = gl_lock_initializer;
 166 # define gl_lock_initializer \
 167     PTHREAD_MUTEX_INITIALIZER
 168 # define glthread_lock_init(LOCK) \
 169     (pthread_in_use () ? pthread_mutex_init (LOCK, NULL) : 0)
 170 # define glthread_lock_lock(LOCK) \
 171     (pthread_in_use () ? pthread_mutex_lock (LOCK) : 0)
 172 # define glthread_lock_unlock(LOCK) \
 173     (pthread_in_use () ? pthread_mutex_unlock (LOCK) : 0)
 174 # define glthread_lock_destroy(LOCK) \
 175     (pthread_in_use () ? pthread_mutex_destroy (LOCK) : 0)
 176
 177 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 178
 179 # if HAVE_PTHREAD_RWLOCK
 180
 181 #  ifdef PTHREAD_RWLOCK_INITIALIZER
 182
 183 typedef pthread_rwlock_t gl_rwlock_t;
 184 #   define gl_rwlock_define(STORAGECLASS, NAME) \
 185       STORAGECLASS pthread_rwlock_t NAME;
 186 #   define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 187       STORAGECLASS pthread_rwlock_t NAME = gl_rwlock_initializer;
 188 #   define gl_rwlock_initializer \
 189       PTHREAD_RWLOCK_INITIALIZER
 190 #   define glthread_rwlock_init(LOCK) \
 191       (pthread_in_use () ? pthread_rwlock_init (LOCK, NULL) : 0)
 192 #   define glthread_rwlock_rdlock(LOCK) \
 193       (pthread_in_use () ? pthread_rwlock_rdlock (LOCK) : 0)
 194 #   define glthread_rwlock_wrlock(LOCK) \
 195       (pthread_in_use () ? pthread_rwlock_wrlock (LOCK) : 0)
 196 #   define glthread_rwlock_unlock(LOCK) \
 197       (pthread_in_use () ? pthread_rwlock_unlock (LOCK) : 0)
 198 #   define glthread_rwlock_destroy(LOCK) \
 199       (pthread_in_use () ? pthread_rwlock_destroy (LOCK) : 0)
 200
 201 #  else
 202
 203 typedef struct
 204         {
 205           int initialized;
 206           pthread_mutex_t guard;   /* protects the initialization */
 207           pthread_rwlock_t rwlock; /* read-write lock */
 208         }
 209         gl_rwlock_t;
 210 #   define gl_rwlock_define(STORAGECLASS, NAME) \
 211       STORAGECLASS gl_rwlock_t NAME;
 212 #   define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 213       STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
 214 #   define gl_rwlock_initializer \
 215       { 0, PTHREAD_MUTEX_INITIALIZER }
 216 #   define glthread_rwlock_init(LOCK) \
 217       (pthread_in_use () ? glthread_rwlock_init_multithreaded (LOCK) : 0)
 218 #   define glthread_rwlock_rdlock(LOCK) \
 219       (pthread_in_use () ? glthread_rwlock_rdlock_multithreaded (LOCK) : 0)
 220 #   define glthread_rwlock_wrlock(LOCK) \
 221       (pthread_in_use () ? glthread_rwlock_wrlock_multithreaded (LOCK) : 0)
 222 #   define glthread_rwlock_unlock(LOCK) \
 223       (pthread_in_use () ? glthread_rwlock_unlock_multithreaded (LOCK) : 0)
 224 #   define glthread_rwlock_destroy(LOCK) \
 225       (pthread_in_use () ? glthread_rwlock_destroy_multithreaded (LOCK) : 0)
 226 extern int glthread_rwlock_init_multithreaded (gl_rwlock_t *lock);
 227 extern int glthread_rwlock_rdlock_multithreaded (gl_rwlock_t *lock);
 228 extern int glthread_rwlock_wrlock_multithreaded (gl_rwlock_t *lock);
 229 extern int glthread_rwlock_unlock_multithreaded (gl_rwlock_t *lock);
 230 extern int glthread_rwlock_destroy_multithreaded (gl_rwlock_t *lock);
 231
 232 #  endif
 233
 234 # else
 235
 236 typedef struct
 237         {
 238           pthread_mutex_t lock; /* protects the remaining fields */
 239           pthread_cond_t waiting_readers; /* waiting readers */
 240           pthread_cond_t waiting_writers; /* waiting writers */
 241           unsigned int waiting_writers_count; /* number of waiting writers */
 242           int runcount; /* number of readers running, or -1 when a writer runs */
 243         }
 244         gl_rwlock_t;
 245 # define gl_rwlock_define(STORAGECLASS, NAME) \
 246     STORAGECLASS gl_rwlock_t NAME;
 247 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 248     STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
 249 # define gl_rwlock_initializer \
 250     { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, 0 }
 251 # define glthread_rwlock_init(LOCK) \
 252     (pthread_in_use () ? glthread_rwlock_init_multithreaded (LOCK) : 0)
 253 # define glthread_rwlock_rdlock(LOCK) \
 254     (pthread_in_use () ? glthread_rwlock_rdlock_multithreaded (LOCK) : 0)
 255 # define glthread_rwlock_wrlock(LOCK) \
 256     (pthread_in_use () ? glthread_rwlock_wrlock_multithreaded (LOCK) : 0)
 257 # define glthread_rwlock_unlock(LOCK) \
 258     (pthread_in_use () ? glthread_rwlock_unlock_multithreaded (LOCK) : 0)
 259 # define glthread_rwlock_destroy(LOCK) \
 260     (pthread_in_use () ? glthread_rwlock_destroy_multithreaded (LOCK) : 0)
 261 extern int glthread_rwlock_init_multithreaded (gl_rwlock_t *lock);
 262 extern int glthread_rwlock_rdlock_multithreaded (gl_rwlock_t *lock);
 263 extern int glthread_rwlock_wrlock_multithreaded (gl_rwlock_t *lock);
 264 extern int glthread_rwlock_unlock_multithreaded (gl_rwlock_t *lock);
 265 extern int glthread_rwlock_destroy_multithreaded (gl_rwlock_t *lock);
 266
 267 # endif
 268
 269 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 270
 271 # if HAVE_PTHREAD_MUTEX_RECURSIVE
 272
 273 #  if defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER || defined PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
 274
 275 typedef pthread_mutex_t gl_recursive_lock_t;
 276 #   define gl_recursive_lock_define(STORAGECLASS, NAME) \
 277       STORAGECLASS pthread_mutex_t NAME;
 278 #   define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 279       STORAGECLASS pthread_mutex_t NAME = gl_recursive_lock_initializer;
 280 #   ifdef PTHREAD_RECURSIVE_MUTEX_INITIALIZER
 281 #    define gl_recursive_lock_initializer \
 282        PTHREAD_RECURSIVE_MUTEX_INITIALIZER
 283 #   else
 284 #    define gl_recursive_lock_initializer \
 285        PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
 286 #   endif
 287 #   define glthread_recursive_lock_init(LOCK) \
 288       (pthread_in_use () ? glthread_recursive_lock_init_multithreaded (LOCK) : 0)
 289 #   define glthread_recursive_lock_lock(LOCK) \
 290       (pthread_in_use () ? pthread_mutex_lock (LOCK) : 0)
 291 #   define glthread_recursive_lock_unlock(LOCK) \
 292       (pthread_in_use () ? pthread_mutex_unlock (LOCK) : 0)
 293 #   define glthread_recursive_lock_destroy(LOCK) \
 294       (pthread_in_use () ? pthread_mutex_destroy (LOCK) : 0)
 295 extern int glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock);
 296
 297 #  else
 298
 299 typedef struct
 300         {
 301           pthread_mutex_t recmutex; /* recursive mutex */
 302           pthread_mutex_t guard;    /* protects the initialization */
 303           int initialized;
 304         }
 305         gl_recursive_lock_t;
 306 #   define gl_recursive_lock_define(STORAGECLASS, NAME) \
 307       STORAGECLASS gl_recursive_lock_t NAME;
 308 #   define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 309       STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
 310 #   define gl_recursive_lock_initializer \
 311       { PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER, 0 }
 312 #   define glthread_recursive_lock_init(LOCK) \
 313       (pthread_in_use () ? glthread_recursive_lock_init_multithreaded (LOCK) : 0)
 314 #   define glthread_recursive_lock_lock(LOCK) \
 315       (pthread_in_use () ? glthread_recursive_lock_lock_multithreaded (LOCK) : 0)
 316 #   define glthread_recursive_lock_unlock(LOCK) \
 317       (pthread_in_use () ? glthread_recursive_lock_unlock_multithreaded (LOCK) : 0)
 318 #   define glthread_recursive_lock_destroy(LOCK) \
 319       (pthread_in_use () ? glthread_recursive_lock_destroy_multithreaded (LOCK) : 0)
 320 extern int glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock);
 321 extern int glthread_recursive_lock_lock_multithreaded (gl_recursive_lock_t *lock);
 322 extern int glthread_recursive_lock_unlock_multithreaded (gl_recursive_lock_t *lock);
 323 extern int glthread_recursive_lock_destroy_multithreaded (gl_recursive_lock_t *lock);
 324
 325 #  endif
 326
 327 # else
 328
 329 /* Old versions of POSIX threads on Solaris did not have recursive locks.
 330    We have to implement them ourselves.  */
 331
 332 typedef struct
 333         {
 334           pthread_mutex_t mutex;
 335           pthread_t owner;
 336           unsigned long depth;
 337         }
 338         gl_recursive_lock_t;
 339 #  define gl_recursive_lock_define(STORAGECLASS, NAME) \
 340      STORAGECLASS gl_recursive_lock_t NAME;
 341 #  define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 342      STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
 343 #  define gl_recursive_lock_initializer \
 344      { PTHREAD_MUTEX_INITIALIZER, (pthread_t) 0, 0 }
 345 #  define glthread_recursive_lock_init(LOCK) \
 346      (pthread_in_use () ? glthread_recursive_lock_init_multithreaded (LOCK) : 0)
 347 #  define glthread_recursive_lock_lock(LOCK) \
 348      (pthread_in_use () ? glthread_recursive_lock_lock_multithreaded (LOCK) : 0)
 349 #  define glthread_recursive_lock_unlock(LOCK) \
 350      (pthread_in_use () ? glthread_recursive_lock_unlock_multithreaded (LOCK) : 0)
 351 #  define glthread_recursive_lock_destroy(LOCK) \
 352      (pthread_in_use () ? glthread_recursive_lock_destroy_multithreaded (LOCK) : 0)
 353 extern int glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock);
 354 extern int glthread_recursive_lock_lock_multithreaded (gl_recursive_lock_t *lock);
 355 extern int glthread_recursive_lock_unlock_multithreaded (gl_recursive_lock_t *lock);
 356 extern int glthread_recursive_lock_destroy_multithreaded (gl_recursive_lock_t *lock);
 357
 358 # endif
 359
 360 /* -------------------------- gl_once_t datatype -------------------------- */
 361
 362 typedef pthread_once_t gl_once_t;
 363 # define gl_once_define(STORAGECLASS, NAME) \
 364     STORAGECLASS pthread_once_t NAME = PTHREAD_ONCE_INIT;
 365 # define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 366     (pthread_in_use ()                                                         \
 367      ? pthread_once (ONCE_CONTROL, INITFUNCTION)                               \
 368      : (glthread_once_singlethreaded (ONCE_CONTROL) ? (INITFUNCTION (), 0) : 0))
 369 extern int glthread_once_singlethreaded (pthread_once_t *once_control);
 370
 371 # ifdef __cplusplus
 372 }
 373 # endif
 374
 375 #endif
 376
 377 /* ========================================================================= */
 378
 379 #if USE_PTH_THREADS
 380
 381 /* Use the GNU Pth threads library.  */
 382
 383 # include <pth.h>
 384
 385 # ifdef __cplusplus
 386 extern "C" {
 387 # endif
 388
 389 # if USE_PTH_THREADS_WEAK
 390
 391 /* Use weak references to the GNU Pth threads library.  */
 392
 393 #  pragma weak pth_mutex_init
 394 #  pragma weak pth_mutex_acquire
 395 #  pragma weak pth_mutex_release
 396 #  pragma weak pth_rwlock_init
 397 #  pragma weak pth_rwlock_acquire
 398 #  pragma weak pth_rwlock_release
 399 #  pragma weak pth_once
 400
 401 #  pragma weak pth_cancel
 402 #  define pth_in_use() (pth_cancel != NULL)
 403
 404 # else
 405
 406 #  define pth_in_use() 1
 407
 408 # endif
 409
 410 /* -------------------------- gl_lock_t datatype -------------------------- */
 411
 412 typedef pth_mutex_t gl_lock_t;
 413 # define gl_lock_define(STORAGECLASS, NAME) \
 414     STORAGECLASS pth_mutex_t NAME;
 415 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
 416     STORAGECLASS pth_mutex_t NAME = gl_lock_initializer;
 417 # define gl_lock_initializer \
 418     PTH_MUTEX_INIT
 419 # define glthread_lock_init(LOCK) \
 420     (pth_in_use () && !pth_mutex_init (LOCK) ? errno : 0)
 421 # define glthread_lock_lock(LOCK) \
 422     (pth_in_use () && !pth_mutex_acquire (LOCK, 0, NULL) ? errno : 0)
 423 # define glthread_lock_unlock(LOCK) \
 424     (pth_in_use () && !pth_mutex_release (LOCK) ? errno : 0)
 425 # define glthread_lock_destroy(LOCK) \
 426     ((void)(LOCK), 0)
 427
 428 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 429
 430 typedef pth_rwlock_t gl_rwlock_t;
 431 #  define gl_rwlock_define(STORAGECLASS, NAME) \
 432      STORAGECLASS pth_rwlock_t NAME;
 433 #  define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 434      STORAGECLASS pth_rwlock_t NAME = gl_rwlock_initializer;
 435 #  define gl_rwlock_initializer \
 436      PTH_RWLOCK_INIT
 437 #  define glthread_rwlock_init(LOCK) \
 438      (pth_in_use () && !pth_rwlock_init (LOCK) ? errno : 0)
 439 #  define glthread_rwlock_rdlock(LOCK) \
 440      (pth_in_use () && !pth_rwlock_acquire (LOCK, PTH_RWLOCK_RD, 0, NULL) ? errno : 0)
 441 #  define glthread_rwlock_wrlock(LOCK) \
 442      (pth_in_use () && !pth_rwlock_acquire (LOCK, PTH_RWLOCK_RW, 0, NULL) ? errno : 0)
 443 #  define glthread_rwlock_unlock(LOCK) \
 444      (pth_in_use () && !pth_rwlock_release (LOCK) ? errno : 0)
 445 #  define glthread_rwlock_destroy(LOCK) \
 446      ((void)(LOCK), 0)
 447
 448 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 449
 450 /* In Pth, mutexes are recursive by default.  */
 451 typedef pth_mutex_t gl_recursive_lock_t;
 452 #  define gl_recursive_lock_define(STORAGECLASS, NAME) \
 453      STORAGECLASS pth_mutex_t NAME;
 454 #  define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 455      STORAGECLASS pth_mutex_t NAME = gl_recursive_lock_initializer;
 456 #  define gl_recursive_lock_initializer \
 457      PTH_MUTEX_INIT
 458 #  define glthread_recursive_lock_init(LOCK) \
 459      (pth_in_use () && !pth_mutex_init (LOCK) ? errno : 0)
 460 #  define glthread_recursive_lock_lock(LOCK) \
 461      (pth_in_use () && !pth_mutex_acquire (LOCK, 0, NULL) ? errno : 0)
 462 #  define glthread_recursive_lock_unlock(LOCK) \
 463      (pth_in_use () && !pth_mutex_release (LOCK) ? errno : 0)
 464 #  define glthread_recursive_lock_destroy(LOCK) \
 465      ((void)(LOCK), 0)
 466
 467 /* -------------------------- gl_once_t datatype -------------------------- */
 468
 469 typedef pth_once_t gl_once_t;
 470 # define gl_once_define(STORAGECLASS, NAME) \
 471     STORAGECLASS pth_once_t NAME = PTH_ONCE_INIT;
 472 # define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 473     (pth_in_use ()                                                             \
 474      ? glthread_once_multithreaded (ONCE_CONTROL, INITFUNCTION)                \
 475      : (glthread_once_singlethreaded (ONCE_CONTROL) ? (INITFUNCTION (), 0) : 0))
 476 extern int glthread_once_multithreaded (pth_once_t *once_control, void (*initfunction) (void));
 477 extern int glthread_once_singlethreaded (pth_once_t *once_control);
 478
 479 # ifdef __cplusplus
 480 }
 481 # endif
 482
 483 #endif
 484
 485 /* ========================================================================= */
 486
 487 #if USE_SOLARIS_THREADS
 488
 489 /* Use the old Solaris threads library.  */
 490
 491 # include <thread.h>
 492 # include <synch.h>
 493
 494 # ifdef __cplusplus
 495 extern "C" {
 496 # endif
 497
 498 # if USE_SOLARIS_THREADS_WEAK
 499
 500 /* Use weak references to the old Solaris threads library.  */
 501
 502 #  pragma weak mutex_init
 503 #  pragma weak mutex_lock
 504 #  pragma weak mutex_unlock
 505 #  pragma weak mutex_destroy
 506 #  pragma weak rwlock_init
 507 #  pragma weak rw_rdlock
 508 #  pragma weak rw_wrlock
 509 #  pragma weak rw_unlock
 510 #  pragma weak rwlock_destroy
 511 #  pragma weak thr_self
 512
 513 #  pragma weak thr_suspend
 514 #  define thread_in_use() (thr_suspend != NULL)
 515
 516 # else
 517
 518 #  define thread_in_use() 1
 519
 520 # endif
 521
 522 /* -------------------------- gl_lock_t datatype -------------------------- */
 523
 524 typedef mutex_t gl_lock_t;
 525 # define gl_lock_define(STORAGECLASS, NAME) \
 526     STORAGECLASS mutex_t NAME;
 527 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
 528     STORAGECLASS mutex_t NAME = gl_lock_initializer;
 529 # define gl_lock_initializer \
 530     DEFAULTMUTEX
 531 # define glthread_lock_init(LOCK) \
 532     (thread_in_use () ? mutex_init (LOCK, USYNC_THREAD, NULL) : 0)
 533 # define glthread_lock_lock(LOCK) \
 534     (thread_in_use () ? mutex_lock (LOCK) : 0)
 535 # define glthread_lock_unlock(LOCK) \
 536     (thread_in_use () ? mutex_unlock (LOCK) : 0)
 537 # define glthread_lock_destroy(LOCK) \
 538     (thread_in_use () ? mutex_destroy (LOCK) : 0)
 539
 540 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 541
 542 typedef rwlock_t gl_rwlock_t;
 543 # define gl_rwlock_define(STORAGECLASS, NAME) \
 544     STORAGECLASS rwlock_t NAME;
 545 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 546     STORAGECLASS rwlock_t NAME = gl_rwlock_initializer;
 547 # define gl_rwlock_initializer \
 548     DEFAULTRWLOCK
 549 # define glthread_rwlock_init(LOCK) \
 550     (thread_in_use () ? rwlock_init (LOCK, USYNC_THREAD, NULL) : 0)
 551 # define glthread_rwlock_rdlock(LOCK) \
 552     (thread_in_use () ? rw_rdlock (LOCK) : 0)
 553 # define glthread_rwlock_wrlock(LOCK) \
 554     (thread_in_use () ? rw_wrlock (LOCK) : 0)
 555 # define glthread_rwlock_unlock(LOCK) \
 556     (thread_in_use () ? rw_unlock (LOCK) : 0)
 557 # define glthread_rwlock_destroy(LOCK) \
 558     (thread_in_use () ? rwlock_destroy (LOCK) : 0)
 559
 560 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 561
 562 /* Old Solaris threads did not have recursive locks.
 563    We have to implement them ourselves.  */
 564
 565 typedef struct
 566         {
 567           mutex_t mutex;
 568           thread_t owner;
 569           unsigned long depth;
 570         }
 571         gl_recursive_lock_t;
 572 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
 573     STORAGECLASS gl_recursive_lock_t NAME;
 574 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 575     STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
 576 # define gl_recursive_lock_initializer \
 577     { DEFAULTMUTEX, (thread_t) 0, 0 }
 578 # define glthread_recursive_lock_init(LOCK) \
 579     (thread_in_use () ? glthread_recursive_lock_init_multithreaded (LOCK) : 0)
 580 # define glthread_recursive_lock_lock(LOCK) \
 581     (thread_in_use () ? glthread_recursive_lock_lock_multithreaded (LOCK) : 0)
 582 # define glthread_recursive_lock_unlock(LOCK) \
 583     (thread_in_use () ? glthread_recursive_lock_unlock_multithreaded (LOCK) : 0)
 584 # define glthread_recursive_lock_destroy(LOCK) \
 585     (thread_in_use () ? glthread_recursive_lock_destroy_multithreaded (LOCK) : 0)
 586 extern int glthread_recursive_lock_init_multithreaded (gl_recursive_lock_t *lock);
 587 extern int glthread_recursive_lock_lock_multithreaded (gl_recursive_lock_t *lock);
 588 extern int glthread_recursive_lock_unlock_multithreaded (gl_recursive_lock_t *lock);
 589 extern int glthread_recursive_lock_destroy_multithreaded (gl_recursive_lock_t *lock);
 590
 591 /* -------------------------- gl_once_t datatype -------------------------- */
 592
 593 typedef struct
 594         {
 595           volatile int inited;
 596           mutex_t mutex;
 597         }
 598         gl_once_t;
 599 # define gl_once_define(STORAGECLASS, NAME) \
 600     STORAGECLASS gl_once_t NAME = { 0, DEFAULTMUTEX };
 601 # define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 602     (thread_in_use ()                                                          \
 603      ? glthread_once_multithreaded (ONCE_CONTROL, INITFUNCTION)                \
 604      : (glthread_once_singlethreaded (ONCE_CONTROL) ? (INITFUNCTION (), 0) : 0))
 605 extern int glthread_once_multithreaded (gl_once_t *once_control, void (*initfunction) (void));
 606 extern int glthread_once_singlethreaded (gl_once_t *once_control);
 607
 608 # ifdef __cplusplus
 609 }
 610 # endif
 611
 612 #endif
 613
 614 /* ========================================================================= */
 615
 616 #if USE_WINDOWS_THREADS
 617
 618 # define WIN32_LEAN_AND_MEAN  /* avoid including junk */
 619 # include <windows.h>
 620
 621 # ifdef __cplusplus
 622 extern "C" {
 623 # endif
 624
 625 /* We can use CRITICAL_SECTION directly, rather than the native Windows Event,
 626    Mutex, Semaphore types, because
 627      - we need only to synchronize inside a single process (address space),
 628        not inter-process locking,
 629      - we don't need to support trylock operations.  (TryEnterCriticalSection
 630        does not work on Windows 95/98/ME.  Packages that need trylock usually
 631        define their own mutex type.)  */
 632
 633 /* There is no way to statically initialize a CRITICAL_SECTION.  It needs
 634    to be done lazily, once only.  For this we need spinlocks.  */
 635
 636 typedef struct { volatile int done; volatile long started; } gl_spinlock_t;
 637
 638 /* -------------------------- gl_lock_t datatype -------------------------- */
 639
 640 typedef struct
 641         {
 642           gl_spinlock_t guard; /* protects the initialization */
 643           CRITICAL_SECTION lock;
 644         }
 645         gl_lock_t;
 646 # define gl_lock_define(STORAGECLASS, NAME) \
 647     STORAGECLASS gl_lock_t NAME;
 648 # define gl_lock_define_initialized(STORAGECLASS, NAME) \
 649     STORAGECLASS gl_lock_t NAME = gl_lock_initializer;
 650 # define gl_lock_initializer \
 651     { { 0, -1 } }
 652 # define glthread_lock_init(LOCK) \
 653     (glthread_lock_init_func (LOCK), 0)
 654 # define glthread_lock_lock(LOCK) \
 655     glthread_lock_lock_func (LOCK)
 656 # define glthread_lock_unlock(LOCK) \
 657     glthread_lock_unlock_func (LOCK)
 658 # define glthread_lock_destroy(LOCK) \
 659     glthread_lock_destroy_func (LOCK)
 660 extern void glthread_lock_init_func (gl_lock_t *lock);
 661 extern int glthread_lock_lock_func (gl_lock_t *lock);
 662 extern int glthread_lock_unlock_func (gl_lock_t *lock);
 663 extern int glthread_lock_destroy_func (gl_lock_t *lock);
 664
 665 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 666
 667 /* It is impossible to implement read-write locks using plain locks, without
 668    introducing an extra thread dedicated to managing read-write locks.
 669    Therefore here we need to use the low-level Event type.  */
 670
 671 typedef struct
 672         {
 673           HANDLE *array; /* array of waiting threads, each represented by an event */
 674           unsigned int count; /* number of waiting threads */
 675           unsigned int alloc; /* length of allocated array */
 676           unsigned int offset; /* index of first waiting thread in array */
 677         }
 678         gl_carray_waitqueue_t;
 679 typedef struct
 680         {
 681           gl_spinlock_t guard; /* protects the initialization */
 682           CRITICAL_SECTION lock; /* protects the remaining fields */
 683           gl_carray_waitqueue_t waiting_readers; /* waiting readers */
 684           gl_carray_waitqueue_t waiting_writers; /* waiting writers */
 685           int runcount; /* number of readers running, or -1 when a writer runs */
 686         }
 687         gl_rwlock_t;
 688 # define gl_rwlock_define(STORAGECLASS, NAME) \
 689     STORAGECLASS gl_rwlock_t NAME;
 690 # define gl_rwlock_define_initialized(STORAGECLASS, NAME) \
 691     STORAGECLASS gl_rwlock_t NAME = gl_rwlock_initializer;
 692 # define gl_rwlock_initializer \
 693     { { 0, -1 } }
 694 # define glthread_rwlock_init(LOCK) \
 695     (glthread_rwlock_init_func (LOCK), 0)
 696 # define glthread_rwlock_rdlock(LOCK) \
 697     glthread_rwlock_rdlock_func (LOCK)
 698 # define glthread_rwlock_wrlock(LOCK) \
 699     glthread_rwlock_wrlock_func (LOCK)
 700 # define glthread_rwlock_unlock(LOCK) \
 701     glthread_rwlock_unlock_func (LOCK)
 702 # define glthread_rwlock_destroy(LOCK) \
 703     glthread_rwlock_destroy_func (LOCK)
 704 extern void glthread_rwlock_init_func (gl_rwlock_t *lock);
 705 extern int glthread_rwlock_rdlock_func (gl_rwlock_t *lock);
 706 extern int glthread_rwlock_wrlock_func (gl_rwlock_t *lock);
 707 extern int glthread_rwlock_unlock_func (gl_rwlock_t *lock);
 708 extern int glthread_rwlock_destroy_func (gl_rwlock_t *lock);
 709
 710 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 711
 712 /* The native Windows documentation says that CRITICAL_SECTION already
 713    implements a recursive lock.  But we need not rely on it: It's easy to
 714    implement a recursive lock without this assumption.  */
 715
 716 typedef struct
 717         {
 718           gl_spinlock_t guard; /* protects the initialization */
 719           DWORD owner;
 720           unsigned long depth;
 721           CRITICAL_SECTION lock;
 722         }
 723         gl_recursive_lock_t;
 724 # define gl_recursive_lock_define(STORAGECLASS, NAME) \
 725     STORAGECLASS gl_recursive_lock_t NAME;
 726 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME) \
 727     STORAGECLASS gl_recursive_lock_t NAME = gl_recursive_lock_initializer;
 728 # define gl_recursive_lock_initializer \
 729     { { 0, -1 }, 0, 0 }
 730 # define glthread_recursive_lock_init(LOCK) \
 731     (glthread_recursive_lock_init_func (LOCK), 0)
 732 # define glthread_recursive_lock_lock(LOCK) \
 733     glthread_recursive_lock_lock_func (LOCK)
 734 # define glthread_recursive_lock_unlock(LOCK) \
 735     glthread_recursive_lock_unlock_func (LOCK)
 736 # define glthread_recursive_lock_destroy(LOCK) \
 737     glthread_recursive_lock_destroy_func (LOCK)
 738 extern void glthread_recursive_lock_init_func (gl_recursive_lock_t *lock);
 739 extern int glthread_recursive_lock_lock_func (gl_recursive_lock_t *lock);
 740 extern int glthread_recursive_lock_unlock_func (gl_recursive_lock_t *lock);
 741 extern int glthread_recursive_lock_destroy_func (gl_recursive_lock_t *lock);
 742
 743 /* -------------------------- gl_once_t datatype -------------------------- */
 744
 745 typedef struct
 746         {
 747           volatile int inited;
 748           volatile long started;
 749           CRITICAL_SECTION lock;
 750         }
 751         gl_once_t;
 752 # define gl_once_define(STORAGECLASS, NAME) \
 753     STORAGECLASS gl_once_t NAME = { -1, -1 };
 754 # define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 755     (glthread_once_func (ONCE_CONTROL, INITFUNCTION), 0)
 756 extern void glthread_once_func (gl_once_t *once_control, void (*initfunction) (void));
 757
 758 # ifdef __cplusplus
 759 }
 760 # endif
 761
 762 #endif
 763
 764 /* ========================================================================= */
 765
 766 #if !(USE_POSIX_THREADS || USE_PTH_THREADS || USE_SOLARIS_THREADS || USE_WINDOWS_THREADS)
 767
 768 /* Provide dummy implementation if threads are not supported.  */
 769
 770 /* -------------------------- gl_lock_t datatype -------------------------- */
 771
 772 typedef int gl_lock_t;
 773 # define gl_lock_define(STORAGECLASS, NAME)
 774 # define gl_lock_define_initialized(STORAGECLASS, NAME)
 775 # define glthread_lock_init(NAME) 0
 776 # define glthread_lock_lock(NAME) 0
 777 # define glthread_lock_unlock(NAME) 0
 778 # define glthread_lock_destroy(NAME) 0
 779
 780 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 781
 782 typedef int gl_rwlock_t;
 783 # define gl_rwlock_define(STORAGECLASS, NAME)
 784 # define gl_rwlock_define_initialized(STORAGECLASS, NAME)
 785 # define glthread_rwlock_init(NAME) 0
 786 # define glthread_rwlock_rdlock(NAME) 0
 787 # define glthread_rwlock_wrlock(NAME) 0
 788 # define glthread_rwlock_unlock(NAME) 0
 789 # define glthread_rwlock_destroy(NAME) 0
 790
 791 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 792
 793 typedef int gl_recursive_lock_t;
 794 # define gl_recursive_lock_define(STORAGECLASS, NAME)
 795 # define gl_recursive_lock_define_initialized(STORAGECLASS, NAME)
 796 # define glthread_recursive_lock_init(NAME) 0
 797 # define glthread_recursive_lock_lock(NAME) 0
 798 # define glthread_recursive_lock_unlock(NAME) 0
 799 # define glthread_recursive_lock_destroy(NAME) 0
 800
 801 /* -------------------------- gl_once_t datatype -------------------------- */
 802
 803 typedef int gl_once_t;
 804 # define gl_once_define(STORAGECLASS, NAME) \
 805     STORAGECLASS gl_once_t NAME = 0;
 806 # define glthread_once(ONCE_CONTROL, INITFUNCTION) \
 807     (*(ONCE_CONTROL) == 0 ? (*(ONCE_CONTROL) = ~ 0, INITFUNCTION (), 0) : 0)
 808
 809 #endif
 810
 811 /* ========================================================================= */
 812
 813 /* Macros with built-in error handling.  */
 814
 815 /* -------------------------- gl_lock_t datatype -------------------------- */
 816
 817 #define gl_lock_init(NAME) \
 818    do                                  \
 819      {                                 \
 820        if (glthread_lock_init (&NAME)) \
 821          abort ();                     \
 822      }                                 \
 823    while (0)
 824 #define gl_lock_lock(NAME) \
 825    do                                  \
 826      {                                 \
 827        if (glthread_lock_lock (&NAME)) \
 828          abort ();                     \
 829      }                                 \
 830    while (0)
 831 #define gl_lock_unlock(NAME) \
 832    do                                    \
 833      {                                   \
 834        if (glthread_lock_unlock (&NAME)) \
 835          abort ();                       \
 836      }                                   \
 837    while (0)
 838 #define gl_lock_destroy(NAME) \
 839    do                                     \
 840      {                                    \
 841        if (glthread_lock_destroy (&NAME)) \
 842          abort ();                        \
 843      }                                    \
 844    while (0)
 845
 846 /* ------------------------- gl_rwlock_t datatype ------------------------- */
 847
 848 #define gl_rwlock_init(NAME) \
 849    do                                    \
 850      {                                   \
 851        if (glthread_rwlock_init (&NAME)) \
 852          abort ();                       \
 853      }                                   \
 854    while (0)
 855 #define gl_rwlock_rdlock(NAME) \
 856    do                                      \
 857      {                                     \
 858        if (glthread_rwlock_rdlock (&NAME)) \
 859          abort ();                         \
 860      }                                     \
 861    while (0)
 862 #define gl_rwlock_wrlock(NAME) \
 863    do                                      \
 864      {                                     \
 865        if (glthread_rwlock_wrlock (&NAME)) \
 866          abort ();                         \
 867      }                                     \
 868    while (0)
 869 #define gl_rwlock_unlock(NAME) \
 870    do                                      \
 871      {                                     \
 872        if (glthread_rwlock_unlock (&NAME)) \
 873          abort ();                         \
 874      }                                     \
 875    while (0)
 876 #define gl_rwlock_destroy(NAME) \
 877    do                                       \
 878      {                                      \
 879        if (glthread_rwlock_destroy (&NAME)) \
 880          abort ();                          \
 881      }                                      \
 882    while (0)
 883
 884 /* --------------------- gl_recursive_lock_t datatype --------------------- */
 885
 886 #define gl_recursive_lock_init(NAME) \
 887    do                                            \
 888      {                                           \
 889        if (glthread_recursive_lock_init (&NAME)) \
 890          abort ();                               \
 891      }                                           \
 892    while (0)
 893 #define gl_recursive_lock_lock(NAME) \
 894    do                                            \
 895      {                                           \
 896        if (glthread_recursive_lock_lock (&NAME)) \
 897          abort ();                               \
 898      }                                           \
 899    while (0)
 900 #define gl_recursive_lock_unlock(NAME) \
 901    do                                              \
 902      {                                             \
 903        if (glthread_recursive_lock_unlock (&NAME)) \
 904          abort ();                                 \
 905      }                                             \
 906    while (0)
 907 #define gl_recursive_lock_destroy(NAME) \
 908    do                                               \
 909      {                                              \
 910        if (glthread_recursive_lock_destroy (&NAME)) \
 911          abort ();                                  \
 912      }                                              \
 913    while (0)
 914
 915 /* -------------------------- gl_once_t datatype -------------------------- */
 916
 917 #define gl_once(NAME, INITFUNCTION) \
 918    do                                           \
 919      {                                          \
 920        if (glthread_once (&NAME, INITFUNCTION)) \
 921          abort ();                              \
 922      }                                          \
 923    while (0)
 924
 925 /* ========================================================================= */
 926
 927 #endif /* _LOCK_H */