lib/pthread.in.h

   1 /* Implement a trivial subset of POSIX 1003.1-2008 pthread.h.
   2
   3    Copyright (C) 2009-2013 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program 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
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, see <http://www.gnu.org/licenses/>.  */
  17
  18 /* Written by Paul Eggert and Glen Lenker.  */
  19
  20 #ifndef _@GUARD_PREFIX@_PTHREAD_H_
  21
  22 #if __GNUC__ >= 3
  23 @PRAGMA_SYSTEM_HEADER@
  24 #endif
  25 @PRAGMA_COLUMNS@
  26
  27 /* The include_next requires a split double-inclusion guard.  */
  28 #if @HAVE_PTHREAD_H@
  29 # @INCLUDE_NEXT@ @NEXT_PTHREAD_H@
  30 #endif
  31
  32 #ifndef _@GUARD_PREFIX@_PTHREAD_H_
  33 #define _@GUARD_PREFIX@_PTHREAD_H_
  34
  35 #include <errno.h>
  36 #include <stdlib.h>
  37 #include <sched.h>
  38 #include <sys/types.h>
  39 #include <time.h>
  40
  41 _GL_INLINE_HEADER_BEGIN
  42 #ifndef _GL_PTHREAD_INLINE
  43 # define _GL_PTHREAD_INLINE _GL_INLINE
  44 #endif
  45
  46 #if ! @HAVE_PTHREAD_T@
  47 # if !GNULIB_defined_pthread_types
  48  typedef int pthread_t;
  49  typedef int pthread_attr_t;
  50  typedef int pthread_barrier_t;
  51  typedef int pthread_barrierattr_t;
  52  typedef int pthread_cond_t;
  53  typedef int pthread_condattr_t;
  54  typedef int pthread_key_t;
  55  typedef int pthread_mutex_t;
  56  typedef int pthread_mutexattr_t;
  57  typedef int pthread_once_t;
  58  typedef int pthread_rwlock_t;
  59  typedef int pthread_rwlockattr_t;
  60 #  define GNULIB_defined_pthread_types 1
  61 # endif
  62 #endif
  63
  64 #ifndef PTHREAD_COND_INITIALIZER
  65 #define PTHREAD_COND_INITIALIZER { 0 }
  66 #define PTHREAD_MUTEX_INITIALIZER { 0 }
  67 #define PTHREAD_ONCE_INIT { 0 }
  68 #define PTHREAD_RWLOCK_INITIALIZER { 0 }
  69
  70 #define PTHREAD_BARRIER_SERIAL_THREAD (-1)
  71
  72 #define PTHREAD_CANCEL_DEFERRED 0
  73 #define PTHREAD_CANCEL_ASYNCHRONOUS 1
  74
  75 #define PTHREAD_CANCEL_ENABLE 0
  76 #define PTHREAD_CANCEL_DISABLE 1
  77
  78 #define PTHREAD_CANCELED ((void *) -1)
  79
  80 #define PTHREAD_CREATE_JOINABLE 0
  81 #define PTHREAD_CREATE_DETACHED 1
  82
  83 #define PTHREAD_INHERIT_SCHED 0
  84 #define PTHREAD_EXPLICIT_SCHED 1
  85
  86 #define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
  87 #define PTHREAD_MUTEX_NORMAL 0
  88 #define PTHREAD_MUTEX_ERRORCHECK 1
  89 #define PTHREAD_MUTEX_RECURSIVE 2
  90
  91 #define PTHREAD_MUTEX_STALLED 0
  92 #define PTHREAD_MUTEX_ROBUST 1
  93
  94 #define PTHREAD_PRIO_NONE 0
  95 #define PTHREAD_PRIO_INHERIT 1
  96 #define PTHREAD_PRIO_PROTECT 2
  97
  98 #define PTHREAD_PROCESS_PRIVATE 0
  99 #define PTHREAD_PROCESS_SHARED 1
 100
 101 #define PTHREAD_SCOPE_SYSTEM 0
 102 #define PTHREAD_SCOPE_PROCESS 1
 103 #endif
 104
 105 #if ! @HAVE_PTHREAD_T@
 106
 107 # if !GNULIB_defined_pthread_functions
 108
 109 /* Provide substitutes for the thread functions that should work
 110    adequately on a single-threaded implementation, where
 111    pthread_create always fails.  The goal is to let programs compile
 112    on non-pthread hosts with minimal runtime overhead.
 113
 114    Omit interfaces that have not been analyzed and for which we do not
 115    know what to do, so that they elicit a compile-time error for
 116    now.  */
 117
 118 _GL_PTHREAD_INLINE int
 119 pthread_cond_destroy (pthread_cond_t *cond)
 120 {
 121   /* COND is never seriously used.  */
 122   return 0;
 123 }
 124
 125 _GL_PTHREAD_INLINE int
 126 pthread_cond_init (pthread_cond_t *restrict cond,
 127                    pthread_condattr_t const *restrict attr)
 128 {
 129   /* COND is never seriously used.  */
 130   return 0;
 131 }
 132
 133 _GL_PTHREAD_INLINE int
 134 pthread_cond_signal (pthread_cond_t *cond)
 135 {
 136   /* No threads can currently be blocked on COND.  */
 137   return 0;
 138 }
 139
 140 _GL_PTHREAD_INLINE int
 141 pthread_cond_wait (pthread_cond_t *restrict cond,
 142                    pthread_mutex_t *restrict mutex)
 143 {
 144   /* Properly-written applications never come here.  */
 145   abort ();
 146   return 0;
 147 }
 148
 149 _GL_PTHREAD_INLINE int
 150 pthread_create (pthread_t *restrict thread,
 151                 pthread_attr_t const *restrict attr,
 152                 void * (*start_routine) (void*), void *restrict arg)
 153 {
 154   /* Do not create a thread.  */
 155   return EAGAIN;
 156 }
 157
 158 _GL_PTHREAD_INLINE void
 159 pthread_exit (void *value)
 160 {
 161   /* There is just one thread, so the process exits.  */
 162   exit (0);
 163 }
 164
 165 _GL_PTHREAD_INLINE int
 166 pthread_join (pthread_t thread, void **pvalue)
 167 {
 168   /* Properly-written applications never come here.  */
 169   abort ();
 170   return 0;
 171 }
 172
 173 _GL_PTHREAD_INLINE int
 174 pthread_mutexattr_destroy (pthread_mutexattr_t *attr)
 175 {
 176   return 0;
 177 }
 178
 179 _GL_PTHREAD_INLINE int
 180 pthread_mutexattr_init (pthread_mutexattr_t *attr)
 181 {
 182   return 0;
 183 }
 184
 185 _GL_PTHREAD_INLINE int
 186 pthread_mutexattr_settype (pthread_mutexattr_t *attr, int attr_type)
 187 {
 188   return 0;
 189 }
 190
 191 _GL_PTHREAD_INLINE int
 192 pthread_mutex_destroy (pthread_mutex_t *mutex)
 193 {
 194   /* MUTEX is never seriously used.  */
 195   return 0;
 196 }
 197
 198 _GL_PTHREAD_INLINE int
 199 pthread_mutex_init (pthread_mutex_t *restrict mutex,
 200                     pthread_mutexattr_t const *restrict attr)
 201 {
 202   /* MUTEX is never seriously used.  */
 203   return 0;
 204 }
 205
 206 _GL_PTHREAD_INLINE int
 207 pthread_mutex_lock (pthread_mutex_t *mutex)
 208 {
 209   /* There is only one thread, so it always gets the lock.  This
 210      implementation does not support PTHREAD_MUTEX_ERRORCHECK.  */
 211   return 0;
 212 }
 213
 214 _GL_PTHREAD_INLINE int
 215 pthread_mutex_trylock (pthread_mutex_t *mutex)
 216 {
 217   return pthread_mutex_lock (mutex);
 218 }
 219
 220 _GL_PTHREAD_INLINE int
 221 pthread_mutex_unlock (pthread_mutex_t *mutex)
 222 {
 223   /* There is only one thread, so it always unlocks successfully.
 224      This implementation does not support robust mutexes or
 225      PTHREAD_MUTEX_ERRORCHECK.  */
 226   return 0;
 227 }
 228
 229 #  define GNULIB_defined_pthread_functions 1
 230 # endif
 231
 232 #endif
 233
 234 #if ! @HAVE_PTHREAD_SPINLOCK_T@
 235
 236 # if !GNULIB_defined_pthread_spinlock_t
 237
 238 /* Approximate spinlocks with mutexes.  */
 239
 240 typedef pthread_mutex_t pthread_spinlock_t;
 241
 242 _GL_PTHREAD_INLINE int
 243 pthread_spin_init (pthread_spinlock_t *lock, int pshared)
 244 {
 245   return pthread_mutex_init (lock, NULL);
 246 }
 247
 248 _GL_PTHREAD_INLINE int
 249 pthread_spin_destroy (pthread_spinlock_t *lock)
 250 {
 251   return pthread_mutex_destroy (lock);
 252 }
 253
 254 _GL_PTHREAD_INLINE int
 255 pthread_spin_lock (pthread_spinlock_t *lock)
 256 {
 257   return pthread_mutex_lock (lock);
 258 }
 259
 260 _GL_PTHREAD_INLINE int
 261 pthread_spin_trylock (pthread_spinlock_t *lock)
 262 {
 263   return pthread_mutex_trylock (lock);
 264 }
 265
 266 _GL_PTHREAD_INLINE int
 267 pthread_spin_unlock (pthread_spinlock_t *lock)
 268 {
 269   return pthread_mutex_unlock (lock);
 270 }
 271
 272 #  define GNULIB_defined_pthread_spinlock_t 1
 273 # endif
 274
 275 #endif
 276
 277 _GL_INLINE_HEADER_END
 278
 279 #endif /* _@GUARD_PREFIX@_PTHREAD_H_ */
 280 #endif /* _@GUARD_PREFIX@_PTHREAD_H_ */