1062c5bc4SJason Schmidlapp /* This is an implementation of the threads API of POSIX 1003.1-2001. 2062c5bc4SJason Schmidlapp * 3062c5bc4SJason Schmidlapp * -------------------------------------------------------------------------- 4062c5bc4SJason Schmidlapp * 5062c5bc4SJason Schmidlapp * Pthreads-embedded (PTE) - POSIX Threads Library for embedded systems 6062c5bc4SJason Schmidlapp * Copyright(C) 2008 Jason Schmidlapp 7062c5bc4SJason Schmidlapp * 8062c5bc4SJason Schmidlapp * Contact Email: jschmidlapp@users.sourceforge.net 9062c5bc4SJason Schmidlapp * 10062c5bc4SJason Schmidlapp * 11062c5bc4SJason Schmidlapp * Pthreads-embedded (PTE) - POSIX Threads Library for embedded systems 12062c5bc4SJason Schmidlapp * Copyright(C) 2008 Jason Schmidlapp 13062c5bc4SJason Schmidlapp * 14062c5bc4SJason Schmidlapp * Contact Email: jschmidlapp@users.sourceforge.net 15062c5bc4SJason Schmidlapp * 16062c5bc4SJason Schmidlapp * 17062c5bc4SJason Schmidlapp * Based upon Pthreads-win32 - POSIX Threads Library for Win32 18062c5bc4SJason Schmidlapp * Copyright(C) 1998 John E. Bossom 19062c5bc4SJason Schmidlapp * Copyright(C) 1999,2005 Pthreads-win32 contributors 20062c5bc4SJason Schmidlapp * 21062c5bc4SJason Schmidlapp * Contact Email: rpj@callisto.canberra.edu.au 22062c5bc4SJason Schmidlapp * 23062c5bc4SJason Schmidlapp * The original list of contributors to the Pthreads-win32 project 24062c5bc4SJason Schmidlapp * is contained in the file CONTRIBUTORS.ptw32 included with the 25062c5bc4SJason Schmidlapp * source code distribution. The list can also be seen at the 26062c5bc4SJason Schmidlapp * following World Wide Web location: 27062c5bc4SJason Schmidlapp * http://sources.redhat.com/pthreads-win32/contributors.html 28062c5bc4SJason Schmidlapp * 29062c5bc4SJason Schmidlapp * This library is free software; you can redistribute it and/or 30062c5bc4SJason Schmidlapp * modify it under the terms of the GNU Lesser General Public 31062c5bc4SJason Schmidlapp * License as published by the Free Software Foundation; either 32062c5bc4SJason Schmidlapp * version 2 of the License, or (at your option) any later version. 33062c5bc4SJason Schmidlapp * 34062c5bc4SJason Schmidlapp * This library is distributed in the hope that it will be useful, 35062c5bc4SJason Schmidlapp * but WITHOUT ANY WARRANTY; without even the implied warranty of 36062c5bc4SJason Schmidlapp * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 37062c5bc4SJason Schmidlapp * Lesser General Public License for more details. 38062c5bc4SJason Schmidlapp * 39062c5bc4SJason Schmidlapp * You should have received a copy of the GNU Lesser General Public 40062c5bc4SJason Schmidlapp * License along with this library in the file COPYING.LIB; 41062c5bc4SJason Schmidlapp * if not, write to the Free Software Foundation, Inc., 42062c5bc4SJason Schmidlapp * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA 43062c5bc4SJason Schmidlapp */ 44062c5bc4SJason Schmidlapp #if !defined( PTHREAD_H ) 45062c5bc4SJason Schmidlapp #define PTHREAD_H 46062c5bc4SJason Schmidlapp 47714af18cSJason Schmidlapp #include <pte_types.h> 48062c5bc4SJason Schmidlapp 49062c5bc4SJason Schmidlapp #include <sched.h> 50062c5bc4SJason Schmidlapp 51062c5bc4SJason Schmidlapp #define PTE_VERSION 2,8,0,0 52062c5bc4SJason Schmidlapp #define PTE_VERSION_STRING "2, 8, 0, 0\0" 53062c5bc4SJason Schmidlapp 54062c5bc4SJason Schmidlapp /* There are two implementations of cancel cleanup. 55062c5bc4SJason Schmidlapp * Note that pthread.h is included in both application 56062c5bc4SJason Schmidlapp * compilation units and also internally for the library. 57062c5bc4SJason Schmidlapp * The code here and within the library aims to work 58062c5bc4SJason Schmidlapp * for all reasonable combinations of environments. 59062c5bc4SJason Schmidlapp * 60062c5bc4SJason Schmidlapp * The two implementations are: 61062c5bc4SJason Schmidlapp * 62062c5bc4SJason Schmidlapp * C 63062c5bc4SJason Schmidlapp * C++ 64062c5bc4SJason Schmidlapp * 65062c5bc4SJason Schmidlapp */ 66062c5bc4SJason Schmidlapp 67062c5bc4SJason Schmidlapp /* 68062c5bc4SJason Schmidlapp * Define defaults for cleanup code. 69062c5bc4SJason Schmidlapp * Note: Unless the build explicitly defines one of the following, then 70062c5bc4SJason Schmidlapp * we default to standard C style cleanup. This style uses setjmp/longjmp 71062c5bc4SJason Schmidlapp * in the cancelation and thread exit implementations and therefore won't 72062c5bc4SJason Schmidlapp * do stack unwinding if linked to applications that have it (e.g. 73062c5bc4SJason Schmidlapp * C++ apps). This is currently consistent with most/all commercial Unix 74062c5bc4SJason Schmidlapp * POSIX threads implementations. 75062c5bc4SJason Schmidlapp */ 76062c5bc4SJason Schmidlapp #if !defined( PTE_CLEANUP_CXX ) && !defined( PTE_CLEANUP_C ) 77062c5bc4SJason Schmidlapp # define PTE_CLEANUP_C 78062c5bc4SJason Schmidlapp #endif 79062c5bc4SJason Schmidlapp 80062c5bc4SJason Schmidlapp #undef PTE_LEVEL 81062c5bc4SJason Schmidlapp 82062c5bc4SJason Schmidlapp #if defined(_POSIX_SOURCE) 83062c5bc4SJason Schmidlapp #define PTE_LEVEL 0 84062c5bc4SJason Schmidlapp /* Early POSIX */ 85062c5bc4SJason Schmidlapp #endif 86062c5bc4SJason Schmidlapp 87062c5bc4SJason Schmidlapp #if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309 88062c5bc4SJason Schmidlapp #undef PTE_LEVEL 89062c5bc4SJason Schmidlapp #define PTE_LEVEL 1 90062c5bc4SJason Schmidlapp /* Include 1b, 1c and 1d */ 91062c5bc4SJason Schmidlapp #endif 92062c5bc4SJason Schmidlapp 93062c5bc4SJason Schmidlapp #if defined(INCLUDE_NP) 94062c5bc4SJason Schmidlapp #undef PTE_LEVEL 95062c5bc4SJason Schmidlapp #define PTE_LEVEL 2 96062c5bc4SJason Schmidlapp /* Include Non-Portable extensions */ 97062c5bc4SJason Schmidlapp #endif 98062c5bc4SJason Schmidlapp 99062c5bc4SJason Schmidlapp #define PTE_LEVEL_MAX 3 100062c5bc4SJason Schmidlapp 101062c5bc4SJason Schmidlapp #if !defined(PTE_LEVEL) 102062c5bc4SJason Schmidlapp #define PTE_LEVEL PTE_LEVEL_MAX 103062c5bc4SJason Schmidlapp /* Include everything */ 104062c5bc4SJason Schmidlapp #endif 105062c5bc4SJason Schmidlapp 106062c5bc4SJason Schmidlapp /* 107062c5bc4SJason Schmidlapp * ------------------------------------------------------------- 108062c5bc4SJason Schmidlapp * 109062c5bc4SJason Schmidlapp * 110062c5bc4SJason Schmidlapp * Module: pthread.h 111062c5bc4SJason Schmidlapp * 112062c5bc4SJason Schmidlapp * Purpose: 113062c5bc4SJason Schmidlapp * Provides an implementation of PThreads based upon the 114062c5bc4SJason Schmidlapp * standard: 115062c5bc4SJason Schmidlapp * 116062c5bc4SJason Schmidlapp * POSIX 1003.1-2001 117062c5bc4SJason Schmidlapp * and 118062c5bc4SJason Schmidlapp * The Single Unix Specification version 3 119062c5bc4SJason Schmidlapp * 120062c5bc4SJason Schmidlapp * (these two are equivalent) 121062c5bc4SJason Schmidlapp * 122062c5bc4SJason Schmidlapp * in order to enhance code portability between Windows, 123062c5bc4SJason Schmidlapp * various commercial Unix implementations, and Linux. 124062c5bc4SJason Schmidlapp * 125062c5bc4SJason Schmidlapp * See the ANNOUNCE file for a full list of conforming 126062c5bc4SJason Schmidlapp * routines and defined constants, and a list of missing 127062c5bc4SJason Schmidlapp * routines and constants not defined in this implementation. 128062c5bc4SJason Schmidlapp * 129062c5bc4SJason Schmidlapp * Authors: 130062c5bc4SJason Schmidlapp * There have been many contributors to this library. 131062c5bc4SJason Schmidlapp * The initial implementation was contributed by 132062c5bc4SJason Schmidlapp * John Bossom, and several others have provided major 133062c5bc4SJason Schmidlapp * sections or revisions of parts of the implementation. 134062c5bc4SJason Schmidlapp * Often significant effort has been contributed to 135062c5bc4SJason Schmidlapp * find and fix important bugs and other problems to 136062c5bc4SJason Schmidlapp * improve the reliability of the library, which sometimes 137062c5bc4SJason Schmidlapp * is not reflected in the amount of code which changed as 138062c5bc4SJason Schmidlapp * result. 139062c5bc4SJason Schmidlapp * As much as possible, the contributors are acknowledged 140062c5bc4SJason Schmidlapp * in the ChangeLog file in the source code distribution 141062c5bc4SJason Schmidlapp * where their changes are noted in detail. 142062c5bc4SJason Schmidlapp * 143062c5bc4SJason Schmidlapp * Contributors are listed in the CONTRIBUTORS file. 144062c5bc4SJason Schmidlapp * 145062c5bc4SJason Schmidlapp * As usual, all bouquets go to the contributors, and all 146062c5bc4SJason Schmidlapp * brickbats go to the project maintainer. 147062c5bc4SJason Schmidlapp * 148062c5bc4SJason Schmidlapp * Maintainer: 149062c5bc4SJason Schmidlapp * The code base for this project is coordinated and 150062c5bc4SJason Schmidlapp * eventually pre-tested, packaged, and made available by 151062c5bc4SJason Schmidlapp * 152062c5bc4SJason Schmidlapp * Ross Johnson <rpj@callisto.canberra.edu.au> 153062c5bc4SJason Schmidlapp * 154062c5bc4SJason Schmidlapp * QA Testers: 155062c5bc4SJason Schmidlapp * Ultimately, the library is tested in the real world by 156062c5bc4SJason Schmidlapp * a host of competent and demanding scientists and 157062c5bc4SJason Schmidlapp * engineers who report bugs and/or provide solutions 158062c5bc4SJason Schmidlapp * which are then fixed or incorporated into subsequent 159062c5bc4SJason Schmidlapp * versions of the library. Each time a bug is fixed, a 160062c5bc4SJason Schmidlapp * test case is written to prove the fix and ensure 161062c5bc4SJason Schmidlapp * that later changes to the code don't reintroduce the 162062c5bc4SJason Schmidlapp * same error. The number of test cases is slowly growing 163062c5bc4SJason Schmidlapp * and therefore so is the code reliability. 164062c5bc4SJason Schmidlapp * 165062c5bc4SJason Schmidlapp * Compliance: 166062c5bc4SJason Schmidlapp * See the file ANNOUNCE for the list of implemented 167062c5bc4SJason Schmidlapp * and not-implemented routines and defined options. 168062c5bc4SJason Schmidlapp * Of course, these are all defined is this file as well. 169062c5bc4SJason Schmidlapp * 170062c5bc4SJason Schmidlapp * Web site: 171062c5bc4SJason Schmidlapp * The source code and other information about this library 172062c5bc4SJason Schmidlapp * are available from 173062c5bc4SJason Schmidlapp * 174062c5bc4SJason Schmidlapp * http://sources.redhat.com/pthreads-win32/ 175062c5bc4SJason Schmidlapp * 176062c5bc4SJason Schmidlapp * ------------------------------------------------------------- 177062c5bc4SJason Schmidlapp */ 178062c5bc4SJason Schmidlapp 179062c5bc4SJason Schmidlapp #include <time.h> 180062c5bc4SJason Schmidlapp 181062c5bc4SJason Schmidlapp #include <setjmp.h> 182062c5bc4SJason Schmidlapp #include <limits.h> 183062c5bc4SJason Schmidlapp 184062c5bc4SJason Schmidlapp /* 185062c5bc4SJason Schmidlapp * Boolean values to make us independent of system includes. 186062c5bc4SJason Schmidlapp */ 187062c5bc4SJason Schmidlapp enum 188062c5bc4SJason Schmidlapp { 189062c5bc4SJason Schmidlapp PTE_FALSE = 0, 190062c5bc4SJason Schmidlapp PTE_TRUE = (! PTE_FALSE) 191062c5bc4SJason Schmidlapp }; 192062c5bc4SJason Schmidlapp 193062c5bc4SJason Schmidlapp 194062c5bc4SJason Schmidlapp /* 195062c5bc4SJason Schmidlapp * ------------------------------------------------------------- 196062c5bc4SJason Schmidlapp * 197062c5bc4SJason Schmidlapp * POSIX 1003.1-2001 Options 198062c5bc4SJason Schmidlapp * ========================= 199062c5bc4SJason Schmidlapp * 200062c5bc4SJason Schmidlapp * Options are normally set in <unistd.h>, which is not provided 201062c5bc4SJason Schmidlapp * with pthreads-embedded. 202062c5bc4SJason Schmidlapp * 203062c5bc4SJason Schmidlapp * For conformance with the Single Unix Specification (version 3), all of the 204062c5bc4SJason Schmidlapp * options below are defined, and have a value of either -1 (not supported) 205062c5bc4SJason Schmidlapp * or 200112L (supported). 206062c5bc4SJason Schmidlapp * 207062c5bc4SJason Schmidlapp * These options can neither be left undefined nor have a value of 0, because 208062c5bc4SJason Schmidlapp * either indicates that sysconf(), which is not implemented, may be used at 209062c5bc4SJason Schmidlapp * runtime to check the status of the option. 210062c5bc4SJason Schmidlapp * 211062c5bc4SJason Schmidlapp * _POSIX_THREADS (== 200112L) 212062c5bc4SJason Schmidlapp * If == 200112L, you can use threads 213062c5bc4SJason Schmidlapp * 214062c5bc4SJason Schmidlapp * _POSIX_THREAD_ATTR_STACKSIZE (== 200112L) 215062c5bc4SJason Schmidlapp * If == 200112L, you can control the size of a thread's 216062c5bc4SJason Schmidlapp * stack 217062c5bc4SJason Schmidlapp * pthread_attr_getstacksize 218062c5bc4SJason Schmidlapp * pthread_attr_setstacksize 219062c5bc4SJason Schmidlapp * 220062c5bc4SJason Schmidlapp * _POSIX_THREAD_ATTR_STACKADDR (== -1) 221062c5bc4SJason Schmidlapp * If == 200112L, you can allocate and control a thread's 222062c5bc4SJason Schmidlapp * stack. If not supported, the following functions 223062c5bc4SJason Schmidlapp * will return ENOSYS, indicating they are not 224062c5bc4SJason Schmidlapp * supported: 225062c5bc4SJason Schmidlapp * pthread_attr_getstackaddr 226062c5bc4SJason Schmidlapp * pthread_attr_setstackaddr 227062c5bc4SJason Schmidlapp * 228062c5bc4SJason Schmidlapp * _POSIX_THREAD_PRIORITY_SCHEDULING (== -1) 229062c5bc4SJason Schmidlapp * If == 200112L, you can use realtime scheduling. 230062c5bc4SJason Schmidlapp * This option indicates that the behaviour of some 231062c5bc4SJason Schmidlapp * implemented functions conforms to the additional TPS 232062c5bc4SJason Schmidlapp * requirements in the standard. E.g. rwlocks favour 233062c5bc4SJason Schmidlapp * writers over readers when threads have equal priority. 234062c5bc4SJason Schmidlapp * 235062c5bc4SJason Schmidlapp * _POSIX_THREAD_PRIO_INHERIT (== -1) 236062c5bc4SJason Schmidlapp * If == 200112L, you can create priority inheritance 237062c5bc4SJason Schmidlapp * mutexes. 238062c5bc4SJason Schmidlapp * pthread_mutexattr_getprotocol + 239062c5bc4SJason Schmidlapp * pthread_mutexattr_setprotocol + 240062c5bc4SJason Schmidlapp * 241062c5bc4SJason Schmidlapp * _POSIX_THREAD_PRIO_PROTECT (== -1) 242062c5bc4SJason Schmidlapp * If == 200112L, you can create priority ceiling mutexes 243062c5bc4SJason Schmidlapp * Indicates the availability of: 244062c5bc4SJason Schmidlapp * pthread_mutex_getprioceiling 245062c5bc4SJason Schmidlapp * pthread_mutex_setprioceiling 246062c5bc4SJason Schmidlapp * pthread_mutexattr_getprioceiling 247062c5bc4SJason Schmidlapp * pthread_mutexattr_getprotocol + 248062c5bc4SJason Schmidlapp * pthread_mutexattr_setprioceiling 249062c5bc4SJason Schmidlapp * pthread_mutexattr_setprotocol + 250062c5bc4SJason Schmidlapp * 251062c5bc4SJason Schmidlapp * _POSIX_THREAD_PROCESS_SHARED (== -1) 252062c5bc4SJason Schmidlapp * If set, you can create mutexes and condition 253062c5bc4SJason Schmidlapp * variables that can be shared with another 254062c5bc4SJason Schmidlapp * process.If set, indicates the availability 255062c5bc4SJason Schmidlapp * of: 256062c5bc4SJason Schmidlapp * pthread_mutexattr_getpshared 257062c5bc4SJason Schmidlapp * pthread_mutexattr_setpshared 258062c5bc4SJason Schmidlapp * pthread_condattr_getpshared 259062c5bc4SJason Schmidlapp * pthread_condattr_setpshared 260062c5bc4SJason Schmidlapp * 261062c5bc4SJason Schmidlapp * _POSIX_THREAD_SAFE_FUNCTIONS (== 200112L) 262062c5bc4SJason Schmidlapp * If == 200112L you can use the special *_r library 263062c5bc4SJason Schmidlapp * functions that provide thread-safe behaviour 264062c5bc4SJason Schmidlapp * 265062c5bc4SJason Schmidlapp * _POSIX_READER_WRITER_LOCKS (== 200112L) 266062c5bc4SJason Schmidlapp * If == 200112L, you can use read/write locks 267062c5bc4SJason Schmidlapp * 268062c5bc4SJason Schmidlapp * _POSIX_SPIN_LOCKS (== 200112L) 269062c5bc4SJason Schmidlapp * If == 200112L, you can use spin locks 270062c5bc4SJason Schmidlapp * 271062c5bc4SJason Schmidlapp * _POSIX_BARRIERS (== 200112L) 272062c5bc4SJason Schmidlapp * If == 200112L, you can use barriers 273062c5bc4SJason Schmidlapp * 274062c5bc4SJason Schmidlapp * + These functions provide both 'inherit' and/or 275062c5bc4SJason Schmidlapp * 'protect' protocol, based upon these macro 276062c5bc4SJason Schmidlapp * settings. 277062c5bc4SJason Schmidlapp * 278062c5bc4SJason Schmidlapp * ------------------------------------------------------------- 279062c5bc4SJason Schmidlapp */ 280062c5bc4SJason Schmidlapp 281062c5bc4SJason Schmidlapp /* 282062c5bc4SJason Schmidlapp * POSIX Options 283062c5bc4SJason Schmidlapp */ 284062c5bc4SJason Schmidlapp #undef _POSIX_THREADS 285062c5bc4SJason Schmidlapp #define _POSIX_THREADS 200112L 286062c5bc4SJason Schmidlapp 287062c5bc4SJason Schmidlapp #undef _POSIX_READER_WRITER_LOCKS 288062c5bc4SJason Schmidlapp #define _POSIX_READER_WRITER_LOCKS 200112L 289062c5bc4SJason Schmidlapp 290062c5bc4SJason Schmidlapp #undef _POSIX_SPIN_LOCKS 291062c5bc4SJason Schmidlapp #define _POSIX_SPIN_LOCKS 200112L 292062c5bc4SJason Schmidlapp 293062c5bc4SJason Schmidlapp #undef _POSIX_BARRIERS 294062c5bc4SJason Schmidlapp #define _POSIX_BARRIERS 200112L 295062c5bc4SJason Schmidlapp 296062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_SAFE_FUNCTIONS 297062c5bc4SJason Schmidlapp #define _POSIX_THREAD_SAFE_FUNCTIONS 200112L 298062c5bc4SJason Schmidlapp 299062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_ATTR_STACKSIZE 300062c5bc4SJason Schmidlapp #define _POSIX_THREAD_ATTR_STACKSIZE 200112L 301062c5bc4SJason Schmidlapp 302062c5bc4SJason Schmidlapp /* 303062c5bc4SJason Schmidlapp * The following options are not supported 304062c5bc4SJason Schmidlapp */ 305062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_ATTR_STACKADDR 306062c5bc4SJason Schmidlapp #define _POSIX_THREAD_ATTR_STACKADDR -1 307062c5bc4SJason Schmidlapp 308062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_PRIO_INHERIT 309062c5bc4SJason Schmidlapp #define _POSIX_THREAD_PRIO_INHERIT -1 310062c5bc4SJason Schmidlapp 311062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_PRIO_PROTECT 312062c5bc4SJason Schmidlapp #define _POSIX_THREAD_PRIO_PROTECT -1 313062c5bc4SJason Schmidlapp 314062c5bc4SJason Schmidlapp /* TPS is not fully supported. */ 315062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_PRIORITY_SCHEDULING 316062c5bc4SJason Schmidlapp #define _POSIX_THREAD_PRIORITY_SCHEDULING -1 317062c5bc4SJason Schmidlapp 318062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_PROCESS_SHARED 319062c5bc4SJason Schmidlapp #define _POSIX_THREAD_PROCESS_SHARED -1 320062c5bc4SJason Schmidlapp 321062c5bc4SJason Schmidlapp 322062c5bc4SJason Schmidlapp /* 323062c5bc4SJason Schmidlapp * POSIX 1003.1-2001 Limits 324062c5bc4SJason Schmidlapp * =========================== 325062c5bc4SJason Schmidlapp * 326062c5bc4SJason Schmidlapp * These limits are normally set in <limits.h>, which is not provided with 327062c5bc4SJason Schmidlapp * pthreads-embedded. 328062c5bc4SJason Schmidlapp * 329062c5bc4SJason Schmidlapp * PTHREAD_DESTRUCTOR_ITERATIONS 330062c5bc4SJason Schmidlapp * Maximum number of attempts to destroy 331062c5bc4SJason Schmidlapp * a thread's thread-specific data on 332062c5bc4SJason Schmidlapp * termination (must be at least 4) 333062c5bc4SJason Schmidlapp * 334062c5bc4SJason Schmidlapp * PTHREAD_KEYS_MAX 335062c5bc4SJason Schmidlapp * Maximum number of thread-specific data keys 336062c5bc4SJason Schmidlapp * available per process (must be at least 128) 337062c5bc4SJason Schmidlapp * 338062c5bc4SJason Schmidlapp * PTHREAD_STACK_MIN 339062c5bc4SJason Schmidlapp * Minimum supported stack size for a thread 340062c5bc4SJason Schmidlapp * 341062c5bc4SJason Schmidlapp * PTHREAD_THREADS_MAX 342062c5bc4SJason Schmidlapp * Maximum number of threads supported per 343062c5bc4SJason Schmidlapp * process (must be at least 64). 344062c5bc4SJason Schmidlapp * 345062c5bc4SJason Schmidlapp * SEM_NSEMS_MAX 346062c5bc4SJason Schmidlapp * The maximum number of semaphores a process can have. 347062c5bc4SJason Schmidlapp * (must be at least 256) 348062c5bc4SJason Schmidlapp * 349062c5bc4SJason Schmidlapp * SEM_VALUE_MAX 350062c5bc4SJason Schmidlapp * The maximum value a semaphore can have. 351062c5bc4SJason Schmidlapp * (must be at least 32767) 352062c5bc4SJason Schmidlapp * 353062c5bc4SJason Schmidlapp */ 354062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_DESTRUCTOR_ITERATIONS 355062c5bc4SJason Schmidlapp #define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4 356062c5bc4SJason Schmidlapp 357062c5bc4SJason Schmidlapp #undef PTHREAD_DESTRUCTOR_ITERATIONS 358062c5bc4SJason Schmidlapp #define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS 359062c5bc4SJason Schmidlapp 360062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_KEYS_MAX 361062c5bc4SJason Schmidlapp #define _POSIX_THREAD_KEYS_MAX 128 362062c5bc4SJason Schmidlapp 363062c5bc4SJason Schmidlapp #undef PTHREAD_KEYS_MAX 364062c5bc4SJason Schmidlapp #define PTHREAD_KEYS_MAX _POSIX_THREAD_KEYS_MAX 365062c5bc4SJason Schmidlapp 366062c5bc4SJason Schmidlapp #undef PTHREAD_STACK_MIN 367062c5bc4SJason Schmidlapp #define PTHREAD_STACK_MIN 0 368062c5bc4SJason Schmidlapp 369062c5bc4SJason Schmidlapp #undef _POSIX_THREAD_THREADS_MAX 370062c5bc4SJason Schmidlapp #define _POSIX_THREAD_THREADS_MAX 64 371062c5bc4SJason Schmidlapp 372062c5bc4SJason Schmidlapp /* Arbitrary value */ 373062c5bc4SJason Schmidlapp #undef PTHREAD_THREADS_MAX 374062c5bc4SJason Schmidlapp #define PTHREAD_THREADS_MAX 2019 375062c5bc4SJason Schmidlapp 376062c5bc4SJason Schmidlapp #undef _POSIX_SEM_NSEMS_MAX 377062c5bc4SJason Schmidlapp #define _POSIX_SEM_NSEMS_MAX 256 378062c5bc4SJason Schmidlapp 379062c5bc4SJason Schmidlapp /* Arbitrary value */ 380062c5bc4SJason Schmidlapp #undef SEM_NSEMS_MAX 381062c5bc4SJason Schmidlapp #define SEM_NSEMS_MAX 1024 382062c5bc4SJason Schmidlapp 383062c5bc4SJason Schmidlapp #undef _POSIX_SEM_VALUE_MAX 384062c5bc4SJason Schmidlapp #define _POSIX_SEM_VALUE_MAX 32767 385062c5bc4SJason Schmidlapp 386062c5bc4SJason Schmidlapp #undef SEM_VALUE_MAX 387062c5bc4SJason Schmidlapp #define SEM_VALUE_MAX INT_MAX 388062c5bc4SJason Schmidlapp 389a12978ccSJeremy Soller typedef void * pthread_t; 390062c5bc4SJason Schmidlapp typedef struct pthread_attr_t_ * pthread_attr_t; 391062c5bc4SJason Schmidlapp typedef struct pthread_once_t_ pthread_once_t; 392062c5bc4SJason Schmidlapp typedef struct pthread_key_t_ * pthread_key_t; 393062c5bc4SJason Schmidlapp typedef struct pthread_mutex_t_ * pthread_mutex_t; 394062c5bc4SJason Schmidlapp typedef struct pthread_mutexattr_t_ * pthread_mutexattr_t; 395062c5bc4SJason Schmidlapp typedef struct pthread_cond_t_ * pthread_cond_t; 396062c5bc4SJason Schmidlapp typedef struct pthread_condattr_t_ * pthread_condattr_t; 397062c5bc4SJason Schmidlapp typedef struct pthread_rwlock_t_ * pthread_rwlock_t; 398062c5bc4SJason Schmidlapp typedef struct pthread_rwlockattr_t_ * pthread_rwlockattr_t; 399062c5bc4SJason Schmidlapp typedef struct pthread_spinlock_t_ * pthread_spinlock_t; 400062c5bc4SJason Schmidlapp typedef struct pthread_barrier_t_ * pthread_barrier_t; 401062c5bc4SJason Schmidlapp typedef struct pthread_barrierattr_t_ * pthread_barrierattr_t; 402062c5bc4SJason Schmidlapp 403062c5bc4SJason Schmidlapp /* 404062c5bc4SJason Schmidlapp * ==================== 405062c5bc4SJason Schmidlapp * ==================== 406062c5bc4SJason Schmidlapp * POSIX Threads 407062c5bc4SJason Schmidlapp * ==================== 408062c5bc4SJason Schmidlapp * ==================== 409062c5bc4SJason Schmidlapp */ 410062c5bc4SJason Schmidlapp 411062c5bc4SJason Schmidlapp enum 412062c5bc4SJason Schmidlapp { 413062c5bc4SJason Schmidlapp /* 414062c5bc4SJason Schmidlapp * pthread_attr_{get,set}detachstate 415062c5bc4SJason Schmidlapp */ 416062c5bc4SJason Schmidlapp PTHREAD_CREATE_JOINABLE = 0, /* Default */ 417062c5bc4SJason Schmidlapp PTHREAD_CREATE_DETACHED = 1, 418062c5bc4SJason Schmidlapp 419062c5bc4SJason Schmidlapp /* 420062c5bc4SJason Schmidlapp * pthread_attr_{get,set}inheritsched 421062c5bc4SJason Schmidlapp */ 422062c5bc4SJason Schmidlapp PTHREAD_INHERIT_SCHED = 0, 423062c5bc4SJason Schmidlapp PTHREAD_EXPLICIT_SCHED = 1, /* Default */ 424062c5bc4SJason Schmidlapp 425062c5bc4SJason Schmidlapp /* 426062c5bc4SJason Schmidlapp * pthread_{get,set}scope 427062c5bc4SJason Schmidlapp */ 428062c5bc4SJason Schmidlapp PTHREAD_SCOPE_PROCESS = 0, 429062c5bc4SJason Schmidlapp PTHREAD_SCOPE_SYSTEM = 1, /* Default */ 430062c5bc4SJason Schmidlapp PTHREAD_SCOPE_PROCESS_VFPU = 2, /* PSP specific */ 431062c5bc4SJason Schmidlapp 432062c5bc4SJason Schmidlapp /* 433062c5bc4SJason Schmidlapp * pthread_setcancelstate paramters 434062c5bc4SJason Schmidlapp */ 435062c5bc4SJason Schmidlapp PTHREAD_CANCEL_ENABLE = 0, /* Default */ 436062c5bc4SJason Schmidlapp PTHREAD_CANCEL_DISABLE = 1, 437062c5bc4SJason Schmidlapp 438062c5bc4SJason Schmidlapp /* 439062c5bc4SJason Schmidlapp * pthread_setcanceltype parameters 440062c5bc4SJason Schmidlapp */ 441062c5bc4SJason Schmidlapp PTHREAD_CANCEL_ASYNCHRONOUS = 0, 442062c5bc4SJason Schmidlapp PTHREAD_CANCEL_DEFERRED = 1, /* Default */ 443062c5bc4SJason Schmidlapp 444062c5bc4SJason Schmidlapp /* 445062c5bc4SJason Schmidlapp * pthread_mutexattr_{get,set}pshared 446062c5bc4SJason Schmidlapp * pthread_condattr_{get,set}pshared 447062c5bc4SJason Schmidlapp */ 448062c5bc4SJason Schmidlapp PTHREAD_PROCESS_PRIVATE = 0, 449062c5bc4SJason Schmidlapp PTHREAD_PROCESS_SHARED = 1, 450062c5bc4SJason Schmidlapp 451062c5bc4SJason Schmidlapp /* 452062c5bc4SJason Schmidlapp * pthread_barrier_wait 453062c5bc4SJason Schmidlapp */ 454062c5bc4SJason Schmidlapp PTHREAD_BARRIER_SERIAL_THREAD = -1 455062c5bc4SJason Schmidlapp }; 456062c5bc4SJason Schmidlapp 457062c5bc4SJason Schmidlapp /* 458062c5bc4SJason Schmidlapp * ==================== 459062c5bc4SJason Schmidlapp * ==================== 460062c5bc4SJason Schmidlapp * Cancelation 461062c5bc4SJason Schmidlapp * ==================== 462062c5bc4SJason Schmidlapp * ==================== 463062c5bc4SJason Schmidlapp */ 464062c5bc4SJason Schmidlapp #define PTHREAD_CANCELED ((void *) -1) 465062c5bc4SJason Schmidlapp 466062c5bc4SJason Schmidlapp 467062c5bc4SJason Schmidlapp /* 468062c5bc4SJason Schmidlapp * ==================== 469062c5bc4SJason Schmidlapp * ==================== 470062c5bc4SJason Schmidlapp * Once Key 471062c5bc4SJason Schmidlapp * ==================== 472062c5bc4SJason Schmidlapp * ==================== 473062c5bc4SJason Schmidlapp */ 474062c5bc4SJason Schmidlapp #define PTHREAD_ONCE_INIT { PTE_FALSE, 0, 0, 0} 475062c5bc4SJason Schmidlapp 476062c5bc4SJason Schmidlapp struct pthread_once_t_ 477062c5bc4SJason Schmidlapp { 478062c5bc4SJason Schmidlapp int state; 479062c5bc4SJason Schmidlapp void * semaphore; 480062c5bc4SJason Schmidlapp int numSemaphoreUsers; 481062c5bc4SJason Schmidlapp int done; /* indicates if user function has been executed */ 482062c5bc4SJason Schmidlapp // void * lock; 483062c5bc4SJason Schmidlapp // int reserved1; 484062c5bc4SJason Schmidlapp // int reserved2; 485062c5bc4SJason Schmidlapp }; 486062c5bc4SJason Schmidlapp 487062c5bc4SJason Schmidlapp 488062c5bc4SJason Schmidlapp /* 489062c5bc4SJason Schmidlapp * ==================== 490062c5bc4SJason Schmidlapp * ==================== 491062c5bc4SJason Schmidlapp * Object initialisers 492062c5bc4SJason Schmidlapp * ==================== 493062c5bc4SJason Schmidlapp * ==================== 494062c5bc4SJason Schmidlapp */ 495062c5bc4SJason Schmidlapp #define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) -1) 496062c5bc4SJason Schmidlapp #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t) -2) 497062c5bc4SJason Schmidlapp #define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_t) -3) 498062c5bc4SJason Schmidlapp 499062c5bc4SJason Schmidlapp /* 500062c5bc4SJason Schmidlapp * Compatibility with LinuxThreads 501062c5bc4SJason Schmidlapp */ 502062c5bc4SJason Schmidlapp #define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP PTHREAD_RECURSIVE_MUTEX_INITIALIZER 503062c5bc4SJason Schmidlapp #define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP PTHREAD_ERRORCHECK_MUTEX_INITIALIZER 504062c5bc4SJason Schmidlapp 505062c5bc4SJason Schmidlapp #define PTHREAD_COND_INITIALIZER ((pthread_cond_t) -1) 506062c5bc4SJason Schmidlapp 507062c5bc4SJason Schmidlapp #define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t) -1) 508062c5bc4SJason Schmidlapp 509062c5bc4SJason Schmidlapp #define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_t) -1) 510062c5bc4SJason Schmidlapp 511062c5bc4SJason Schmidlapp 512062c5bc4SJason Schmidlapp /* 513062c5bc4SJason Schmidlapp * Mutex types. 514062c5bc4SJason Schmidlapp */ 515062c5bc4SJason Schmidlapp enum 516062c5bc4SJason Schmidlapp { 517062c5bc4SJason Schmidlapp /* Compatibility with LinuxThreads */ 518062c5bc4SJason Schmidlapp PTHREAD_MUTEX_FAST_NP, 519062c5bc4SJason Schmidlapp PTHREAD_MUTEX_RECURSIVE_NP, 520062c5bc4SJason Schmidlapp PTHREAD_MUTEX_ERRORCHECK_NP, 521062c5bc4SJason Schmidlapp PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP, 522062c5bc4SJason Schmidlapp PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP, 523062c5bc4SJason Schmidlapp /* For compatibility with POSIX */ 524062c5bc4SJason Schmidlapp PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP, 525062c5bc4SJason Schmidlapp PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, 526062c5bc4SJason Schmidlapp PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, 527062c5bc4SJason Schmidlapp PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL 528062c5bc4SJason Schmidlapp }; 529062c5bc4SJason Schmidlapp 530062c5bc4SJason Schmidlapp 531062c5bc4SJason Schmidlapp typedef struct pte_cleanup_t pte_cleanup_t; 532062c5bc4SJason Schmidlapp 533062c5bc4SJason Schmidlapp typedef void (* pte_cleanup_callback_t)(void *); 534062c5bc4SJason Schmidlapp 535062c5bc4SJason Schmidlapp struct pte_cleanup_t 536062c5bc4SJason Schmidlapp { 537062c5bc4SJason Schmidlapp pte_cleanup_callback_t routine; 538062c5bc4SJason Schmidlapp void *arg; 539062c5bc4SJason Schmidlapp struct pte_cleanup_t *prev; 540062c5bc4SJason Schmidlapp }; 541062c5bc4SJason Schmidlapp 542062c5bc4SJason Schmidlapp #ifdef PTE_CLEANUP_C 543062c5bc4SJason Schmidlapp 544062c5bc4SJason Schmidlapp /* 545062c5bc4SJason Schmidlapp * C implementation of PThreads cancel cleanup 546062c5bc4SJason Schmidlapp */ 547062c5bc4SJason Schmidlapp 548062c5bc4SJason Schmidlapp #define pthread_cleanup_push( _rout, _arg ) \ 549062c5bc4SJason Schmidlapp { \ 550062c5bc4SJason Schmidlapp pte_cleanup_t _cleanup; \ 551062c5bc4SJason Schmidlapp \ 552062c5bc4SJason Schmidlapp pte_push_cleanup( &_cleanup, (pte_cleanup_callback_t) (_rout), (_arg) ); \ 553062c5bc4SJason Schmidlapp 554062c5bc4SJason Schmidlapp #define pthread_cleanup_pop( _execute ) \ 555062c5bc4SJason Schmidlapp (void) pte_pop_cleanup( _execute ); \ 556062c5bc4SJason Schmidlapp } 557062c5bc4SJason Schmidlapp 558062c5bc4SJason Schmidlapp #else /* PTE_CLEANUP_C */ 559062c5bc4SJason Schmidlapp 560062c5bc4SJason Schmidlapp #ifdef PTE_CLEANUP_CXX 561062c5bc4SJason Schmidlapp 562062c5bc4SJason Schmidlapp /* 563062c5bc4SJason Schmidlapp * C++ version of cancel cleanup. 564062c5bc4SJason Schmidlapp * - John E. Bossom. 565062c5bc4SJason Schmidlapp */ 566062c5bc4SJason Schmidlapp 567062c5bc4SJason Schmidlapp class PThreadCleanup 568062c5bc4SJason Schmidlapp { 569062c5bc4SJason Schmidlapp /* 570062c5bc4SJason Schmidlapp * PThreadCleanup 571062c5bc4SJason Schmidlapp * 572062c5bc4SJason Schmidlapp * Purpose 573062c5bc4SJason Schmidlapp * This class is a C++ helper class that is 574062c5bc4SJason Schmidlapp * used to implement pthread_cleanup_push/ 575062c5bc4SJason Schmidlapp * pthread_cleanup_pop. 576062c5bc4SJason Schmidlapp * The destructor of this class automatically 577062c5bc4SJason Schmidlapp * pops the pushed cleanup routine regardless 578062c5bc4SJason Schmidlapp * of how the code exits the scope 579062c5bc4SJason Schmidlapp * (i.e. such as by an exception) 580062c5bc4SJason Schmidlapp */ 581062c5bc4SJason Schmidlapp pte_cleanup_callback_t cleanUpRout; 582062c5bc4SJason Schmidlapp void * obj; 583062c5bc4SJason Schmidlapp int executeIt; 584062c5bc4SJason Schmidlapp 585062c5bc4SJason Schmidlapp public: PThreadCleanup()586062c5bc4SJason Schmidlapp PThreadCleanup() : 587062c5bc4SJason Schmidlapp cleanUpRout( 0 ), 588062c5bc4SJason Schmidlapp obj( 0 ), 589062c5bc4SJason Schmidlapp executeIt( 0 ) 590062c5bc4SJason Schmidlapp /* 591062c5bc4SJason Schmidlapp * No cleanup performed 592062c5bc4SJason Schmidlapp */ 593062c5bc4SJason Schmidlapp { 594062c5bc4SJason Schmidlapp } 595062c5bc4SJason Schmidlapp PThreadCleanup(pte_cleanup_callback_t routine,void * arg)596062c5bc4SJason Schmidlapp PThreadCleanup( 597062c5bc4SJason Schmidlapp pte_cleanup_callback_t routine, 598062c5bc4SJason Schmidlapp void * arg ) : 599062c5bc4SJason Schmidlapp cleanUpRout( routine ), 600062c5bc4SJason Schmidlapp obj( arg ), 601062c5bc4SJason Schmidlapp executeIt( 1 ) 602062c5bc4SJason Schmidlapp /* 603062c5bc4SJason Schmidlapp * Registers a cleanup routine for 'arg' 604062c5bc4SJason Schmidlapp */ 605062c5bc4SJason Schmidlapp { 606062c5bc4SJason Schmidlapp } 607062c5bc4SJason Schmidlapp ~PThreadCleanup()608062c5bc4SJason Schmidlapp ~PThreadCleanup() 609062c5bc4SJason Schmidlapp { 610062c5bc4SJason Schmidlapp if ( executeIt ) 611062c5bc4SJason Schmidlapp { 612062c5bc4SJason Schmidlapp (void) (*cleanUpRout)( obj ); 613062c5bc4SJason Schmidlapp } 614062c5bc4SJason Schmidlapp } 615062c5bc4SJason Schmidlapp execute(int exec)616062c5bc4SJason Schmidlapp void execute( int exec ) 617062c5bc4SJason Schmidlapp { 618062c5bc4SJason Schmidlapp executeIt = exec; 619062c5bc4SJason Schmidlapp } 620062c5bc4SJason Schmidlapp }; 621062c5bc4SJason Schmidlapp 622062c5bc4SJason Schmidlapp /* 623062c5bc4SJason Schmidlapp * C++ implementation of PThreads cancel cleanup; 624062c5bc4SJason Schmidlapp * This implementation takes advantage of a helper 625062c5bc4SJason Schmidlapp * class who's destructor automatically calls the 626062c5bc4SJason Schmidlapp * cleanup routine if we exit our scope weirdly 627062c5bc4SJason Schmidlapp */ 628062c5bc4SJason Schmidlapp #define pthread_cleanup_push( _rout, _arg ) \ 629062c5bc4SJason Schmidlapp { \ 630062c5bc4SJason Schmidlapp PThreadCleanup cleanup((pte_cleanup_callback_t)(_rout), \ 631062c5bc4SJason Schmidlapp (void *) (_arg) ); 632062c5bc4SJason Schmidlapp 633062c5bc4SJason Schmidlapp #define pthread_cleanup_pop( _execute ) \ 634062c5bc4SJason Schmidlapp cleanup.execute( _execute ); \ 635062c5bc4SJason Schmidlapp } 636062c5bc4SJason Schmidlapp 637062c5bc4SJason Schmidlapp #else 638062c5bc4SJason Schmidlapp 639062c5bc4SJason Schmidlapp #error ERROR [__FILE__, line __LINE__]: Cleanup type undefined. 640062c5bc4SJason Schmidlapp 641062c5bc4SJason Schmidlapp #endif /* PTE_CLEANUP_CXX */ 642062c5bc4SJason Schmidlapp 643062c5bc4SJason Schmidlapp #endif /* PTE_CLEANUP_C */ 644062c5bc4SJason Schmidlapp 645747ec726SJason Schmidlapp #ifdef __cplusplus 646747ec726SJason Schmidlapp extern "C" { 647747ec726SJason Schmidlapp #endif /* __cplusplus */ 648747ec726SJason Schmidlapp 649062c5bc4SJason Schmidlapp /* 650062c5bc4SJason Schmidlapp * =============== 651062c5bc4SJason Schmidlapp * =============== 652062c5bc4SJason Schmidlapp * Methods 653062c5bc4SJason Schmidlapp * =============== 654062c5bc4SJason Schmidlapp * =============== 655062c5bc4SJason Schmidlapp */ 656062c5bc4SJason Schmidlapp 657dc52dd28SJeremy Soller void pthread_init (void); 658062c5bc4SJason Schmidlapp void pthread_terminate (void); 659062c5bc4SJason Schmidlapp 660062c5bc4SJason Schmidlapp /* 661062c5bc4SJason Schmidlapp * PThread Attribute Functions 662062c5bc4SJason Schmidlapp */ 663062c5bc4SJason Schmidlapp int pthread_attr_init (pthread_attr_t * attr); 664062c5bc4SJason Schmidlapp 665062c5bc4SJason Schmidlapp int pthread_attr_destroy (pthread_attr_t * attr); 666062c5bc4SJason Schmidlapp 667062c5bc4SJason Schmidlapp int pthread_attr_getdetachstate (const pthread_attr_t * attr, 668062c5bc4SJason Schmidlapp int *detachstate); 669062c5bc4SJason Schmidlapp 670062c5bc4SJason Schmidlapp int pthread_attr_getstackaddr (const pthread_attr_t * attr, 671062c5bc4SJason Schmidlapp void **stackaddr); 672062c5bc4SJason Schmidlapp 673062c5bc4SJason Schmidlapp int pthread_attr_getstacksize (const pthread_attr_t * attr, 674062c5bc4SJason Schmidlapp size_t * stacksize); 675062c5bc4SJason Schmidlapp 676062c5bc4SJason Schmidlapp int pthread_attr_setdetachstate (pthread_attr_t * attr, 677062c5bc4SJason Schmidlapp int detachstate); 678062c5bc4SJason Schmidlapp 679062c5bc4SJason Schmidlapp int pthread_attr_setstackaddr (pthread_attr_t * attr, 680062c5bc4SJason Schmidlapp void *stackaddr); 681062c5bc4SJason Schmidlapp 682062c5bc4SJason Schmidlapp int pthread_attr_setstacksize (pthread_attr_t * attr, 683062c5bc4SJason Schmidlapp size_t stacksize); 684062c5bc4SJason Schmidlapp 685062c5bc4SJason Schmidlapp int pthread_attr_getschedparam (const pthread_attr_t *attr, 686062c5bc4SJason Schmidlapp struct sched_param *param); 687062c5bc4SJason Schmidlapp 688062c5bc4SJason Schmidlapp int pthread_attr_setschedparam (pthread_attr_t *attr, 689062c5bc4SJason Schmidlapp const struct sched_param *param); 690062c5bc4SJason Schmidlapp 691062c5bc4SJason Schmidlapp int pthread_attr_setschedpolicy (pthread_attr_t *, 692062c5bc4SJason Schmidlapp int); 693062c5bc4SJason Schmidlapp 694062c5bc4SJason Schmidlapp int pthread_attr_getschedpolicy (pthread_attr_t *, 695062c5bc4SJason Schmidlapp int *); 696062c5bc4SJason Schmidlapp 697062c5bc4SJason Schmidlapp int pthread_attr_setinheritsched(pthread_attr_t * attr, 698062c5bc4SJason Schmidlapp int inheritsched); 699062c5bc4SJason Schmidlapp 700062c5bc4SJason Schmidlapp int pthread_attr_getinheritsched(pthread_attr_t * attr, 701062c5bc4SJason Schmidlapp int * inheritsched); 702062c5bc4SJason Schmidlapp 703062c5bc4SJason Schmidlapp int pthread_attr_setscope (pthread_attr_t *, 704062c5bc4SJason Schmidlapp int); 705062c5bc4SJason Schmidlapp 706062c5bc4SJason Schmidlapp int pthread_attr_getscope (const pthread_attr_t *, 707062c5bc4SJason Schmidlapp int *); 708062c5bc4SJason Schmidlapp 709062c5bc4SJason Schmidlapp /* 710062c5bc4SJason Schmidlapp * PThread Functions 711062c5bc4SJason Schmidlapp */ 712062c5bc4SJason Schmidlapp int pthread_create (pthread_t * tid, 713062c5bc4SJason Schmidlapp const pthread_attr_t * attr, 714062c5bc4SJason Schmidlapp void *(*start) (void *), 715062c5bc4SJason Schmidlapp void *arg); 716062c5bc4SJason Schmidlapp 717062c5bc4SJason Schmidlapp int pthread_detach (pthread_t tid); 718062c5bc4SJason Schmidlapp 719062c5bc4SJason Schmidlapp int pthread_equal (pthread_t t1, 720062c5bc4SJason Schmidlapp pthread_t t2); 721062c5bc4SJason Schmidlapp 722062c5bc4SJason Schmidlapp void pthread_exit (void *value_ptr); 723062c5bc4SJason Schmidlapp 724062c5bc4SJason Schmidlapp int pthread_join (pthread_t thread, 725062c5bc4SJason Schmidlapp void **value_ptr); 726062c5bc4SJason Schmidlapp 727062c5bc4SJason Schmidlapp pthread_t pthread_self (void); 728062c5bc4SJason Schmidlapp 729062c5bc4SJason Schmidlapp int pthread_cancel (pthread_t thread); 730062c5bc4SJason Schmidlapp 731062c5bc4SJason Schmidlapp int pthread_setcancelstate (int state, 732062c5bc4SJason Schmidlapp int *oldstate); 733062c5bc4SJason Schmidlapp 734062c5bc4SJason Schmidlapp int pthread_setcanceltype (int type, 735062c5bc4SJason Schmidlapp int *oldtype); 736062c5bc4SJason Schmidlapp 737062c5bc4SJason Schmidlapp void pthread_testcancel (void); 738062c5bc4SJason Schmidlapp 739062c5bc4SJason Schmidlapp int pthread_once (pthread_once_t * once_control, 740062c5bc4SJason Schmidlapp void (*init_routine) (void)); 741062c5bc4SJason Schmidlapp 742062c5bc4SJason Schmidlapp #if PTE_LEVEL >= PTE_LEVEL_MAX 743062c5bc4SJason Schmidlapp pte_cleanup_t * pte_pop_cleanup (int execute); 744062c5bc4SJason Schmidlapp 745062c5bc4SJason Schmidlapp void pte_push_cleanup (pte_cleanup_t * cleanup, 746062c5bc4SJason Schmidlapp void (*routine) (void *), 747062c5bc4SJason Schmidlapp void *arg); 748062c5bc4SJason Schmidlapp #endif /* PTE_LEVEL >= PTE_LEVEL_MAX */ 749062c5bc4SJason Schmidlapp 750062c5bc4SJason Schmidlapp /* 751062c5bc4SJason Schmidlapp * Thread Specific Data Functions 752062c5bc4SJason Schmidlapp */ 753062c5bc4SJason Schmidlapp int pthread_key_create (pthread_key_t * key, 754062c5bc4SJason Schmidlapp void (*destructor) (void *)); 755062c5bc4SJason Schmidlapp 756062c5bc4SJason Schmidlapp int pthread_key_delete (pthread_key_t key); 757062c5bc4SJason Schmidlapp 758062c5bc4SJason Schmidlapp int pthread_setspecific (pthread_key_t key, 759062c5bc4SJason Schmidlapp const void *value); 760062c5bc4SJason Schmidlapp 761062c5bc4SJason Schmidlapp void * pthread_getspecific (pthread_key_t key); 762062c5bc4SJason Schmidlapp 763062c5bc4SJason Schmidlapp 764062c5bc4SJason Schmidlapp /* 765062c5bc4SJason Schmidlapp * Mutex Attribute Functions 766062c5bc4SJason Schmidlapp */ 767062c5bc4SJason Schmidlapp int pthread_mutexattr_init (pthread_mutexattr_t * attr); 768062c5bc4SJason Schmidlapp 769062c5bc4SJason Schmidlapp int pthread_mutexattr_destroy (pthread_mutexattr_t * attr); 770062c5bc4SJason Schmidlapp 771062c5bc4SJason Schmidlapp int pthread_mutexattr_getpshared (const pthread_mutexattr_t 772062c5bc4SJason Schmidlapp * attr, 773062c5bc4SJason Schmidlapp int *pshared); 774062c5bc4SJason Schmidlapp 775062c5bc4SJason Schmidlapp int pthread_mutexattr_setpshared (pthread_mutexattr_t * attr, 776062c5bc4SJason Schmidlapp int pshared); 777062c5bc4SJason Schmidlapp 778062c5bc4SJason Schmidlapp int pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind); 779062c5bc4SJason Schmidlapp int pthread_mutexattr_gettype (pthread_mutexattr_t * attr, int *kind); 780062c5bc4SJason Schmidlapp 781062c5bc4SJason Schmidlapp /* 782062c5bc4SJason Schmidlapp * Barrier Attribute Functions 783062c5bc4SJason Schmidlapp */ 784062c5bc4SJason Schmidlapp int pthread_barrierattr_init (pthread_barrierattr_t * attr); 785062c5bc4SJason Schmidlapp 786062c5bc4SJason Schmidlapp int pthread_barrierattr_destroy (pthread_barrierattr_t * attr); 787062c5bc4SJason Schmidlapp 788062c5bc4SJason Schmidlapp int pthread_barrierattr_getpshared (const pthread_barrierattr_t 789062c5bc4SJason Schmidlapp * attr, 790062c5bc4SJason Schmidlapp int *pshared); 791062c5bc4SJason Schmidlapp 792062c5bc4SJason Schmidlapp int pthread_barrierattr_setpshared (pthread_barrierattr_t * attr, 793062c5bc4SJason Schmidlapp int pshared); 794062c5bc4SJason Schmidlapp 795062c5bc4SJason Schmidlapp /* 796062c5bc4SJason Schmidlapp * Mutex Functions 797062c5bc4SJason Schmidlapp */ 798062c5bc4SJason Schmidlapp int pthread_mutex_init (pthread_mutex_t * mutex, 799062c5bc4SJason Schmidlapp const pthread_mutexattr_t * attr); 800062c5bc4SJason Schmidlapp 801062c5bc4SJason Schmidlapp int pthread_mutex_destroy (pthread_mutex_t * mutex); 802062c5bc4SJason Schmidlapp 803062c5bc4SJason Schmidlapp int pthread_mutex_lock (pthread_mutex_t * mutex); 804062c5bc4SJason Schmidlapp 805062c5bc4SJason Schmidlapp int pthread_mutex_timedlock(pthread_mutex_t *mutex, 806062c5bc4SJason Schmidlapp const struct timespec *abstime); 807062c5bc4SJason Schmidlapp 808062c5bc4SJason Schmidlapp int pthread_mutex_trylock (pthread_mutex_t * mutex); 809062c5bc4SJason Schmidlapp 810062c5bc4SJason Schmidlapp int pthread_mutex_unlock (pthread_mutex_t * mutex); 811062c5bc4SJason Schmidlapp 812062c5bc4SJason Schmidlapp /* 813062c5bc4SJason Schmidlapp * Spinlock Functions 814062c5bc4SJason Schmidlapp */ 815062c5bc4SJason Schmidlapp int pthread_spin_init (pthread_spinlock_t * lock, int pshared); 816062c5bc4SJason Schmidlapp 817062c5bc4SJason Schmidlapp int pthread_spin_destroy (pthread_spinlock_t * lock); 818062c5bc4SJason Schmidlapp 819062c5bc4SJason Schmidlapp int pthread_spin_lock (pthread_spinlock_t * lock); 820062c5bc4SJason Schmidlapp 821062c5bc4SJason Schmidlapp int pthread_spin_trylock (pthread_spinlock_t * lock); 822062c5bc4SJason Schmidlapp 823062c5bc4SJason Schmidlapp int pthread_spin_unlock (pthread_spinlock_t * lock); 824062c5bc4SJason Schmidlapp 825062c5bc4SJason Schmidlapp /* 826062c5bc4SJason Schmidlapp * Barrier Functions 827062c5bc4SJason Schmidlapp */ 828062c5bc4SJason Schmidlapp int pthread_barrier_init (pthread_barrier_t * barrier, 829062c5bc4SJason Schmidlapp const pthread_barrierattr_t * attr, 830062c5bc4SJason Schmidlapp unsigned int count); 831062c5bc4SJason Schmidlapp 832062c5bc4SJason Schmidlapp int pthread_barrier_destroy (pthread_barrier_t * barrier); 833062c5bc4SJason Schmidlapp 834062c5bc4SJason Schmidlapp int pthread_barrier_wait (pthread_barrier_t * barrier); 835062c5bc4SJason Schmidlapp 836062c5bc4SJason Schmidlapp /* 837062c5bc4SJason Schmidlapp * Condition Variable Attribute Functions 838062c5bc4SJason Schmidlapp */ 839062c5bc4SJason Schmidlapp int pthread_condattr_init (pthread_condattr_t * attr); 840062c5bc4SJason Schmidlapp 841062c5bc4SJason Schmidlapp int pthread_condattr_destroy (pthread_condattr_t * attr); 842062c5bc4SJason Schmidlapp 843062c5bc4SJason Schmidlapp int pthread_condattr_getpshared (const pthread_condattr_t * attr, 844062c5bc4SJason Schmidlapp int *pshared); 845062c5bc4SJason Schmidlapp 846062c5bc4SJason Schmidlapp int pthread_condattr_setpshared (pthread_condattr_t * attr, 847062c5bc4SJason Schmidlapp int pshared); 848062c5bc4SJason Schmidlapp 849*7af8bdd5SJeremy Soller int pthread_condattr_getclock (const pthread_condattr_t * attr, 850*7af8bdd5SJeremy Soller clockid_t *clock_id); 851*7af8bdd5SJeremy Soller 852*7af8bdd5SJeremy Soller int pthread_condattr_setclock (pthread_condattr_t * attr, 853*7af8bdd5SJeremy Soller clockid_t clock_id); 854*7af8bdd5SJeremy Soller 855062c5bc4SJason Schmidlapp /* 856062c5bc4SJason Schmidlapp * Condition Variable Functions 857062c5bc4SJason Schmidlapp */ 858062c5bc4SJason Schmidlapp int pthread_cond_init (pthread_cond_t * cond, 859062c5bc4SJason Schmidlapp const pthread_condattr_t * attr); 860062c5bc4SJason Schmidlapp 861062c5bc4SJason Schmidlapp int pthread_cond_destroy (pthread_cond_t * cond); 862062c5bc4SJason Schmidlapp 863062c5bc4SJason Schmidlapp int pthread_cond_wait (pthread_cond_t * cond, 864062c5bc4SJason Schmidlapp pthread_mutex_t * mutex); 865062c5bc4SJason Schmidlapp 866062c5bc4SJason Schmidlapp int pthread_cond_timedwait (pthread_cond_t * cond, 867062c5bc4SJason Schmidlapp pthread_mutex_t * mutex, 868062c5bc4SJason Schmidlapp const struct timespec *abstime); 869062c5bc4SJason Schmidlapp 870062c5bc4SJason Schmidlapp int pthread_cond_signal (pthread_cond_t * cond); 871062c5bc4SJason Schmidlapp 872062c5bc4SJason Schmidlapp int pthread_cond_broadcast (pthread_cond_t * cond); 873062c5bc4SJason Schmidlapp 874062c5bc4SJason Schmidlapp /* 875062c5bc4SJason Schmidlapp * Scheduling 876062c5bc4SJason Schmidlapp */ 877062c5bc4SJason Schmidlapp int pthread_setschedparam (pthread_t thread, 878062c5bc4SJason Schmidlapp int policy, 879062c5bc4SJason Schmidlapp const struct sched_param *param); 880062c5bc4SJason Schmidlapp 881062c5bc4SJason Schmidlapp int pthread_getschedparam (pthread_t thread, 882062c5bc4SJason Schmidlapp int *policy, 883062c5bc4SJason Schmidlapp struct sched_param *param); 884062c5bc4SJason Schmidlapp 885062c5bc4SJason Schmidlapp int pthread_setconcurrency (int); 886062c5bc4SJason Schmidlapp 887062c5bc4SJason Schmidlapp int pthread_getconcurrency (void); 888062c5bc4SJason Schmidlapp 889062c5bc4SJason Schmidlapp /* 890062c5bc4SJason Schmidlapp * Read-Write Lock Functions 891062c5bc4SJason Schmidlapp */ 892062c5bc4SJason Schmidlapp int pthread_rwlock_init(pthread_rwlock_t *lock, 893062c5bc4SJason Schmidlapp const pthread_rwlockattr_t *attr); 894062c5bc4SJason Schmidlapp 895062c5bc4SJason Schmidlapp int pthread_rwlock_destroy(pthread_rwlock_t *lock); 896062c5bc4SJason Schmidlapp 897062c5bc4SJason Schmidlapp int pthread_rwlock_tryrdlock(pthread_rwlock_t *); 898062c5bc4SJason Schmidlapp 899062c5bc4SJason Schmidlapp int pthread_rwlock_trywrlock(pthread_rwlock_t *); 900062c5bc4SJason Schmidlapp 901062c5bc4SJason Schmidlapp int pthread_rwlock_rdlock(pthread_rwlock_t *lock); 902062c5bc4SJason Schmidlapp 903062c5bc4SJason Schmidlapp int pthread_rwlock_timedrdlock(pthread_rwlock_t *lock, 904062c5bc4SJason Schmidlapp const struct timespec *abstime); 905062c5bc4SJason Schmidlapp 906062c5bc4SJason Schmidlapp int pthread_rwlock_wrlock(pthread_rwlock_t *lock); 907062c5bc4SJason Schmidlapp 908062c5bc4SJason Schmidlapp int pthread_rwlock_timedwrlock(pthread_rwlock_t *lock, 909062c5bc4SJason Schmidlapp const struct timespec *abstime); 910062c5bc4SJason Schmidlapp 911062c5bc4SJason Schmidlapp int pthread_rwlock_unlock(pthread_rwlock_t *lock); 912062c5bc4SJason Schmidlapp 913062c5bc4SJason Schmidlapp int pthread_rwlockattr_init (pthread_rwlockattr_t * attr); 914062c5bc4SJason Schmidlapp 915062c5bc4SJason Schmidlapp int pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr); 916062c5bc4SJason Schmidlapp 917062c5bc4SJason Schmidlapp int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr, 918062c5bc4SJason Schmidlapp int *pshared); 919062c5bc4SJason Schmidlapp 920062c5bc4SJason Schmidlapp int pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr, 921062c5bc4SJason Schmidlapp int pshared); 922062c5bc4SJason Schmidlapp 923062c5bc4SJason Schmidlapp #if PTE_LEVEL >= PTE_LEVEL_MAX - 1 924062c5bc4SJason Schmidlapp 925062c5bc4SJason Schmidlapp /* 926062c5bc4SJason Schmidlapp * Signal Functions. Should be defined in <signal.h> but we might 927062c5bc4SJason Schmidlapp * already have signal.h that don't define these. 928062c5bc4SJason Schmidlapp */ 929062c5bc4SJason Schmidlapp int pthread_kill(pthread_t thread, int sig); 930062c5bc4SJason Schmidlapp 931062c5bc4SJason Schmidlapp /* 932062c5bc4SJason Schmidlapp * Non-portable functions 933062c5bc4SJason Schmidlapp */ 934062c5bc4SJason Schmidlapp 935062c5bc4SJason Schmidlapp /* 936062c5bc4SJason Schmidlapp * Compatibility with Linux. 937062c5bc4SJason Schmidlapp */ 938062c5bc4SJason Schmidlapp int pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr, 939062c5bc4SJason Schmidlapp int kind); 940062c5bc4SJason Schmidlapp int pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr, 941062c5bc4SJason Schmidlapp int *kind); 942062c5bc4SJason Schmidlapp 943062c5bc4SJason Schmidlapp /* 944062c5bc4SJason Schmidlapp * Possibly supported by other POSIX threads implementations 945062c5bc4SJason Schmidlapp */ 946062c5bc4SJason Schmidlapp int pthread_delay_np (struct timespec * interval); 947062c5bc4SJason Schmidlapp int pthread_num_processors_np(void); 948062c5bc4SJason Schmidlapp 949062c5bc4SJason Schmidlapp /* 950062c5bc4SJason Schmidlapp * Register a system time change with the library. 951062c5bc4SJason Schmidlapp * Causes the library to perform various functions 952062c5bc4SJason Schmidlapp * in response to the change. Should be called whenever 953062c5bc4SJason Schmidlapp * the application's top level window receives a 954062c5bc4SJason Schmidlapp * WM_TIMECHANGE message. It can be passed directly to 955062c5bc4SJason Schmidlapp * pthread_create() as a new thread if desired. 956062c5bc4SJason Schmidlapp */ 957062c5bc4SJason Schmidlapp void * pthread_timechange_handler_np(void *); 958062c5bc4SJason Schmidlapp 959062c5bc4SJason Schmidlapp #endif /*PTE_LEVEL >= PTE_LEVEL_MAX - 1 */ 960062c5bc4SJason Schmidlapp 961747ec726SJason Schmidlapp #ifdef __cplusplus 962747ec726SJason Schmidlapp } 963747ec726SJason Schmidlapp #endif /* cplusplus */ 964747ec726SJason Schmidlapp 965062c5bc4SJason Schmidlapp #if PTE_LEVEL >= PTE_LEVEL_MAX 966062c5bc4SJason Schmidlapp 967062c5bc4SJason Schmidlapp 968062c5bc4SJason Schmidlapp 969062c5bc4SJason Schmidlapp #endif /* PTE_LEVEL >= PTE_LEVEL_MAX */ 970062c5bc4SJason Schmidlapp 971062c5bc4SJason Schmidlapp /* 972062c5bc4SJason Schmidlapp * Some compiler environments don't define some things. 973062c5bc4SJason Schmidlapp */ 974062c5bc4SJason Schmidlapp # define _ftime ftime 975062c5bc4SJason Schmidlapp # define _timeb timeb 976062c5bc4SJason Schmidlapp 977062c5bc4SJason Schmidlapp #ifdef __cplusplus 978062c5bc4SJason Schmidlapp 979062c5bc4SJason Schmidlapp /* 980062c5bc4SJason Schmidlapp * Internal exceptions 981062c5bc4SJason Schmidlapp */ 982062c5bc4SJason Schmidlapp class pte_exception {}; 983062c5bc4SJason Schmidlapp class pte_exception_cancel : public pte_exception {}; 984062c5bc4SJason Schmidlapp class pte_exception_exit : public pte_exception {}; 985062c5bc4SJason Schmidlapp 986062c5bc4SJason Schmidlapp #endif 987062c5bc4SJason Schmidlapp 988062c5bc4SJason Schmidlapp 989714af18cSJason Schmidlapp #ifdef PTE_CXX_EXCEPTIONS 990062c5bc4SJason Schmidlapp 991062c5bc4SJason Schmidlapp /* 992062c5bc4SJason Schmidlapp * Redefine the C++ catch keyword to ensure that applications 993062c5bc4SJason Schmidlapp * propagate our internal exceptions up to the library's internal handlers. 994062c5bc4SJason Schmidlapp */ 995062c5bc4SJason Schmidlapp #define catch( E ) \ 996062c5bc4SJason Schmidlapp catch( pte_exception & ) { throw; } \ 997062c5bc4SJason Schmidlapp catch( E ) 998062c5bc4SJason Schmidlapp 999714af18cSJason Schmidlapp #endif /* ! PTE_CXX_EXCEPTIONS */ 1000062c5bc4SJason Schmidlapp 1001062c5bc4SJason Schmidlapp #undef PTE_LEVEL 1002062c5bc4SJason Schmidlapp #undef PTE_LEVEL_MAX 1003062c5bc4SJason Schmidlapp 1004062c5bc4SJason Schmidlapp #endif /* PTHREAD_H */ 1005