1 /* Locking in multithreaded situations. 2 Copyright (C) 2005-2015 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 */ 928