headers/posix/pthread.h

   1 /*
   2  * Copyright 2001-2011 Haiku, Inc. All Rights Reserved.
   3  * Distributed under the terms of the Haiku License.
   4  */
   5 #ifndef _PTHREAD_H_
   6 #define _PTHREAD_H_
   7
   8
   9 #include <sched.h>
  10 #include <stdint.h>
  11 #include <sys/types.h>
  12 #include <time.h>
  13
  14
  15 #define PTHREAD_MUTEX_DEFAULT           0
  16 #define PTHREAD_MUTEX_NORMAL            1
  17 #define PTHREAD_MUTEX_ERRORCHECK        2
  18 #define PTHREAD_MUTEX_RECURSIVE         3
  19
  20 #define PTHREAD_PROCESS_PRIVATE         0
  21 #define PTHREAD_PROCESS_SHARED          1
  22
  23 /*
  24  * Flags for threads and thread attributes.
  25  */
  26 #define PTHREAD_DETACHED                        0x1
  27 #define PTHREAD_SCOPE_SYSTEM            0x2
  28 #define PTHREAD_INHERIT_SCHED           0x4
  29 #define PTHREAD_NOFLOAT                         0x8
  30
  31 #define PTHREAD_CREATE_DETACHED         PTHREAD_DETACHED
  32 #define PTHREAD_CREATE_JOINABLE         0
  33 #define PTHREAD_SCOPE_PROCESS           0
  34 #define PTHREAD_EXPLICIT_SCHED          0
  35
  36 /*
  37  * Flags for cancelling threads
  38  */
  39 #define PTHREAD_CANCEL_ENABLE           0
  40 #define PTHREAD_CANCEL_DISABLE          1
  41 #define PTHREAD_CANCEL_DEFERRED         0
  42 #define PTHREAD_CANCEL_ASYNCHRONOUS     2
  43 #define PTHREAD_CANCELED                        ((void *) 1)
  44
  45 #define PTHREAD_ONCE_INIT                       { -1 }
  46
  47 #define PTHREAD_BARRIER_SERIAL_THREAD -1
  48 #define PTHREAD_PRIO_NONE                       0
  49 #define PTHREAD_PRIO_INHERIT            1
  50 #define PTHREAD_PRIO_PROTECT            2
  51
  52 /* private structure */
  53 struct __pthread_cleanup_handler {
  54         struct __pthread_cleanup_handler *previous;
  55         void    (*function)(void *argument);
  56         void    *argument;
  57 };
  58
  59 #define pthread_cleanup_push(func, arg) \
  60         do { \
  61                 struct __pthread_cleanup_handler __handler; \
  62                 __handler.function = (func); \
  63                 __handler.argument = (arg); \
  64                 __pthread_cleanup_push_handler(&__handler);
  65
  66 #define pthread_cleanup_pop(execute) \
  67                 if (execute) \
  68                         __handler.function(__handler.argument); \
  69                 __pthread_cleanup_pop_handler(); \
  70         } while (0)
  71
  72
  73 #ifdef __cplusplus
  74 extern "C" {
  75 #endif
  76
  77 #define PTHREAD_MUTEX_INITIALIZER \
  78         { PTHREAD_MUTEX_DEFAULT, 0, -42, -1, 0 }
  79 #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER \
  80         { PTHREAD_MUTEX_RECURSIVE, 0, -42, -1, 0 }
  81 #define PTHREAD_COND_INITIALIZER        \
  82         { 0, -42, NULL, 0, 0 }
  83 #define PTHREAD_RWLOCK_INITIALIZER      \
  84         { 0, -1, {{0}} }
  85
  86 /* mutex functions */
  87 extern int pthread_mutex_destroy(pthread_mutex_t *mutex);
  88 extern int pthread_mutex_getprioceiling(const pthread_mutex_t *mutex,
  89         int *_priorityCeiling);
  90 extern int pthread_mutex_init(pthread_mutex_t *mutex,
  91         const pthread_mutexattr_t *attr);
  92 extern int pthread_mutex_lock(pthread_mutex_t *mutex);
  93 extern int pthread_mutex_setprioceiling(pthread_mutex_t *mutex,
  94         int newPriorityCeiling, int *_oldPriorityCeiling);
  95 extern int pthread_mutex_timedlock(pthread_mutex_t *mutex,
  96         const struct timespec *spec);
  97 extern int pthread_mutex_trylock(pthread_mutex_t *mutex);
  98 extern int pthread_mutex_unlock(pthread_mutex_t *mutex);
  99
 100 /* mutex attribute functions */
 101 extern int pthread_mutexattr_destroy(pthread_mutexattr_t *mutexAttr);
 102 extern int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *mutexAttr,
 103         int *_priorityCeiling);
 104 extern int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *mutexAttr,
 105         int *_protocol);
 106 extern int pthread_mutexattr_getpshared(const pthread_mutexattr_t *mutexAttr,
 107         int *_processShared);
 108 extern int pthread_mutexattr_gettype(const pthread_mutexattr_t *mutexAttr,
 109         int *_type);
 110 extern int pthread_mutexattr_init(pthread_mutexattr_t *mutexAttr);
 111 extern int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *mutexAttr,
 112         int priorityCeiling);
 113 extern int pthread_mutexattr_setprotocol(pthread_mutexattr_t *mutexAttr,
 114         int protocol);
 115 extern int pthread_mutexattr_setpshared(pthread_mutexattr_t *mutexAttr,
 116         int processShared);
 117 extern int pthread_mutexattr_settype(pthread_mutexattr_t *mutexAttr, int type);
 118
 119 /* barrier functions */
 120 extern int pthread_barrier_init(pthread_barrier_t *barrier,
 121         const pthread_barrierattr_t *attr, unsigned count);
 122 extern int pthread_barrier_destroy(pthread_barrier_t *barrier);
 123 extern int pthread_barrier_wait(pthread_barrier_t *barrier);
 124
 125 /* barrier attribute functions */
 126 extern int pthread_barrierattr_destroy(pthread_barrierattr_t *attr);
 127 extern int pthread_barrierattr_getpshared(const pthread_barrierattr_t *attr,
 128         int *shared);
 129 extern int pthread_barrierattr_init(pthread_barrierattr_t *attr);
 130 extern int pthread_barrierattr_setpshared(pthread_barrierattr_t *attr,
 131         int shared);
 132
 133 /* condition variable functions */
 134 extern int pthread_cond_destroy(pthread_cond_t *cond);
 135 extern int pthread_cond_init(pthread_cond_t *cond,
 136         const pthread_condattr_t *attr);
 137 extern int pthread_cond_broadcast(pthread_cond_t *cond);
 138 extern int pthread_cond_signal(pthread_cond_t *cond);
 139 extern int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
 140         const struct timespec *abstime);
 141 extern int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
 142
 143 /* condition variable attribute functions */
 144 extern int pthread_condattr_destroy(pthread_condattr_t *condAttr);
 145 extern int pthread_condattr_init(pthread_condattr_t *condAttr);
 146 extern int pthread_condattr_getpshared(const pthread_condattr_t *condAttr,
 147         int *processShared);
 148 extern int pthread_condattr_setpshared(pthread_condattr_t *condAttr,
 149         int processShared);
 150 extern int pthread_condattr_getclock(const pthread_condattr_t *condAttr,
 151         clockid_t *clockID);
 152 extern int pthread_condattr_setclock(pthread_condattr_t *condAttr,
 153         clockid_t clockID);
 154
 155 /* rwlock functions */
 156 extern int pthread_rwlock_init(pthread_rwlock_t *lock,
 157         const pthread_rwlockattr_t *attr);
 158 extern int pthread_rwlock_destroy(pthread_rwlock_t *lock);
 159 extern int pthread_rwlock_rdlock(pthread_rwlock_t *lock);
 160 extern int pthread_rwlock_tryrdlock(pthread_rwlock_t *lock);
 161 extern int pthread_rwlock_timedrdlock(pthread_rwlock_t *lock,
 162         const struct timespec *timeout);
 163 extern int pthread_rwlock_wrlock(pthread_rwlock_t *lock);
 164 extern int pthread_rwlock_trywrlock(pthread_rwlock_t *lock);
 165 extern int pthread_rwlock_timedwrlock(pthread_rwlock_t *lock,
 166         const struct timespec *timeout);
 167 extern int pthread_rwlock_unlock(pthread_rwlock_t *lock);
 168
 169 /* rwlock attribute functions */
 170 extern int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
 171 extern int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);
 172 extern int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *attr,
 173         int *shared);
 174 extern int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *attr,
 175         int shared);
 176
 177 /* spinlock functions */
 178 extern int pthread_spin_init(pthread_spinlock_t* spinlock, int pshared);
 179 extern int pthread_spin_destroy(pthread_spinlock_t* spinlock);
 180 extern int pthread_spin_lock(pthread_spinlock_t* spinlock);
 181 extern int pthread_spin_trylock(pthread_spinlock_t* spinlock);
 182 extern int pthread_spin_unlock(pthread_spinlock_t* spinlock);
 183
 184 /* misc. functions */
 185 extern int pthread_atfork(void (*prepare)(void), void (*parent)(void),
 186         void (*child)(void));
 187 extern int pthread_once(pthread_once_t *once_control,
 188         void (*init_routine)(void));
 189
 190 /* thread attributes functions */
 191 extern int pthread_attr_destroy(pthread_attr_t *attr);
 192 extern int pthread_attr_init(pthread_attr_t *attr);
 193 extern int pthread_attr_getdetachstate(const pthread_attr_t *attr,
 194         int *detachstate);
 195 extern int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
 196 extern int pthread_attr_getstacksize(const pthread_attr_t *attr,
 197         size_t *stacksize);
 198 extern int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
 199 extern int pthread_attr_getscope(const pthread_attr_t *attr,
 200         int *contentionScope);
 201 extern int pthread_attr_setscope(pthread_attr_t *attr, int contentionScope);
 202
 203 extern int pthread_attr_getschedparam(const pthread_attr_t *attr,
 204         struct sched_param *param);
 205 extern int pthread_attr_setschedparam(pthread_attr_t *attr,
 206         const struct sched_param *param);
 207
 208 extern int pthread_attr_getguardsize(const pthread_attr_t *attr,
 209         size_t *guardsize);
 210 extern int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);
 211
 212 #if 0   /* Unimplemented attribute functions: */
 213
 214 /* [TPS] */
 215 extern int pthread_attr_getinheritsched(const pthread_attr_t *attr,
 216         int *inheritsched);
 217 extern int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched);
 218
 219 extern int pthread_attr_getschedpolicy(const pthread_attr_t *attr,
 220         int *policy);
 221 extern int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);
 222
 223 /* [TSA] */
 224 extern int pthread_attr_getstackaddr(const pthread_attr_t *attr,
 225         void **stackaddr);
 226 extern int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr);
 227
 228 /* [TSA TSS] */
 229 extern int pthread_attr_getstack(const pthread_attr_t *attr,
 230         void **stackaddr, size_t *stacksize);
 231 extern int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize);
 232
 233 #endif  /* 0 */
 234
 235
 236 /* thread functions */
 237 extern int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
 238         void *(*start_routine)(void*), void *arg);
 239 extern int pthread_detach(pthread_t thread);
 240 extern int pthread_equal(pthread_t t1, pthread_t t2);
 241 extern void pthread_exit(void *value_ptr);
 242 extern int pthread_join(pthread_t thread, void **_value);
 243 extern pthread_t pthread_self(void);
 244 extern int pthread_getconcurrency(void);
 245 extern int pthread_setconcurrency(int newLevel);
 246
 247 extern int pthread_cancel(pthread_t thread);
 248 extern int pthread_setcancelstate(int state, int *_oldState);
 249 extern int pthread_setcanceltype(int type, int *_oldType);
 250 extern void pthread_testcancel(void);
 251
 252 extern int pthread_getschedparam(pthread_t thread, int *policy,
 253         struct sched_param *param);
 254 extern int pthread_setschedparam(pthread_t thread, int policy,
 255         const struct sched_param *param);
 256
 257 /* thread specific data functions */
 258 extern int pthread_key_create(pthread_key_t *key,
 259         void (*destructorFunc)(void*));
 260 extern int pthread_key_delete(pthread_key_t key);
 261 extern void *pthread_getspecific(pthread_key_t key);
 262 extern int pthread_setspecific(pthread_key_t key, const void *value);
 263
 264 /* private functions */
 265 extern void __pthread_cleanup_push_handler(
 266         struct __pthread_cleanup_handler *handler);
 267 extern struct __pthread_cleanup_handler *__pthread_cleanup_pop_handler(void);
 268
 269 #ifdef __cplusplus
 270 }
 271 #endif
 272
 273 #endif  /* _PTHREAD_ */