diff --git a/newlib/ChangeLog b/newlib/ChangeLog index b72120c68..0f882ffa2 100644 --- a/newlib/ChangeLog +++ b/newlib/ChangeLog @@ -1,3 +1,14 @@ +2006-09-13 Joel Sherrill + + * libc/include/pthread.h: Add pthread barriers, + rwlocks, and spinlocks. Change const to + _CONST and prefix parameter names with + an underscore. + * libc/include/sys/types.h: Add id and attribute + types for barriers, wrlocks, and spinlocks. + * libc/include/sys/features.h: Enable barriers, + wrlocks, and spinlocks for RTEMS. + 2006-09-13 Patrick Mansfield * libc/include/math.h: Remove _CONST from _LIB_VERSION, as it is diff --git a/newlib/libc/include/pthread.h b/newlib/libc/include/pthread.h index 05ff38b11..1dc20bcc8 100644 --- a/newlib/libc/include/pthread.h +++ b/newlib/libc/include/pthread.h @@ -50,18 +50,18 @@ extern "C" { /* Mutex Initialization Attributes, P1003.1c/Draft 10, p. 81 */ -int _EXFUN(pthread_mutexattr_init, (pthread_mutexattr_t *attr)); -int _EXFUN(pthread_mutexattr_destroy, (pthread_mutexattr_t *attr)); +int _EXFUN(pthread_mutexattr_init, (pthread_mutexattr_t *__attr)); +int _EXFUN(pthread_mutexattr_destroy, (pthread_mutexattr_t *__attr)); int _EXFUN(pthread_mutexattr_getpshared, - (const pthread_mutexattr_t *attr, int *pshared)); + (_CONST pthread_mutexattr_t *__attr, int *__pshared)); int _EXFUN(pthread_mutexattr_setpshared, - (pthread_mutexattr_t *attr, int pshared)); + (pthread_mutexattr_t *__attr, int __pshared)); /* Initializing and Destroying a Mutex, P1003.1c/Draft 10, p. 87 */ int _EXFUN(pthread_mutex_init, - (pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)); -int _EXFUN(pthread_mutex_destroy, (pthread_mutex_t *mutex)); + (pthread_mutex_t *__mutex, _CONST pthread_mutexattr_t *__attr)); +int _EXFUN(pthread_mutex_destroy, (pthread_mutex_t *__mutex)); /* This is used to statically initialize a pthread_mutex_t. Example: @@ -73,31 +73,31 @@ int _EXFUN(pthread_mutex_destroy, (pthread_mutex_t *mutex)); /* Locking and Unlocking a Mutex, P1003.1c/Draft 10, p. 93 NOTE: P1003.4b/D8 adds pthread_mutex_timedlock(), p. 29 */ -int _EXFUN(pthread_mutex_lock, (pthread_mutex_t *mutex)); -int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *mutex)); -int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *mutex)); +int _EXFUN(pthread_mutex_lock, (pthread_mutex_t *__mutex)); +int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex)); +int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex)); #if defined(_POSIX_TIMEOUTS) int _EXFUN(pthread_mutex_timedlock, - (pthread_mutex_t *mutex, const struct timespec *timeout)); + (pthread_mutex_t *__mutex, _CONST struct timespec *__timeout)); #endif /* _POSIX_TIMEOUTS */ /* Condition Variable Initialization Attributes, P1003.1c/Draft 10, p. 96 */ -int _EXFUN(pthread_condattr_init, (pthread_condattr_t *attr)); -int _EXFUN(pthread_condattr_destroy, (pthread_condattr_t *attr)); +int _EXFUN(pthread_condattr_init, (pthread_condattr_t *__attr)); +int _EXFUN(pthread_condattr_destroy, (pthread_condattr_t *__attr)); int _EXFUN(pthread_condattr_getpshared, - (const pthread_condattr_t *attr, int *pshared)); + (_CONST pthread_condattr_t *__attr, int *__pshared)); int _EXFUN(pthread_condattr_setpshared, - (pthread_condattr_t *attr, int pshared)); + (pthread_condattr_t *__attr, int __pshared)); /* Initializing and Destroying a Condition Variable, P1003.1c/Draft 10, p. 87 */ int _EXFUN(pthread_cond_init, - (pthread_cond_t *cond, const pthread_condattr_t *attr)); -int _EXFUN(pthread_cond_destroy, (pthread_cond_t *mutex)); + (pthread_cond_t *__cond, _CONST pthread_condattr_t *__attr)); +int _EXFUN(pthread_cond_destroy, (pthread_cond_t *__mutex)); /* This is used to statically initialize a pthread_cond_t. Example: @@ -108,49 +108,50 @@ int _EXFUN(pthread_cond_destroy, (pthread_cond_t *mutex)); /* Broadcasting and Signaling a Condition, P1003.1c/Draft 10, p. 101 */ -int _EXFUN(pthread_cond_signal, (pthread_cond_t *cond)); -int _EXFUN(pthread_cond_broadcast, (pthread_cond_t *cond)); +int _EXFUN(pthread_cond_signal, (pthread_cond_t *__cond)); +int _EXFUN(pthread_cond_broadcast, (pthread_cond_t *__cond)); /* Waiting on a Condition, P1003.1c/Draft 10, p. 105 */ int _EXFUN(pthread_cond_wait, - (pthread_cond_t *cond, pthread_mutex_t *mutex)); + (pthread_cond_t *__cond, pthread_mutex_t *__mutex)); int _EXFUN(pthread_cond_timedwait, - (pthread_cond_t *cond, pthread_mutex_t *mutex, - const struct timespec *abstime)); + (pthread_cond_t *__cond, pthread_mutex_t *__mutex, + _CONST struct timespec *__abstime)); #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) /* Thread Creation Scheduling Attributes, P1003.1c/Draft 10, p. 120 */ int _EXFUN(pthread_attr_setscope, - (pthread_attr_t *attr, int contentionscope)); + (pthread_attr_t *__attr, int __contentionscope)); int _EXFUN(pthread_attr_getscope, - (const pthread_attr_t *attr, int *contentionscope)); + (_CONST pthread_attr_t *__attr, int *__contentionscope)); int _EXFUN(pthread_attr_setinheritsched, - (pthread_attr_t *attr, int inheritsched)); + (pthread_attr_t *__attr, int __inheritsched)); int _EXFUN(pthread_attr_getinheritsched, - (const pthread_attr_t *attr, int *inheritsched)); -int _EXFUN(pthread_attr_setschedpolicy, (pthread_attr_t *attr, int policy)); + (_CONST pthread_attr_t *__attr, int *__inheritsched)); +int _EXFUN(pthread_attr_setschedpolicy, + (pthread_attr_t *__attr, int __policy)); int _EXFUN(pthread_attr_getschedpolicy, - (const pthread_attr_t *attr, int *policy)); + (_CONST pthread_attr_t *__attr, int *__policy)); #endif /* defined(_POSIX_THREAD_PRIORITY_SCHEDULING) */ int _EXFUN(pthread_attr_setschedparam, - (pthread_attr_t *attr, const struct sched_param *param)); + (pthread_attr_t *__attr, _CONST struct sched_param *__param)); int _EXFUN(pthread_attr_getschedparam, - (const pthread_attr_t *attr, struct sched_param *param)); + (_CONST pthread_attr_t *__attr, struct sched_param *__param)); #if defined(_POSIX_THREAD_PRIORITY_SCHEDULING) /* Dynamic Thread Scheduling Parameters Access, P1003.1c/Draft 10, p. 124 */ int _EXFUN(pthread_getschedparam, - (pthread_t thread, int *policy, struct sched_param *param)); + (pthread_t __pthread, int *__policy, struct sched_param *__param)); int _EXFUN(pthread_setschedparam, - (pthread_t thread, int policy, struct sched_param *param)); + (pthread_t __pthread, int __policy, struct sched_param *__param)); #endif /* defined(_POSIX_THREAD_PRIORITY_SCHEDULING) */ @@ -159,13 +160,13 @@ int _EXFUN(pthread_setschedparam, /* Mutex Initialization Scheduling Attributes, P1003.1c/Draft 10, p. 128 */ int _EXFUN(pthread_mutexattr_setprotocol, - (pthread_mutexattr_t *attr, int protocol)); + (pthread_mutexattr_t *__attr, int __protocol)); int _EXFUN(pthread_mutexattr_getprotocol, - (const pthread_mutexattr_t *attr, int *protocol)); + (_CONST pthread_mutexattr_t *__attr, int *__protocol)); int _EXFUN(pthread_mutexattr_setprioceiling, - (pthread_mutexattr_t *attr, int prioceiling)); + (pthread_mutexattr_t *__attr, int __prioceiling)); int _EXFUN(pthread_mutexattr_getprioceiling, - (const pthread_mutexattr_t *attr, int *prioceiling)); + (_CONST pthread_mutexattr_t *__attr, int *__prioceiling)); #endif /* _POSIX_THREAD_PRIO_INHERIT || _POSIX_THREAD_PRIO_PROTECT */ @@ -174,46 +175,46 @@ int _EXFUN(pthread_mutexattr_getprioceiling, /* Change the Priority Ceiling of a Mutex, P1003.1c/Draft 10, p. 131 */ int _EXFUN(pthread_mutex_setprioceiling, - (pthread_mutex_t *mutex, int prioceiling, int *old_ceiling)); + (pthread_mutex_t *__mutex, int __prioceiling, int *__old_ceiling)); int _EXFUN(pthread_mutex_getprioceiling, - (pthread_mutex_t *mutex, int *prioceiling)); + (pthread_mutex_t *__mutex, int *__prioceiling)); #endif /* _POSIX_THREAD_PRIO_PROTECT */ /* Thread Creation Attributes, P1003.1c/Draft 10, p, 140 */ -int _EXFUN(pthread_attr_init, (pthread_attr_t *attr)); -int _EXFUN(pthread_attr_destroy, (pthread_attr_t *attr)); +int _EXFUN(pthread_attr_init, (pthread_attr_t *__attr)); +int _EXFUN(pthread_attr_destroy, (pthread_attr_t *__attr)); int _EXFUN(pthread_attr_getstacksize, - (const pthread_attr_t *attr, size_t *stacksize)); + (_CONST pthread_attr_t *__attr, size_t *__stacksize)); int _EXFUN(pthread_attr_setstacksize, - (pthread_attr_t *attr, size_t stacksize)); + (pthread_attr_t *__attr, size_t stacksize)); int _EXFUN(pthread_attr_getstackaddr, - (const pthread_attr_t *attr, void **stackaddr)); + (_CONST pthread_attr_t *__attr, void **__stackaddr)); int _EXFUN(pthread_attr_setstackaddr, - (pthread_attr_t *attr, void *stackaddr)); + (pthread_attr_t *__attr, void *__stackaddr)); int _EXFUN(pthread_attr_getdetachstate, - (const pthread_attr_t *attr, int *detachstate)); + (_CONST pthread_attr_t *__attr, int *__detachstate)); int _EXFUN(pthread_attr_setdetachstate, - (pthread_attr_t *attr, int detachstate)); + (pthread_attr_t *__attr, int __detachstate)); /* Thread Creation, P1003.1c/Draft 10, p. 144 */ int _EXFUN(pthread_create, - (pthread_t *thread, const pthread_attr_t *attr, - void *(*start_routine)( void * ), void *arg)); + (pthread_t *__pthread, _CONST pthread_attr_t *__attr, + void *(*__start_routine)( void * ), void *__arg)); /* Wait for Thread Termination, P1003.1c/Draft 10, p. 147 */ -int _EXFUN(pthread_join, (pthread_t thread, void **value_ptr)); +int _EXFUN(pthread_join, (pthread_t __pthread, void **__value_ptr)); /* Detaching a Thread, P1003.1c/Draft 10, p. 149 */ -int _EXFUN(pthread_detach, (pthread_t thread)); +int _EXFUN(pthread_detach, (pthread_t __pthread)); /* Thread Termination, p1003.1c/Draft 10, p. 150 */ -void _EXFUN(pthread_exit, (void *value_ptr)); +void _EXFUN(pthread_exit, (void *__value_ptr)); /* Get Calling Thread's ID, p1003.1c/Draft 10, p. XXX */ @@ -221,7 +222,7 @@ pthread_t _EXFUN(pthread_self, (void)); /* Compare Thread IDs, p1003.1c/Draft 10, p. 153 */ -int _EXFUN(pthread_equal, (pthread_t t1, pthread_t t2)); +int _EXFUN(pthread_equal, (pthread_t __t1, pthread_t __t2)); /* Dynamic Package Initialization */ @@ -234,21 +235,22 @@ int _EXFUN(pthread_equal, (pthread_t t1, pthread_t t2)); #define PTHREAD_ONCE_INIT { 1, 0 } /* is initialized and not run */ int _EXFUN(pthread_once, - (pthread_once_t *once_control, void (*init_routine)(void))); + (pthread_once_t *__once_control, void (*__init_routine)(void))); /* Thread-Specific Data Key Create, P1003.1c/Draft 10, p. 163 */ int _EXFUN(pthread_key_create, - (pthread_key_t *key, void (*destructor)( void * ))); + (pthread_key_t *__key, void (*__destructor)( void * ))); /* Thread-Specific Data Management, P1003.1c/Draft 10, p. 165 */ -int _EXFUN(pthread_setspecific, (pthread_key_t key, const void *value)); -void * _EXFUN(pthread_getspecific, (pthread_key_t key)); +int _EXFUN(pthread_setspecific, + (pthread_key_t __key, _CONST void *__value)); +void * _EXFUN(pthread_getspecific, (pthread_key_t __key)); /* Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167 */ -int _EXFUN(pthread_key_delete, (pthread_key_t key)); +int _EXFUN(pthread_key_delete, (pthread_key_t __key)); /* Execution of a Thread, P1003.1c/Draft 10, p. 181 */ @@ -260,38 +262,94 @@ int _EXFUN(pthread_key_delete, (pthread_key_t key)); #define PTHREAD_CANCELED ((void *) -1) -int _EXFUN(pthread_cancel, (pthread_t thread)); +int _EXFUN(pthread_cancel, (pthread_t __pthread)); /* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ -int _EXFUN(pthread_setcancelstate, (int state, int *oldstate)); -int _EXFUN(pthread_setcanceltype, (int type, int *oldtype)); +int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate)); +int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype)); void _EXFUN(pthread_testcancel, (void)); /* Establishing Cancellation Handlers, P1003.1c/Draft 10, p. 184 */ -void _EXFUN(pthread_cleanup_push, (void (*routine)( void * ), void *arg)); -void _EXFUN(pthread_cleanup_pop, (int execute)); +void _EXFUN(pthread_cleanup_push, + (void (*__routine)( void * ), void *__arg)); +void _EXFUN(pthread_cleanup_pop, (int __execute)); #if defined(_POSIX_THREAD_CPUTIME) /* Accessing a Thread CPU-time Clock, P1003.4b/D8, p. 58 */ int _EXFUN(pthread_getcpuclockid, - (pthread_t thread_id, clockid_t *clock_id)); + (pthread_t __pthread_id, clockid_t *__clock_id)); /* CPU-time Clock Thread Creation Attribute, P1003.4b/D8, p. 59 */ int _EXFUN(pthread_attr_setcputime, - (pthread_attr_t *attr, int clock_allowed)); + (pthread_attr_t *__attr, int __clock_allowed)); int _EXFUN(pthread_attr_getcputime, - (pthread_attr_t *attr, int *clock_allowed)); + (pthread_attr_t *__attr, int *__clock_allowed)); #endif /* defined(_POSIX_THREAD_CPUTIME) */ + #endif /* defined(_POSIX_THREADS) */ +#if defined(_POSIX_BARRIERS) + +int _EXFUN(pthread_barrierattr_init, (pthread_barrierattr_t *__attr)); +int _EXFUN(pthread_barrierattr_destroy, (pthread_barrierattr_t *__attr)); +int _EXFUN(pthread_barrierattr_getpshared, + (_CONST pthread_barrierattr_t *__attr, int *__pshared)); +int _EXFUN(pthread_barrierattr_setpshared, + (pthread_barrierattr_t *__attr, int __pshared)); + +#define PTHREAD_BARRIER_SERIAL_THREAD -1 + +int _EXFUN(pthread_barrier_init, + (pthread_barrier_t *__barrier, + _CONST pthread_barrierattr_t *__attr, unsigned __count)); +int _EXFUN(pthread_barrier_destroy, (pthread_barrier_t *__barrier)); +int _EXFUN(pthread_barrier_wait,(pthread_barrier_t *__barrier)); + +#endif /* defined(_POSIX_BARRIERS) */ + +#if defined(_POSIX_SPIN_LOCKS) + +int _EXFUN(pthread_spin_init, + (pthread_spinlock_t *__spinlock, int __pshared)); +int _EXFUN(pthread_spin_destroy, (pthread_spinlock_t *__spinlock)); +int _EXFUN(pthread_spin_lock, (pthread_spinlock_t *__spinlock)); +int _EXFUN(pthread_spin_trylock, (pthread_spinlock_t *__spinlock)); +int _EXFUN(pthread_spin_unlock, (pthread_spinlock_t *__spinlock)); + +#endif /* defined(_POSIX_SPIN_LOCKS) */ + +#if defined(_POSIX_READER_WRITER_LOCKS) + +int _EXFUN(pthread_rwlockattr_init, (pthread_rwlockattr_t *__attr)); +int _EXFUN(pthread_rwlockattr_destroy, (pthread_rwlockattr_t *__attr)); +int _EXFUN(pthread_rwlockattr_getpshared, + (_CONST pthread_rwlockattr_t *__attr, int *__pshared)); +int _EXFUN(pthread_rwlockattr_setpshared, + (pthread_rwlockattr_t *__attr, int __pshared)); + +int _EXFUN(pthread_rwlock_init, + (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); +int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); +int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); +int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); +int _EXFUN(pthread_rwlock_timedrdlock, + (pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime)); +int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock)); +int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock)); +int _EXFUN(pthread_rwlock_timedwrlock, + (pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime)); + +#endif /* defined(_POSIX_READER_WRITER_LOCKS) */ + + #ifdef __cplusplus } #endif diff --git a/newlib/libc/include/sys/features.h b/newlib/libc/include/sys/features.h index 6754f1e9d..7dc948668 100644 --- a/newlib/libc/include/sys/features.h +++ b/newlib/libc/include/sys/features.h @@ -45,6 +45,9 @@ extern "C" { #define _POSIX_SHARED_MEMORY_OBJECTS 1 #define _POSIX_SYNCHRONIZED_IO 1 #define _POSIX_TIMERS 1 +#define _POSIX_BARRIERS 200112L +#define _POSIX_READER_WRITER_LOCKS 200112L +#define _POSIX_SPIN_LOCKS 200112L /* In P1003.1b but defined by drafts at least as early as P1003.1c/D10 */ diff --git a/newlib/libc/include/sys/types.h b/newlib/libc/include/sys/types.h index 70d919a46..c1bff4793 100644 --- a/newlib/libc/include/sys/types.h +++ b/newlib/libc/include/sys/types.h @@ -371,6 +371,36 @@ typedef struct { #endif #endif /* defined(_POSIX_THREADS) */ +/* POSIX Barrier Types */ + +#if defined(_POSIX_BARRIERS) +typedef __uint32_t pthread_barrier_t; /* POSIX Barrier Object */ +typedef struct { + int is_initialized; /* is this structure initialized? */ +#if defined(_POSIX_THREAD_PROCESS_SHARED) + int process_shared; /* allow this to be shared amongst processes */ +#endif +} pthread_barrierattr_t; +#endif /* defined(_POSIX_BARRIERS) */ + +/* POSIX Spin Lock Types */ + +#if defined(_POSIX_SPIN_LOCKS) +typedef __uint32_t pthread_spinlock_t; /* POSIX Spin Lock Object */ +#endif /* defined(_POSIX_SPIN_LOCKS) */ + +/* POSIX Reader/Writer Lock Types */ + +#if defined(_POSIX_READER_WRITER_LOCKS) +typedef __uint32_t pthread_rwlock_t; /* POSIX RWLock Object */ +typedef struct { + int is_initialized; /* is this structure initialized? */ +#if defined(_POSIX_THREAD_PROCESS_SHARED) + int process_shared; /* allow this to be shared amongst processes */ +#endif +} pthread_rwlockattr_t; +#endif /* defined(_POSIX_READER_WRITER_LOCKS) */ + #endif /* !__need_inttypes */ #undef __need_inttypes