sysdeps/nptl/bits/libc-lockP.h

   1 /* Private libc-internal interface for mutex locks.  NPTL version.
   2    Copyright (C) 1996-2014 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
  17    not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #ifndef _BITS_LIBC_LOCKP_H
  20 #define _BITS_LIBC_LOCKP_H 1
  21
  22 #include <pthread.h>
  23 #define __need_NULL
  24 #include <stddef.h>
  25
  26
  27 /* Fortunately Linux now has a mean to do locking which is realtime
  28    safe without the aid of the thread library.  We also need no fancy
  29    options like error checking mutexes etc.  We only need simple
  30    locks, maybe recursive.  This can be easily and cheaply implemented
  31    using futexes.  We will use them everywhere except in ld.so since
  32    ld.so might be used on old kernels with a different libc.so.  */
  33 #include <lowlevellock.h>
  34 #include <tls.h>
  35 #include <pthread-functions.h>
  36
  37 /* Mutex type.  */
  38 #if defined NOT_IN_libc && !defined IS_IN_libpthread
  39 typedef pthread_mutex_t __libc_lock_t;
  40 #else
  41 typedef int __libc_lock_t;
  42 #endif
  43 typedef struct { pthread_mutex_t mutex; } __rtld_lock_recursive_t;
  44 typedef pthread_rwlock_t __libc_rwlock_t;
  45
  46 /* Type for key to thread-specific data.  */
  47 typedef pthread_key_t __libc_key_t;
  48
  49 /* Define a lock variable NAME with storage class CLASS.  The lock must be
  50    initialized with __libc_lock_init before it can be used (or define it
  51    with __libc_lock_define_initialized, below).  Use `extern' for CLASS to
  52    declare a lock defined in another module.  In public structure
  53    definitions you must use a pointer to the lock structure (i.e., NAME
  54    begins with a `*'), because its storage size will not be known outside
  55    of libc.  */
  56 #define __libc_lock_define(CLASS,NAME) \
  57   CLASS __libc_lock_t NAME;
  58 #define __libc_rwlock_define(CLASS,NAME) \
  59   CLASS __libc_rwlock_t NAME;
  60 #define __rtld_lock_define_recursive(CLASS,NAME) \
  61   CLASS __rtld_lock_recursive_t NAME;
  62
  63 /* Define an initialized lock variable NAME with storage class CLASS.
  64
  65    For the C library we take a deeper look at the initializer.  For
  66    this implementation all fields are initialized to zero.  Therefore
  67    we don't initialize the variable which allows putting it into the
  68    BSS section.  (Except on PA-RISC and other odd architectures, where
  69    initialized locks must be set to one due to the lack of normal
  70    atomic operations.) */
  71
  72 #if !defined NOT_IN_libc || defined IS_IN_libpthread
  73 # if LLL_LOCK_INITIALIZER == 0
  74 #  define __libc_lock_define_initialized(CLASS,NAME) \
  75   CLASS __libc_lock_t NAME;
  76 # else
  77 #  define __libc_lock_define_initialized(CLASS,NAME) \
  78   CLASS __libc_lock_t NAME = LLL_LOCK_INITIALIZER;
  79 # endif
  80 #else
  81 # define __libc_lock_define_initialized(CLASS,NAME) \
  82   CLASS __libc_lock_t NAME;
  83 #endif
  84
  85 #define __libc_rwlock_define_initialized(CLASS,NAME) \
  86   CLASS __libc_rwlock_t NAME = PTHREAD_RWLOCK_INITIALIZER;
  87
  88 #define __rtld_lock_define_initialized_recursive(CLASS,NAME) \
  89   CLASS __rtld_lock_recursive_t NAME = _RTLD_LOCK_RECURSIVE_INITIALIZER;
  90 #define _RTLD_LOCK_RECURSIVE_INITIALIZER \
  91   {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
  92
  93 #define __rtld_lock_initialize(NAME) \
  94   (void) ((NAME) = (__rtld_lock_recursive_t) _RTLD_LOCK_RECURSIVE_INITIALIZER)
  95
  96 /* If we check for a weakly referenced symbol and then perform a
  97    normal jump to it te code generated for some platforms in case of
  98    PIC is unnecessarily slow.  What would happen is that the function
  99    is first referenced as data and then it is called indirectly
 100    through the PLT.  We can make this a direct jump.  */
 101 #ifdef __PIC__
 102 # define __libc_maybe_call(FUNC, ARGS, ELSE) \
 103   (__extension__ ({ __typeof (FUNC) *_fn = (FUNC); \
 104                     _fn != NULL ? (*_fn) ARGS : ELSE; }))
 105 #else
 106 # define __libc_maybe_call(FUNC, ARGS, ELSE) \
 107   (FUNC != NULL ? FUNC ARGS : ELSE)
 108 #endif
 109
 110 /* Call thread functions through the function pointer table.  */
 111 #if defined SHARED && !defined NOT_IN_libc
 112 # define PTFAVAIL(NAME) __libc_pthread_functions_init
 113 # define __libc_ptf_call(FUNC, ARGS, ELSE) \
 114   (__libc_pthread_functions_init ? PTHFCT_CALL (ptr_##FUNC, ARGS) : ELSE)
 115 # define __libc_ptf_call_always(FUNC, ARGS) \
 116   PTHFCT_CALL (ptr_##FUNC, ARGS)
 117 #else
 118 # define PTFAVAIL(NAME) (NAME != NULL)
 119 # define __libc_ptf_call(FUNC, ARGS, ELSE) \
 120   __libc_maybe_call (FUNC, ARGS, ELSE)
 121 # define __libc_ptf_call_always(FUNC, ARGS) \
 122   FUNC ARGS
 123 #endif
 124
 125
 126 /* Initialize the named lock variable, leaving it in a consistent, unlocked
 127    state.  */
 128 #if !defined NOT_IN_libc || defined IS_IN_libpthread
 129 # define __libc_lock_init(NAME) \
 130   ((void) ((NAME) = LLL_LOCK_INITIALIZER))
 131 #else
 132 # define __libc_lock_init(NAME) \
 133   __libc_maybe_call (__pthread_mutex_init, (&(NAME), NULL), 0)
 134 #endif
 135 #if defined SHARED && !defined NOT_IN_libc
 136 /* ((NAME) = (__libc_rwlock_t) PTHREAD_RWLOCK_INITIALIZER) is inefficient.  */
 137 # define __libc_rwlock_init(NAME) \
 138   ((void) __builtin_memset (&(NAME), '\0', sizeof (NAME)))
 139 #else
 140 # define __libc_rwlock_init(NAME) \
 141   __libc_maybe_call (__pthread_rwlock_init, (&(NAME), NULL), 0)
 142 #endif
 143
 144 /* Finalize the named lock variable, which must be locked.  It cannot be
 145    used again until __libc_lock_init is called again on it.  This must be
 146    called on a lock variable before the containing storage is reused.  */
 147 #if !defined NOT_IN_libc || defined IS_IN_libpthread
 148 # define __libc_lock_fini(NAME) ((void) 0)
 149 #else
 150 # define __libc_lock_fini(NAME) \
 151   __libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
 152 #endif
 153 #if defined SHARED && !defined NOT_IN_libc
 154 # define __libc_rwlock_fini(NAME) ((void) 0)
 155 #else
 156 # define __libc_rwlock_fini(NAME) \
 157   __libc_maybe_call (__pthread_rwlock_destroy, (&(NAME)), 0)
 158 #endif
 159
 160 /* Lock the named lock variable.  */
 161 #if !defined NOT_IN_libc || defined IS_IN_libpthread
 162 # ifndef __libc_lock_lock
 163 #  define __libc_lock_lock(NAME) \
 164   ({ lll_lock (NAME, LLL_PRIVATE); 0; })
 165 # endif
 166 #else
 167 # undef __libc_lock_lock
 168 # define __libc_lock_lock(NAME) \
 169   __libc_maybe_call (__pthread_mutex_lock, (&(NAME)), 0)
 170 #endif
 171 #define __libc_rwlock_rdlock(NAME) \
 172   __libc_ptf_call (__pthread_rwlock_rdlock, (&(NAME)), 0)
 173 #define __libc_rwlock_wrlock(NAME) \
 174   __libc_ptf_call (__pthread_rwlock_wrlock, (&(NAME)), 0)
 175
 176 /* Try to lock the named lock variable.  */
 177 #if !defined NOT_IN_libc || defined IS_IN_libpthread
 178 # ifndef __libc_lock_trylock
 179 #  define __libc_lock_trylock(NAME) \
 180   lll_trylock (NAME)
 181 # endif
 182 #else
 183 # undef __libc_lock_trylock
 184 # define __libc_lock_trylock(NAME) \
 185   __libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
 186 #endif
 187 #define __libc_rwlock_tryrdlock(NAME) \
 188   __libc_maybe_call (__pthread_rwlock_tryrdlock, (&(NAME)), 0)
 189 #define __libc_rwlock_trywrlock(NAME) \
 190   __libc_maybe_call (__pthread_rwlock_trywrlock, (&(NAME)), 0)
 191
 192 #define __rtld_lock_trylock_recursive(NAME) \
 193   __libc_maybe_call (__pthread_mutex_trylock, (&(NAME).mutex), 0)
 194
 195 /* Unlock the named lock variable.  */
 196 #if !defined NOT_IN_libc || defined IS_IN_libpthread
 197 # define __libc_lock_unlock(NAME) \
 198   lll_unlock (NAME, LLL_PRIVATE)
 199 #else
 200 # define __libc_lock_unlock(NAME) \
 201   __libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
 202 #endif
 203 #define __libc_rwlock_unlock(NAME) \
 204   __libc_ptf_call (__pthread_rwlock_unlock, (&(NAME)), 0)
 205
 206 #ifdef SHARED
 207 # define __rtld_lock_default_lock_recursive(lock) \
 208   ++((pthread_mutex_t *)(lock))->__data.__count;
 209
 210 # define __rtld_lock_default_unlock_recursive(lock) \
 211   --((pthread_mutex_t *)(lock))->__data.__count;
 212
 213 # define __rtld_lock_lock_recursive(NAME) \
 214   GL(dl_rtld_lock_recursive) (&(NAME).mutex)
 215
 216 # define __rtld_lock_unlock_recursive(NAME) \
 217   GL(dl_rtld_unlock_recursive) (&(NAME).mutex)
 218 #else
 219 # define __rtld_lock_lock_recursive(NAME) \
 220   __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
 221
 222 # define __rtld_lock_unlock_recursive(NAME) \
 223   __libc_maybe_call (__pthread_mutex_unlock, (&(NAME).mutex), 0)
 224 #endif
 225
 226 /* Define once control variable.  */
 227 #if PTHREAD_ONCE_INIT == 0
 228 /* Special case for static variables where we can avoid the initialization
 229    if it is zero.  */
 230 # define __libc_once_define(CLASS, NAME) \
 231   CLASS pthread_once_t NAME
 232 #else
 233 # define __libc_once_define(CLASS, NAME) \
 234   CLASS pthread_once_t NAME = PTHREAD_ONCE_INIT
 235 #endif
 236
 237 /* Call handler iff the first call.  */
 238 #define __libc_once(ONCE_CONTROL, INIT_FUNCTION) \
 239   do {                                                                        \
 240     if (PTFAVAIL (__pthread_once))                                            \
 241       __libc_ptf_call_always (__pthread_once, (&(ONCE_CONTROL),               \
 242                                                INIT_FUNCTION));               \
 243     else if ((ONCE_CONTROL) == PTHREAD_ONCE_INIT) {                           \
 244       INIT_FUNCTION ();                                                       \
 245       (ONCE_CONTROL) |= 2;                                                    \
 246     }                                                                         \
 247   } while (0)
 248
 249 /* Get once control variable.  */
 250 #define __libc_once_get(ONCE_CONTROL)   ((ONCE_CONTROL) != PTHREAD_ONCE_INIT)
 251
 252 /* Note that for I/O cleanup handling we are using the old-style
 253    cancel handling.  It does not have to be integrated with C++ snce
 254    no C++ code is called in the middle.  The old-style handling is
 255    faster and the support is not going away.  */
 256 extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *buffer,
 257                                    void (*routine) (void *), void *arg);
 258 extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *buffer,
 259                                   int execute);
 260 extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer,
 261                                          void (*routine) (void *), void *arg);
 262 extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer,
 263                                           int execute);
 264
 265 /* Sometimes we have to exit the block in the middle.  */
 266 #define __libc_cleanup_end(DOIT) \
 267     if (_avail) {                                                             \
 268       __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\
 269     } else if (DOIT)                                                          \
 270       _buffer.__routine (_buffer.__arg)
 271
 272
 273 /* Normal cleanup handling, based on C cleanup attribute.  */
 274 __extern_inline void
 275 __libc_cleanup_routine (struct __pthread_cleanup_frame *f)
 276 {
 277   if (f->__do_it)
 278     f->__cancel_routine (f->__cancel_arg);
 279 }
 280
 281 #define __libc_cleanup_push(fct, arg) \
 282   do {                                                                        \
 283     struct __pthread_cleanup_frame __clframe                                  \
 284       __attribute__ ((__cleanup__ (__libc_cleanup_routine)))                  \
 285       = { .__cancel_routine = (fct), .__cancel_arg = (arg),                   \
 286           .__do_it = 1 };
 287
 288 #define __libc_cleanup_pop(execute) \
 289     __clframe.__do_it = (execute);                                            \
 290   } while (0)
 291
 292
 293 /* Create thread-specific key.  */
 294 #define __libc_key_create(KEY, DESTRUCTOR) \
 295   __libc_ptf_call (__pthread_key_create, (KEY, DESTRUCTOR), 1)
 296
 297 /* Get thread-specific data.  */
 298 #define __libc_getspecific(KEY) \
 299   __libc_ptf_call (__pthread_getspecific, (KEY), NULL)
 300
 301 /* Set thread-specific data.  */
 302 #define __libc_setspecific(KEY, VALUE) \
 303   __libc_ptf_call (__pthread_setspecific, (KEY, VALUE), 0)
 304
 305
 306 /* Register handlers to execute before and after `fork'.  Note that the
 307    last parameter is NULL.  The handlers registered by the libc are
 308    never removed so this is OK.  */
 309 #define __libc_atfork(PREPARE, PARENT, CHILD) \
 310   __register_atfork (PREPARE, PARENT, CHILD, NULL)
 311 extern int __register_atfork (void (*__prepare) (void),
 312                               void (*__parent) (void),
 313                               void (*__child) (void),
 314                               void *__dso_handle);
 315
 316 /* Functions that are used by this file and are internal to the GNU C
 317    library.  */
 318
 319 extern int __pthread_mutex_init (pthread_mutex_t *__mutex,
 320                                  const pthread_mutexattr_t *__mutex_attr);
 321
 322 extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex);
 323
 324 extern int __pthread_mutex_trylock (pthread_mutex_t *__mutex);
 325
 326 extern int __pthread_mutex_lock (pthread_mutex_t *__mutex);
 327
 328 extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex);
 329
 330 extern int __pthread_mutexattr_init (pthread_mutexattr_t *__attr);
 331
 332 extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *__attr);
 333
 334 extern int __pthread_mutexattr_settype (pthread_mutexattr_t *__attr,
 335                                         int __kind);
 336
 337 extern int __pthread_rwlock_init (pthread_rwlock_t *__rwlock,
 338                                   const pthread_rwlockattr_t *__attr);
 339
 340 extern int __pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);
 341
 342 extern int __pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock);
 343
 344 extern int __pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock);
 345
 346 extern int __pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock);
 347
 348 extern int __pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock);
 349
 350 extern int __pthread_rwlock_unlock (pthread_rwlock_t *__rwlock);
 351
 352 extern int __pthread_key_create (pthread_key_t *__key,
 353                                  void (*__destr_function) (void *));
 354
 355 extern int __pthread_setspecific (pthread_key_t __key,
 356                                   const void *__pointer);
 357
 358 extern void *__pthread_getspecific (pthread_key_t __key);
 359
 360 extern int __pthread_once (pthread_once_t *__once_control,
 361                            void (*__init_routine) (void));
 362
 363 extern int __pthread_atfork (void (*__prepare) (void),
 364                              void (*__parent) (void),
 365                              void (*__child) (void));
 366
 367
 368
 369 /* Make the pthread functions weak so that we can elide them from
 370    single-threaded processes.  */
 371 #ifndef __NO_WEAK_PTHREAD_ALIASES
 372 # ifdef weak_extern
 373 weak_extern (__pthread_mutex_init)
 374 weak_extern (__pthread_mutex_destroy)
 375 weak_extern (__pthread_mutex_lock)
 376 weak_extern (__pthread_mutex_trylock)
 377 weak_extern (__pthread_mutex_unlock)
 378 weak_extern (__pthread_mutexattr_init)
 379 weak_extern (__pthread_mutexattr_destroy)
 380 weak_extern (__pthread_mutexattr_settype)
 381 weak_extern (__pthread_rwlock_init)
 382 weak_extern (__pthread_rwlock_destroy)
 383 weak_extern (__pthread_rwlock_rdlock)
 384 weak_extern (__pthread_rwlock_tryrdlock)
 385 weak_extern (__pthread_rwlock_wrlock)
 386 weak_extern (__pthread_rwlock_trywrlock)
 387 weak_extern (__pthread_rwlock_unlock)
 388 weak_extern (__pthread_key_create)
 389 weak_extern (__pthread_setspecific)
 390 weak_extern (__pthread_getspecific)
 391 weak_extern (__pthread_once)
 392 weak_extern (__pthread_initialize)
 393 weak_extern (__pthread_atfork)
 394 weak_extern (_pthread_cleanup_push_defer)
 395 weak_extern (_pthread_cleanup_pop_restore)
 396 weak_extern (pthread_setcancelstate)
 397 # else
 398 #  pragma weak __pthread_mutex_init
 399 #  pragma weak __pthread_mutex_destroy
 400 #  pragma weak __pthread_mutex_lock
 401 #  pragma weak __pthread_mutex_trylock
 402 #  pragma weak __pthread_mutex_unlock
 403 #  pragma weak __pthread_mutexattr_init
 404 #  pragma weak __pthread_mutexattr_destroy
 405 #  pragma weak __pthread_mutexattr_settype
 406 #  pragma weak __pthread_rwlock_destroy
 407 #  pragma weak __pthread_rwlock_rdlock
 408 #  pragma weak __pthread_rwlock_tryrdlock
 409 #  pragma weak __pthread_rwlock_wrlock
 410 #  pragma weak __pthread_rwlock_trywrlock
 411 #  pragma weak __pthread_rwlock_unlock
 412 #  pragma weak __pthread_key_create
 413 #  pragma weak __pthread_setspecific
 414 #  pragma weak __pthread_getspecific
 415 #  pragma weak __pthread_once
 416 #  pragma weak __pthread_initialize
 417 #  pragma weak __pthread_atfork
 418 #  pragma weak _pthread_cleanup_push_defer
 419 #  pragma weak _pthread_cleanup_pop_restore
 420 #  pragma weak pthread_setcancelstate
 421 # endif
 422 #endif
 423
 424 #endif  /* bits/libc-lockP.h */