1 /* libc-internal interface for mutex locks. NPTL version. 2 Copyright (C) 1996-2003, 2005, 2007 Free Software Foundation, Inc. 3 This file is part of the GNU C Library. 4 5 The GNU C Library is free software; you can redistribute it and/or 6 modify it under the terms of the GNU Lesser General Public License as 7 published by the Free Software Foundation; either version 2.1 of the 8 License, or (at your option) any later version. 9 10 The GNU C Library is distributed in the hope that it will be useful, 11 but WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 Lesser General Public License for more details. 14 15 You should have received a copy of the GNU Lesser General Public 16 License along with the GNU C Library; see the file COPYING.LIB. If not, 17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, 18 Boston, MA 02111-1307, USA. */ 19 20 #ifndef _BITS_LIBC_LOCK_H 21 #define _BITS_LIBC_LOCK_H 1 22 23 #include <pthread.h> 24 #define __need_NULL 25 #include <stddef.h> 26 27 28 /* Fortunately Linux now has a mean to do locking which is realtime 29 safe without the aid of the thread library. We also need no fancy 30 options like error checking mutexes etc. We only need simple 31 locks, maybe recursive. This can be easily and cheaply implemented 32 using futexes. We will use them everywhere except in ld.so since 33 ld.so might be used on old kernels with a different libc.so. */ 34 #ifdef _LIBC 35 # include <lowlevellock.h> 36 # include <tls.h> 37 # include <pthread-functions.h> 38 # include <errno.h> /* For EBUSY. */ 39 # include <gnu/option-groups.h> /* For __OPTION_EGLIBC_BIG_MACROS. */ 40 #endif 41 42 /* Mutex type. */ 43 #if defined _LIBC || defined _IO_MTSAFE_IO 44 # if (defined NOT_IN_libc && !defined IS_IN_libpthread) || !defined _LIBC 45 typedef pthread_mutex_t __libc_lock_t; 46 typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t; 47 # else 48 typedef int __libc_lock_t; 49 typedef struct { int lock; int cnt; void *owner; } __libc_lock_recursive_t; 50 # endif 51 typedef struct { pthread_mutex_t mutex; } __rtld_lock_recursive_t; 52 # ifdef __USE_UNIX98 53 typedef pthread_rwlock_t __libc_rwlock_t; 54 # else 55 typedef struct __libc_rwlock_opaque__ __libc_rwlock_t; 56 # endif 57 #else 58 typedef struct __libc_lock_opaque__ __libc_lock_t; 59 typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t; 60 typedef struct __libc_rwlock_opaque__ __libc_rwlock_t; 61 #endif 62 63 /* Type for key to thread-specific data. */ 64 typedef pthread_key_t __libc_key_t; 65 66 /* Define a lock variable NAME with storage class CLASS. The lock must be 67 initialized with __libc_lock_init before it can be used (or define it 68 with __libc_lock_define_initialized, below). Use `extern' for CLASS to 69 declare a lock defined in another module. In public structure 70 definitions you must use a pointer to the lock structure (i.e., NAME 71 begins with a `*'), because its storage size will not be known outside 72 of libc. */ 73 #define __libc_lock_define(CLASS,NAME) \ 74 CLASS __libc_lock_t NAME; 75 #define __libc_rwlock_define(CLASS,NAME) \ 76 CLASS __libc_rwlock_t NAME; 77 #define __libc_lock_define_recursive(CLASS,NAME) \ 78 CLASS __libc_lock_recursive_t NAME; 79 #define __rtld_lock_define_recursive(CLASS,NAME) \ 80 CLASS __rtld_lock_recursive_t NAME; 81 82 /* Define an initialized lock variable NAME with storage class CLASS. 83 84 For the C library we take a deeper look at the initializer. For 85 this implementation all fields are initialized to zero. Therefore 86 we don't initialize the variable which allows putting it into the 87 BSS section. (Except on PA-RISC and other odd architectures, where 88 initialized locks must be set to one due to the lack of normal 89 atomic operations.) */ 90 91 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 92 # if LLL_LOCK_INITIALIZER == 0 93 # define __libc_lock_define_initialized(CLASS,NAME) \ 94 CLASS __libc_lock_t NAME; 95 # else 96 # define __libc_lock_define_initialized(CLASS,NAME) \ 97 CLASS __libc_lock_t NAME = LLL_LOCK_INITIALIZER; 98 # endif 99 #else 100 # if __LT_SPINLOCK_INIT == 0 101 # define __libc_lock_define_initialized(CLASS,NAME) \ 102 CLASS __libc_lock_t NAME; 103 # else 104 # define __libc_lock_define_initialized(CLASS,NAME) \ 105 CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER; 106 # endif 107 #endif 108 109 #define __libc_rwlock_define_initialized(CLASS,NAME) \ 110 CLASS __libc_rwlock_t NAME = PTHREAD_RWLOCK_INITIALIZER; 111 112 /* Define an initialized recursive lock variable NAME with storage 113 class CLASS. */ 114 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 115 # if LLL_LOCK_INITIALIZER == 0 116 # define __libc_lock_define_initialized_recursive(CLASS,NAME) \ 117 CLASS __libc_lock_recursive_t NAME; 118 # else 119 # define __libc_lock_define_initialized_recursive(CLASS,NAME) \ 120 CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER; 121 # endif 122 # define _LIBC_LOCK_RECURSIVE_INITIALIZER \ 123 { LLL_LOCK_INITIALIZER, 0, NULL } 124 #else 125 # define __libc_lock_define_initialized_recursive(CLASS,NAME) \ 126 CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER; 127 # define _LIBC_LOCK_RECURSIVE_INITIALIZER \ 128 {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP} 129 #endif 130 131 #define __rtld_lock_define_initialized_recursive(CLASS,NAME) \ 132 CLASS __rtld_lock_recursive_t NAME = _RTLD_LOCK_RECURSIVE_INITIALIZER; 133 #define _RTLD_LOCK_RECURSIVE_INITIALIZER \ 134 {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP} 135 136 #define __rtld_lock_initialize(NAME) \ 137 (void) ((NAME) = (__rtld_lock_recursive_t) _RTLD_LOCK_RECURSIVE_INITIALIZER) 138 139 /* If we check for a weakly referenced symbol and then perform a 140 normal jump to it te code generated for some platforms in case of 141 PIC is unnecessarily slow. What would happen is that the function 142 is first referenced as data and then it is called indirectly 143 through the PLT. We can make this a direct jump. */ 144 #ifdef __PIC__ 145 # define __libc_maybe_call(FUNC, ARGS, ELSE) \ 146 (__extension__ ({ __typeof (FUNC) *_fn = (FUNC); \ 147 _fn != NULL ? (*_fn) ARGS : ELSE; })) 148 #else 149 # define __libc_maybe_call(FUNC, ARGS, ELSE) \ 150 (FUNC != NULL ? FUNC ARGS : ELSE) 151 #endif 152 153 /* Call thread functions through the function pointer table. */ 154 #if defined SHARED && !defined NOT_IN_libc 155 # define PTFAVAIL(NAME) __libc_pthread_functions_init 156 # define __libc_ptf_call(FUNC, ARGS, ELSE) \ 157 (__libc_pthread_functions_init ? PTHFCT_CALL (ptr_##FUNC, ARGS) : ELSE) 158 # define __libc_ptf_call_always(FUNC, ARGS) \ 159 PTHFCT_CALL (ptr_##FUNC, ARGS) 160 #else 161 # define PTFAVAIL(NAME) (NAME != NULL) 162 # define __libc_ptf_call(FUNC, ARGS, ELSE) \ 163 __libc_maybe_call (FUNC, ARGS, ELSE) 164 # define __libc_ptf_call_always(FUNC, ARGS) \ 165 FUNC ARGS 166 #endif 167 168 169 /* Initialize the named lock variable, leaving it in a consistent, unlocked 170 state. */ 171 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 172 # define __libc_lock_init(NAME) ((NAME) = LLL_LOCK_INITIALIZER, 0) 173 #else 174 # define __libc_lock_init(NAME) \ 175 __libc_maybe_call (__pthread_mutex_init, (&(NAME), NULL), 0) 176 #endif 177 #if defined SHARED && !defined NOT_IN_libc 178 /* ((NAME) = (__libc_rwlock_t) PTHREAD_RWLOCK_INITIALIZER, 0) is 179 inefficient. */ 180 # define __libc_rwlock_init(NAME) \ 181 (__builtin_memset (&(NAME), '\0', sizeof (NAME)), 0) 182 #else 183 # define __libc_rwlock_init(NAME) \ 184 __libc_maybe_call (__pthread_rwlock_init, (&(NAME), NULL), 0) 185 #endif 186 187 /* Same as last but this time we initialize a recursive mutex. */ 188 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 189 # define __libc_lock_init_recursive(NAME) \ 190 ((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER, 0) 191 #else 192 # define __libc_lock_init_recursive(NAME) \ 193 do { \ 194 if (__pthread_mutex_init != NULL) \ 195 { \ 196 pthread_mutexattr_t __attr; \ 197 __pthread_mutexattr_init (&__attr); \ 198 __pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \ 199 __pthread_mutex_init (&(NAME).mutex, &__attr); \ 200 __pthread_mutexattr_destroy (&__attr); \ 201 } \ 202 } while (0) 203 #endif 204 205 #define __rtld_lock_init_recursive(NAME) \ 206 do { \ 207 if (__pthread_mutex_init != NULL) \ 208 { \ 209 pthread_mutexattr_t __attr; \ 210 __pthread_mutexattr_init (&__attr); \ 211 __pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \ 212 __pthread_mutex_init (&(NAME).mutex, &__attr); \ 213 __pthread_mutexattr_destroy (&__attr); \ 214 } \ 215 } while (0) 216 217 /* Finalize the named lock variable, which must be locked. It cannot be 218 used again until __libc_lock_init is called again on it. This must be 219 called on a lock variable before the containing storage is reused. */ 220 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 221 # define __libc_lock_fini(NAME) ((void) 0) 222 #else 223 # define __libc_lock_fini(NAME) \ 224 __libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0) 225 #endif 226 #if defined SHARED && !defined NOT_IN_libc 227 # define __libc_rwlock_fini(NAME) ((void) 0) 228 #else 229 # define __libc_rwlock_fini(NAME) \ 230 __libc_maybe_call (__pthread_rwlock_destroy, (&(NAME)), 0) 231 #endif 232 233 /* Finalize recursive named lock. */ 234 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 235 # define __libc_lock_fini_recursive(NAME) ((void) 0) 236 #else 237 # define __libc_lock_fini_recursive(NAME) \ 238 __libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0) 239 #endif 240 241 /* Lock the named lock variable. */ 242 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 243 # if __OPTION_EGLIBC_BIG_MACROS != 1 244 /* EGLIBC: Declare wrapper function for a big macro if either 245 !__OPTION_EGLIBC_BIG_MACROS or we are using a back door from 246 small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */ 247 extern void __libc_lock_lock_fn (__libc_lock_t *); 248 libc_hidden_proto (__libc_lock_lock_fn); 249 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */ 250 # if __OPTION_EGLIBC_BIG_MACROS 251 # define __libc_lock_lock(NAME) \ 252 ({ lll_lock (NAME, LLL_PRIVATE); 0; }) 253 # else 254 # define __libc_lock_lock(NAME) \ 255 __libc_lock_lock_fn (&(NAME)) 256 # endif /* __OPTION_EGLIBC_BIG_MACROS */ 257 #else 258 # define __libc_lock_lock(NAME) \ 259 __libc_maybe_call (__pthread_mutex_lock, (&(NAME)), 0) 260 #endif 261 #define __libc_rwlock_rdlock(NAME) \ 262 __libc_ptf_call (__pthread_rwlock_rdlock, (&(NAME)), 0) 263 #define __libc_rwlock_wrlock(NAME) \ 264 __libc_ptf_call (__pthread_rwlock_wrlock, (&(NAME)), 0) 265 266 /* Lock the recursive named lock variable. */ 267 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 268 # if __OPTION_EGLIBC_BIG_MACROS != 1 269 /* EGLIBC: Declare wrapper function for a big macro if either 270 !__OPTION_EGLIBC_BIG_MACROS or we are using a back door from 271 small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */ 272 extern void __libc_lock_lock_recursive_fn (__libc_lock_recursive_t *); 273 libc_hidden_proto (__libc_lock_lock_recursive_fn); 274 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */ 275 # if __OPTION_EGLIBC_BIG_MACROS 276 # define __libc_lock_lock_recursive(NAME) \ 277 do { \ 278 void *self = THREAD_SELF; \ 279 if ((NAME).owner != self) \ 280 { \ 281 lll_lock ((NAME).lock, LLL_PRIVATE); \ 282 (NAME).owner = self; \ 283 } \ 284 ++(NAME).cnt; \ 285 } while (0) 286 # else 287 # define __libc_lock_lock_recursive(NAME) \ 288 __libc_lock_lock_recursive_fn (&(NAME)) 289 # endif /* __OPTION_EGLIBC_BIG_MACROS */ 290 #else 291 # define __libc_lock_lock_recursive(NAME) \ 292 __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0) 293 #endif 294 295 /* Try to lock the named lock variable. */ 296 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 297 # if __OPTION_EGLIBC_BIG_MACROS != 1 298 /* EGLIBC: Declare wrapper function for a big macro if either 299 !__OPTION_EGLIBC_BIG_MACROS or we are using a back door from 300 small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */ 301 extern int __libc_lock_trylock_fn (__libc_lock_t *); 302 libc_hidden_proto (__libc_lock_trylock_fn); 303 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */ 304 # if __OPTION_EGLIBC_BIG_MACROS 305 # define __libc_lock_trylock(NAME) \ 306 lll_trylock (NAME) 307 # else 308 # define __libc_lock_trylock(NAME) \ 309 __libc_lock_trylock_fn (&(NAME)) 310 # endif /* __OPTION_EGLIBC_BIG_MACROS */ 311 #else 312 # define __libc_lock_trylock(NAME) \ 313 __libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0) 314 #endif 315 #define __libc_rwlock_tryrdlock(NAME) \ 316 __libc_maybe_call (__pthread_rwlock_tryrdlock, (&(NAME)), 0) 317 #define __libc_rwlock_trywrlock(NAME) \ 318 __libc_maybe_call (__pthread_rwlock_trywrlock, (&(NAME)), 0) 319 320 /* Try to lock the recursive named lock variable. */ 321 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 322 # if __OPTION_EGLIBC_BIG_MACROS != 1 323 /* EGLIBC: Declare wrapper function for a big macro if either 324 !__OPTION_EGLIBC_BIG_MACROS or we are using a back door from 325 small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */ 326 extern int __libc_lock_trylock_recursive_fn (__libc_lock_recursive_t *); 327 libc_hidden_proto (__libc_lock_trylock_recursive_fn); 328 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */ 329 # if __OPTION_EGLIBC_BIG_MACROS 330 # define __libc_lock_trylock_recursive(NAME) \ 331 ({ \ 332 int result = 0; \ 333 void *self = THREAD_SELF; \ 334 if ((NAME).owner != self) \ 335 { \ 336 if (lll_trylock ((NAME).lock) == 0) \ 337 { \ 338 (NAME).owner = self; \ 339 (NAME).cnt = 1; \ 340 } \ 341 else \ 342 result = EBUSY; \ 343 } \ 344 else \ 345 ++(NAME).cnt; \ 346 result; \ 347 }) 348 # else 349 # define __libc_lock_trylock_recursive(NAME) \ 350 __libc_lock_trylock_recursive_fn (&(NAME)) 351 # endif /* __OPTION_EGLIBC_BIG_MACROS */ 352 #else 353 # define __libc_lock_trylock_recursive(NAME) \ 354 __libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0) 355 #endif 356 357 #define __rtld_lock_trylock_recursive(NAME) \ 358 __libc_maybe_call (__pthread_mutex_trylock, (&(NAME).mutex), 0) 359 360 /* Unlock the named lock variable. */ 361 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 362 # if __OPTION_EGLIBC_BIG_MACROS != 1 363 /* EGLIBC: Declare wrapper function for a big macro if either 364 !__OPTION_EGLIBC_BIG_MACROS, or we are using a back door from 365 small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */ 366 extern void __libc_lock_unlock_fn (__libc_lock_t *); 367 libc_hidden_proto (__libc_lock_unlock_fn); 368 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */ 369 # if __OPTION_EGLIBC_BIG_MACROS 370 # define __libc_lock_unlock(NAME) \ 371 lll_unlock (NAME, LLL_PRIVATE) 372 # else 373 # define __libc_lock_unlock(NAME) \ 374 __libc_lock_unlock_fn (&(NAME)) 375 # endif /* __OPTION_EGLIBC_BIG_MACROS */ 376 #else 377 # define __libc_lock_unlock(NAME) \ 378 __libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0) 379 #endif 380 #define __libc_rwlock_unlock(NAME) \ 381 __libc_ptf_call (__pthread_rwlock_unlock, (&(NAME)), 0) 382 383 /* Unlock the recursive named lock variable. */ 384 #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread) 385 # if __OPTION_EGLIBC_BIG_MACROS != 1 386 /* EGLIBC: Declare wrapper function for a big macro if either 387 !__OPTION_EGLIBC_BIG_MACROS, or we are using a back door from 388 small-macros-fns.c (__OPTION_EGLIBC_BIG_MACROS == 2). */ 389 extern void __libc_lock_unlock_recursive_fn (__libc_lock_recursive_t *); 390 libc_hidden_proto (__libc_lock_unlock_recursive_fn); 391 # endif /* __OPTION_EGLIBC_BIG_MACROS != 1 */ 392 # if __OPTION_EGLIBC_BIG_MACROS 393 /* We do no error checking here. */ 394 # define __libc_lock_unlock_recursive(NAME) \ 395 do { \ 396 if (--(NAME).cnt == 0) \ 397 { \ 398 (NAME).owner = NULL; \ 399 lll_unlock ((NAME).lock, LLL_PRIVATE); \ 400 } \ 401 } while (0) 402 # else 403 # define __libc_lock_unlock_recursive(NAME) \ 404 __libc_lock_unlock_recursive_fn (&(NAME)) 405 # endif /* __OPTION_EGLIBC_BIG_MACROS */ 406 #else 407 # define __libc_lock_unlock_recursive(NAME) \ 408 __libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0) 409 #endif 410 411 #if defined _LIBC && defined SHARED 412 # define __rtld_lock_default_lock_recursive(lock) \ 413 ++((pthread_mutex_t *)(lock))->__data.__count; 414 415 # define __rtld_lock_default_unlock_recursive(lock) \ 416 --((pthread_mutex_t *)(lock))->__data.__count; 417 418 # define __rtld_lock_lock_recursive(NAME) \ 419 GL(dl_rtld_lock_recursive) (&(NAME).mutex) 420 421 # define __rtld_lock_unlock_recursive(NAME) \ 422 GL(dl_rtld_unlock_recursive) (&(NAME).mutex) 423 #else 424 # define __rtld_lock_lock_recursive(NAME) \ 425 __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0) 426 427 # define __rtld_lock_unlock_recursive(NAME) \ 428 __libc_maybe_call (__pthread_mutex_unlock, (&(NAME).mutex), 0) 429 #endif 430 431 /* Define once control variable. */ 432 #if PTHREAD_ONCE_INIT == 0 433 /* Special case for static variables where we can avoid the initialization 434 if it is zero. */ 435 # define __libc_once_define(CLASS, NAME) \ 436 CLASS pthread_once_t NAME 437 #else 438 # define __libc_once_define(CLASS, NAME) \ 439 CLASS pthread_once_t NAME = PTHREAD_ONCE_INIT 440 #endif 441 442 /* Call handler iff the first call. */ 443 #define __libc_once(ONCE_CONTROL, INIT_FUNCTION) \ 444 do { \ 445 if (PTFAVAIL (__pthread_once)) \ 446 __libc_ptf_call_always (__pthread_once, (&(ONCE_CONTROL), \ 447 INIT_FUNCTION)); \ 448 else if ((ONCE_CONTROL) == PTHREAD_ONCE_INIT) { \ 449 INIT_FUNCTION (); \ 450 (ONCE_CONTROL) |= 2; \ 451 } \ 452 } while (0) 453 454 455 /* Note that for I/O cleanup handling we are using the old-style 456 cancel handling. It does not have to be integrated with C++ snce 457 no C++ code is called in the middle. The old-style handling is 458 faster and the support is not going away. */ 459 extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *buffer, 460 void (*routine) (void *), void *arg); 461 extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *buffer, 462 int execute); 463 extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer, 464 void (*routine) (void *), void *arg); 465 extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer, 466 int execute); 467 468 /* Start critical region with cleanup. */ 469 #define __libc_cleanup_region_start(DOIT, FCT, ARG) \ 470 { struct _pthread_cleanup_buffer _buffer; \ 471 int _avail; \ 472 if (DOIT) { \ 473 _avail = PTFAVAIL (_pthread_cleanup_push_defer); \ 474 if (_avail) { \ 475 __libc_ptf_call_always (_pthread_cleanup_push_defer, (&_buffer, FCT, \ 476 ARG)); \ 477 } else { \ 478 _buffer.__routine = (FCT); \ 479 _buffer.__arg = (ARG); \ 480 } \ 481 } else { \ 482 _avail = 0; \ 483 } 484 485 /* End critical region with cleanup. */ 486 #define __libc_cleanup_region_end(DOIT) \ 487 if (_avail) { \ 488 __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\ 489 } else if (DOIT) \ 490 _buffer.__routine (_buffer.__arg); \ 491 } 492 493 /* Sometimes we have to exit the block in the middle. */ 494 #define __libc_cleanup_end(DOIT) \ 495 if (_avail) { \ 496 __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\ 497 } else if (DOIT) \ 498 _buffer.__routine (_buffer.__arg) 499 500 501 /* Normal cleanup handling, based on C cleanup attribute. */ 502 __extern_inline void 503 __libc_cleanup_routine (struct __pthread_cleanup_frame *f) 504 { 505 if (f->__do_it) 506 f->__cancel_routine (f->__cancel_arg); 507 } 508 509 #define __libc_cleanup_push(fct, arg) \ 510 do { \ 511 struct __pthread_cleanup_frame __clframe \ 512 __attribute__ ((__cleanup__ (__libc_cleanup_routine))) \ 513 = { .__cancel_routine = (fct), .__cancel_arg = (arg), \ 514 .__do_it = 1 }; 515 516 #define __libc_cleanup_pop(execute) \ 517 __clframe.__do_it = (execute); \ 518 } while (0) 519 520 521 /* Create thread-specific key. */ 522 #define __libc_key_create(KEY, DESTRUCTOR) \ 523 __libc_ptf_call (__pthread_key_create, (KEY, DESTRUCTOR), 1) 524 525 /* Get thread-specific data. */ 526 #define __libc_getspecific(KEY) \ 527 __libc_ptf_call (__pthread_getspecific, (KEY), NULL) 528 529 /* Set thread-specific data. */ 530 #define __libc_setspecific(KEY, VALUE) \ 531 __libc_ptf_call (__pthread_setspecific, (KEY, VALUE), 0) 532 533 534 /* Register handlers to execute before and after `fork'. Note that the 535 last parameter is NULL. The handlers registered by the libc are 536 never removed so this is OK. */ 537 #define __libc_atfork(PREPARE, PARENT, CHILD) \ 538 __register_atfork (PREPARE, PARENT, CHILD, NULL) 539 extern int __register_atfork (void (*__prepare) (void), 540 void (*__parent) (void), 541 void (*__child) (void), 542 void *__dso_handle); 543 544 /* Functions that are used by this file and are internal to the GNU C 545 library. */ 546 547 extern int __pthread_mutex_init (pthread_mutex_t *__mutex, 548 __const pthread_mutexattr_t *__mutex_attr); 549 550 extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex); 551 552 extern int __pthread_mutex_trylock (pthread_mutex_t *__mutex); 553 554 extern int __pthread_mutex_lock (pthread_mutex_t *__mutex); 555 556 extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex); 557 558 extern int __pthread_mutexattr_init (pthread_mutexattr_t *__attr); 559 560 extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *__attr); 561 562 extern int __pthread_mutexattr_settype (pthread_mutexattr_t *__attr, 563 int __kind); 564 565 #ifdef __USE_UNIX98 566 extern int __pthread_rwlock_init (pthread_rwlock_t *__rwlock, 567 __const pthread_rwlockattr_t *__attr); 568 569 extern int __pthread_rwlock_destroy (pthread_rwlock_t *__rwlock); 570 571 extern int __pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock); 572 573 extern int __pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock); 574 575 extern int __pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock); 576 577 extern int __pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock); 578 579 extern int __pthread_rwlock_unlock (pthread_rwlock_t *__rwlock); 580 #endif 581 582 extern int __pthread_key_create (pthread_key_t *__key, 583 void (*__destr_function) (void *)); 584 585 extern int __pthread_setspecific (pthread_key_t __key, 586 __const void *__pointer); 587 588 extern void *__pthread_getspecific (pthread_key_t __key); 589 590 extern int __pthread_once (pthread_once_t *__once_control, 591 void (*__init_routine) (void)); 592 593 extern int __pthread_atfork (void (*__prepare) (void), 594 void (*__parent) (void), 595 void (*__child) (void)); 596 597 598 599 /* Make the pthread functions weak so that we can elide them from 600 single-threaded processes. */ 601 #ifndef __NO_WEAK_PTHREAD_ALIASES 602 # ifdef weak_extern 603 # if _LIBC 604 # include <bp-sym.h> 605 # else 606 # define BP_SYM(sym) sym 607 # endif 608 weak_extern (BP_SYM (__pthread_mutex_init)) 609 weak_extern (BP_SYM (__pthread_mutex_destroy)) 610 weak_extern (BP_SYM (__pthread_mutex_lock)) 611 weak_extern (BP_SYM (__pthread_mutex_trylock)) 612 weak_extern (BP_SYM (__pthread_mutex_unlock)) 613 weak_extern (BP_SYM (__pthread_mutexattr_init)) 614 weak_extern (BP_SYM (__pthread_mutexattr_destroy)) 615 weak_extern (BP_SYM (__pthread_mutexattr_settype)) 616 weak_extern (BP_SYM (__pthread_rwlock_init)) 617 weak_extern (BP_SYM (__pthread_rwlock_destroy)) 618 weak_extern (BP_SYM (__pthread_rwlock_rdlock)) 619 weak_extern (BP_SYM (__pthread_rwlock_tryrdlock)) 620 weak_extern (BP_SYM (__pthread_rwlock_wrlock)) 621 weak_extern (BP_SYM (__pthread_rwlock_trywrlock)) 622 weak_extern (BP_SYM (__pthread_rwlock_unlock)) 623 weak_extern (BP_SYM (__pthread_key_create)) 624 weak_extern (BP_SYM (__pthread_setspecific)) 625 weak_extern (BP_SYM (__pthread_getspecific)) 626 weak_extern (BP_SYM (__pthread_once)) 627 weak_extern (__pthread_initialize) 628 weak_extern (__pthread_atfork) 629 weak_extern (BP_SYM (_pthread_cleanup_push_defer)) 630 weak_extern (BP_SYM (_pthread_cleanup_pop_restore)) 631 weak_extern (BP_SYM (pthread_setcancelstate)) 632 # else 633 # pragma weak __pthread_mutex_init 634 # pragma weak __pthread_mutex_destroy 635 # pragma weak __pthread_mutex_lock 636 # pragma weak __pthread_mutex_trylock 637 # pragma weak __pthread_mutex_unlock 638 # pragma weak __pthread_mutexattr_init 639 # pragma weak __pthread_mutexattr_destroy 640 # pragma weak __pthread_mutexattr_settype 641 # pragma weak __pthread_rwlock_destroy 642 # pragma weak __pthread_rwlock_rdlock 643 # pragma weak __pthread_rwlock_tryrdlock 644 # pragma weak __pthread_rwlock_wrlock 645 # pragma weak __pthread_rwlock_trywrlock 646 # pragma weak __pthread_rwlock_unlock 647 # pragma weak __pthread_key_create 648 # pragma weak __pthread_setspecific 649 # pragma weak __pthread_getspecific 650 # pragma weak __pthread_once 651 # pragma weak __pthread_initialize 652 # pragma weak __pthread_atfork 653 # pragma weak _pthread_cleanup_push_defer 654 # pragma weak _pthread_cleanup_pop_restore 655 # pragma weak pthread_setcancelstate 656 # endif 657 #endif 658 659 #endif /* bits/libc-lock.h */ 660
