l4/pkg/uclibc/lib/contrib/uclibc/libc/sysdeps/linux/common/bits/uClibc_mutex.h

   1 /* Copyright (C) 2006   Manuel Novoa III    <mjn3@codepoet.org>
   2  *
   3  * GNU Library General Public License (LGPL) version 2 or later.
   4  *
   5  * Dedicated to Toni.  See uClibc/DEDICATION.mjn3 for details.
   6  */
   7
   8 #ifndef _UCLIBC_MUTEX_H
   9 #define _UCLIBC_MUTEX_H
  10
  11 #include <features.h>
  12
  13 #ifdef __UCLIBC_HAS_THREADS__
  14
  15 #include <pthread.h>
  16 #include <bits/uClibc_pthread.h>
  17
  18 #define __UCLIBC_MUTEX_TYPE                             pthread_mutex_t
  19
  20 #define __UCLIBC_MUTEX(M)                               pthread_mutex_t M
  21 #define __UCLIBC_MUTEX_INIT(M,I)                        pthread_mutex_t M = I
  22 #define __UCLIBC_MUTEX_STATIC(M,I)                      static pthread_mutex_t M = I
  23 #define __UCLIBC_MUTEX_EXTERN(M)                        extern pthread_mutex_t M
  24
  25 #define __UCLIBC_MUTEX_INIT_VAR(M)                                                              \
  26                 ((M) = (pthread_mutex_t) PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
  27
  28 #define __UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE(M)                                                            \
  29                 __pthread_mutex_lock(&(M))
  30
  31 #define __UCLIBC_MUTEX_UNLOCK_CANCEL_UNSAFE(M)                                                          \
  32                 __pthread_mutex_unlock(&(M))
  33
  34 #define __UCLIBC_MUTEX_TRYLOCK_CANCEL_UNSAFE(M)                                                         \
  35                 __pthread_mutex_trylock(&(M))
  36
  37 #define __UCLIBC_MUTEX_CONDITIONAL_LOCK(M,C)                                                            \
  38         do {                                                                                            \
  39                 struct _pthread_cleanup_buffer __infunc_pthread_cleanup_buffer;                         \
  40                 int __infunc_need_locking = (C);                                                        \
  41                 if (__infunc_need_locking) {                                                            \
  42                         _pthread_cleanup_push_defer(&__infunc_pthread_cleanup_buffer,                   \
  43                                            (void (*) (void *))__pthread_mutex_unlock,                   \
  44                                                                                 &(M));                  \
  45                         __pthread_mutex_lock(&(M));                                                     \
  46                 }                                                                                       \
  47                 ((void)0)
  48
  49 #define __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M,C)                                                          \
  50                 if (__infunc_need_locking) {                                                            \
  51                         _pthread_cleanup_pop_restore(&__infunc_pthread_cleanup_buffer,1);               \
  52                 }                                                                                       \
  53         } while (0)
  54
  55 #define __UCLIBC_MUTEX_AUTO_LOCK_VAR(A)         int A
  56
  57 #define __UCLIBC_MUTEX_AUTO_LOCK(M,A,V)                                                                 \
  58         __UCLIBC_MUTEX_CONDITIONAL_LOCK(M,((A=(V)) == 0))
  59
  60 #define __UCLIBC_MUTEX_AUTO_UNLOCK(M,A)                                                                 \
  61         __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M,(A == 0))
  62
  63 #define __UCLIBC_MUTEX_LOCK(M)                                                                          \
  64         __UCLIBC_MUTEX_CONDITIONAL_LOCK(M, 1)
  65
  66 #define __UCLIBC_MUTEX_UNLOCK(M)                                                                        \
  67         __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M, 1)
  68
  69 #ifdef __USE_STDIO_FUTEXES__
  70
  71 #include <bits/stdio-lock.h>
  72
  73 #define __UCLIBC_IO_MUTEX(M)                    _IO_lock_t M
  74 #define __UCLIBC_IO_MUTEX_LOCK(M)               _IO_lock_lock(M)
  75 #define __UCLIBC_IO_MUTEX_UNLOCK(M)     _IO_lock_unlock(M)
  76 #define __UCLIBC_IO_MUTEX_TRYLOCK(M)    _IO_lock_trylock(M)
  77 #define __UCLIBC_IO_MUTEX_INIT(M)       _IO_lock_t M = _IO_lock_initializer
  78 #define __UCLIBC_IO_MUTEX_EXTERN(M)             extern _IO_lock_t M
  79
  80 #define __UCLIBC_IO_MUTEX_CONDITIONAL_LOCK(M,C)         \
  81         if (C) {                                                                                \
  82                 _IO_lock_lock(M);                                                       \
  83         }
  84
  85 #define __UCLIBC_IO_MUTEX_CONDITIONAL_UNLOCK(M,C)       \
  86         if (C) {                                                                                \
  87                 _IO_lock_unlock(M);                                                     \
  88         }
  89
  90 #define __UCLIBC_IO_MUTEX_AUTO_LOCK(M,A,V)                      \
  91                 __UCLIBC_IO_MUTEX_CONDITIONAL_LOCK(M,((A=(V))) == 0)
  92
  93 #define __UCLIBC_IO_MUTEX_AUTO_UNLOCK(M,A)                      \
  94                 __UCLIBC_IO_MUTEX_CONDITIONAL_UNLOCK(M,((A) == 0))
  95
  96 #define __UCLIBC_IO_MUTEX_LOCK_CANCEL_UNSAFE(M)         _IO_lock_lock(M)
  97 #define __UCLIBC_IO_MUTEX_UNLOCK_CANCEL_UNSAFE(M)       _IO_lock_unlock(M)
  98
  99 #else /* of __USE_STDIO_FUTEXES__ */
 100
 101 #define __UCLIBC_IO_MUTEX(M)                        __UCLIBC_MUTEX(M)
 102 #define __UCLIBC_IO_MUTEX_LOCK(M)                   __UCLIBC_MUTEX_CONDITIONAL_LOCK(M, 1)
 103 #define __UCLIBC_IO_MUTEX_UNLOCK(M)                 __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M, 1)
 104 #define __UCLIBC_IO_MUTEX_TRYLOCK(M)                __UCLIBC_MUTEX_TRYLOCK_CANCEL_UNSAFE(M)
 105 #define __UCLIBC_IO_MUTEX_INIT(M)                   __UCLIBC_MUTEX_INIT(M, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
 106 #define __UCLIBC_IO_MUTEX_EXTERN(M)                 __UCLIBC_MUTEX_EXTERN(M)
 107 #define __UCLIBC_IO_MUTEX_AUTO_LOCK(M,A,V)          __UCLIBC_MUTEX_AUTO_LOCK(M,A,V)
 108 #define __UCLIBC_IO_MUTEX_AUTO_UNLOCK(M,A)          __UCLIBC_MUTEX_AUTO_UNLOCK(M,A)
 109 #define __UCLIBC_IO_MUTEX_LOCK_CANCEL_UNSAFE(M)     __UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE(M)
 110 #define __UCLIBC_IO_MUTEX_UNLOCK_CANCEL_UNSAFE(M)   __UCLIBC_MUTEX_UNLOCK_CANCEL_UNSAFE(M)
 111 #define __UCLIBC_IO_MUTEX_CONDITIONAL_LOCK(M,C)     __UCLIBC_MUTEX_CONDITIONAL_LOCK(M, 1)
 112 #define __UCLIBC_IO_MUTEX_CONDITIONAL_UNLOCK(M,C)   __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M, 1)
 113
 114 #endif /* of __USE_STDIO_FUTEXES__ */
 115
 116
 117 #else /* of __UCLIBC_HAS_THREADS__ */
 118
 119 #define __UCLIBC_MUTEX(M)                               void *__UCLIBC_MUTEX_DUMMY_ ## M
 120 #define __UCLIBC_MUTEX_INIT(M,I)                        extern void *__UCLIBC_MUTEX_DUMMY_ ## M
 121 #define __UCLIBC_MUTEX_STATIC(M,I)                      extern void *__UCLIBC_MUTEX_DUMMY_ ## M
 122 #define __UCLIBC_MUTEX_EXTERN(M)                        extern void *__UCLIBC_MUTEX_DUMMY_ ## M
 123
 124 #define __UCLIBC_MUTEX_INIT_VAR(M)                                      ((void)0)
 125 #define __UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE(M)            ((void)0)
 126 #define __UCLIBC_MUTEX_UNLOCK_CANCEL_UNSAFE(M)          ((void)0)
 127 #define __UCLIBC_MUTEX_TRYLOCK_CANCEL_UNSAFE(M)         (0)     /* Always succeed? */
 128
 129 #define __UCLIBC_MUTEX_CONDITIONAL_LOCK(M,C)            ((void)0)
 130 #define __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M,C)          ((void)0)
 131
 132 #define __UCLIBC_MUTEX_AUTO_LOCK_VAR(A)                 ((void)0)
 133 #define __UCLIBC_MUTEX_AUTO_LOCK(M,A,V)                 ((void)0)
 134 #define __UCLIBC_MUTEX_AUTO_UNLOCK(M,A)                 ((void)0)
 135
 136 #define __UCLIBC_MUTEX_LOCK(M)                          ((void)0)
 137 #define __UCLIBC_MUTEX_UNLOCK(M)                        ((void)0)
 138
 139 #define __UCLIBC_IO_MUTEX(M)                        __UCLIBC_MUTEX(M)
 140 #define __UCLIBC_IO_MUTEX_LOCK(M)                   __UCLIBC_MUTEX_CONDITIONAL_LOCK(M, 1)
 141 #define __UCLIBC_IO_MUTEX_UNLOCK(M)                 __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M, 1)
 142 #define __UCLIBC_IO_MUTEX_TRYLOCK(M)                __UCLIBC_MUTEX_TRYLOCK_CANCEL_UNSAFE(M)
 143 #define __UCLIBC_IO_MUTEX_INIT(M)                   __UCLIBC_MUTEX_INIT(M, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
 144 #define __UCLIBC_IO_MUTEX_EXTERN(M)                 __UCLIBC_MUTEX_EXTERN(M)
 145 #define __UCLIBC_IO_MUTEX_AUTO_LOCK(M,A,V)          __UCLIBC_MUTEX_AUTO_LOCK(M,A,V)
 146 #define __UCLIBC_IO_MUTEX_AUTO_UNLOCK(M,A)          __UCLIBC_MUTEX_AUTO_UNLOCK(M,A)
 147 #define __UCLIBC_IO_MUTEX_LOCK_CANCEL_UNSAFE(M)     __UCLIBC_MUTEX_LOCK_CANCEL_UNSAFE(M)
 148 #define __UCLIBC_IO_MUTEX_UNLOCK_CANCEL_UNSAFE(M)   __UCLIBC_MUTEX_UNLOCK_CANCEL_UNSAFE(M)
 149 #define __UCLIBC_IO_MUTEX_CONDITIONAL_LOCK(M,C)     __UCLIBC_MUTEX_CONDITIONAL_LOCK(M, 1)
 150 #define __UCLIBC_IO_MUTEX_CONDITIONAL_UNLOCK(M,C)   __UCLIBC_MUTEX_CONDITIONAL_UNLOCK(M, 1)
 151
 152 #endif /* of __UCLIBC_HAS_THREADS__ */
 153
 154 #define __UCLIBC_IO_MUTEX_TRYLOCK_CANCEL_UNSAFE(M)      \
 155                 __UCLIBC_IO_MUTEX_TRYLOCK(M)
 156
 157 #endif /* _UCLIBC_MUTEX_H */