Subversion Repositories or1k_old

/*  pthread.h

 *

 *  $Id: pthread.h,v 1.1 2000-09-26 13:17:04 joel Exp $

 */

#ifndef __PTHREAD_h

#define __PTHREAD_h

#ifdef __cplusplus

extern "C" {

#endif

#include <sys/features.h>

#if defined(_POSIX_THREADS)

#include <sys/types.h>

#include <time.h>

#include <sys/sched.h>

/*

 *  3.1.3 Register Fork Handlers, P1003.1c/Draft 10, P1003.1c/Draft 10, p. 27

 *

 *  RTEMS does not support processes, so we fall under this and do not

 *  provide this routine:

 *

 *  "Either the implementation shall support the pthread_atfork() function

 *   as described above or the pthread_atfork() funciton shall not be

 *   provided."

 */

/*

 *  11.3.1 Mutex Initialization Attributes, P1003.1c/Draft 10, p. 81

 */

int pthread_mutexattr_init(

  pthread_mutexattr_t *attr

);

int pthread_mutexattr_destroy(

  pthread_mutexattr_t *attr

);

int pthread_mutexattr_getpshared(

  const pthread_mutexattr_t *attr,

  int                       *pshared

);

int pthread_mutexattr_setpshared(

  pthread_mutexattr_t *attr,

  int                  pshared

);

/*

 *  11.3.2 Initializing and Destroying a Mutex, P1003.1c/Draft 10, p. 87

 */

int pthread_mutex_init(

  pthread_mutex_t           *mutex,

  const pthread_mutexattr_t *attr

);

int pthread_mutex_destroy(

  pthread_mutex_t           *mutex

);

/*

 *  This is used to statically initialize a pthread_mutex_t. Example:

 *

 *  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

 */

#define PTHREAD_MUTEX_INITIALIZER  ((pthread_mutex_t) 0xFFFFFFFF)

/*

 *  11.3.3 Locking and Unlocking a Mutex, P1003.1c/Draft 10, p. 93

 *

 *  NOTE: P1003.4b/D8 adds pthread_mutex_timedlock(), p. 29

 */

int pthread_mutex_lock(

  pthread_mutex_t           *mutex

);

int pthread_mutex_trylock(

  pthread_mutex_t           *mutex

);

int pthread_mutex_unlock(

  pthread_mutex_t           *mutex

);

#if defined(_POSIX_TIMEOUTS)

int pthread_mutex_timedlock(

  pthread_mutex_t       *mutex,

  const struct timespec *timeout

);

#endif /* _POSIX_TIMEOUTS */

/*

 *  11.4.1 Condition Variable Initialization Attributes,

 *            P1003.1c/Draft 10, p. 96

 */

int pthread_condattr_init(

  pthread_condattr_t *attr

);

int pthread_condattr_destroy(

  pthread_condattr_t *attr

);

int pthread_condattr_getpshared(

  const pthread_condattr_t *attr,

  int                      *pshared

);

int pthread_condattr_setpshared(

  pthread_condattr_t  *attr,

  int                  pshared

);

/*

 *  11.4.2 Initializing and Destroying a Condition Variable,

 *         P1003.1c/Draft 10, p. 87

 */

int pthread_cond_init(

  pthread_cond_t           *cond,

  const pthread_condattr_t *attr

);

int pthread_cond_destroy(

  pthread_cond_t           *mutex

);

/*

 *  This is used to statically initialize a pthread_cond_t. Example:

 *

 *  pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

 */

#define PTHREAD_COND_INITIALIZER  ((pthread_mutex_t) 0xFFFFFFFF)

/*

 *  11.4.3 Broadcasting and Signaling a Condition, P1003.1c/Draft 10, p. 101

 */

int pthread_cond_signal(

  pthread_cond_t   *cond

);

int pthread_cond_broadcast(

  pthread_cond_t   *cond

);

/*

 *  11.4.4 Waiting on a Condition, P1003.1c/Draft 10, p. 105

 */

int pthread_cond_wait(

  pthread_cond_t     *cond,

  pthread_mutex_t    *mutex

);

int pthread_cond_timedwait(

  pthread_cond_t        *cond,

  pthread_mutex_t       *mutex,

  const struct timespec *abstime

);

#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)

/*

 *  13.5.1 Thread Creation Scheduling Attributes, P1003.1c/Draft 10, p. 120

 */

int pthread_attr_setscope(

  pthread_attr_t  *attr,

  int              contentionscope

);

int pthread_attr_getscope(

  const pthread_attr_t  *attr,

  int                   *contentionscope

);

int pthread_attr_setinheritsched(

  pthread_attr_t  *attr,

  int              inheritsched

);

int pthread_attr_getinheritsched(

  const pthread_attr_t  *attr,

  int                   *inheritsched

);

int pthread_attr_setschedpolicy(

  pthread_attr_t  *attr,

  int              policy

);

int pthread_attr_getschedpolicy(

  const pthread_attr_t  *attr,

  int                   *policy

);

#endif /* defined(_POSIX_THREAD_PRIORITY_SCHEDULING) */

int pthread_attr_setschedparam(

  pthread_attr_t            *attr,

  const struct sched_param  *param

);

int pthread_attr_getschedparam(

  const pthread_attr_t  *attr,

  struct sched_param    *param

);

#if defined(_POSIX_THREAD_PRIORITY_SCHEDULING)

/*

 *  13.5.2 Dynamic Thread Scheduling Parameters Access,

 *         P1003.1c/Draft 10, p. 124

 */

int pthread_getschedparam(

  pthread_t           thread,

  int                *policy,

  struct sched_param *param

);

int pthread_setschedparam(

  pthread_t           thread,

  int                 policy,

  struct sched_param *param

);

#endif /* defined(_POSIX_THREAD_PRIORITY_SCHEDULING) */

#if defined(_POSIX_THREAD_PRIO_INHERIT) || defined(_POSIX_THREAD_PRIO_PROTECT)

/*

 *  13.6.1 Mutex Initialization Scheduling Attributes, P1003.1c/Draft 10, p. 128

 */

int pthread_mutexattr_setprotocol(

  pthread_mutexattr_t   *attr,

  int                    protocol

);

int pthread_mutexattr_getprotocol(

  const pthread_mutexattr_t   *attr,

  int                         *protocol

);

int pthread_mutexattr_setprioceiling(

  pthread_mutexattr_t   *attr,

  int                    prioceiling

);

int pthread_mutexattr_getprioceiling(

  const pthread_mutexattr_t   *attr,

  int                         *prioceiling

);

#endif /* _POSIX_THREAD_PRIO_INHERIT || _POSIX_THREAD_PRIO_PROTECT */

#if defined(_POSIX_THREAD_PRIO_PROTECT)

/*

 *  13.6.2 Change the Priority Ceiling of a Mutex, P1003.1c/Draft 10, p. 131

 */

int pthread_mutex_setprioceiling(

  pthread_mutex_t   *mutex,

  int                prioceiling,

  int               *old_ceiling

);

int pthread_mutex_getprioceiling(

  pthread_mutex_t   *mutex,

  int               *prioceiling

);

#endif /* _POSIX_THREAD_PRIO_PROTECT */

/*

 *  16.1.1 Thread Creation Attributes, P1003.1c/Draft 10, p, 140

 */

int pthread_attr_init(

  pthread_attr_t  *attr

);

int pthread_attr_destroy(

  pthread_attr_t  *attr

);

int pthread_attr_getstacksize(

  const pthread_attr_t  *attr,

  size_t                *stacksize

);

int pthread_attr_setstacksize(

  pthread_attr_t  *attr,

  size_t           stacksize

);

int pthread_attr_getstackaddr(

  const pthread_attr_t   *attr,

  void                  **stackaddr

);

int pthread_attr_setstackaddr(

  pthread_attr_t  *attr,

  void            *stackaddr

);

int pthread_attr_getdetachstate(

  const pthread_attr_t  *attr,

  int                   *detachstate

);

int pthread_attr_setdetachstate(

  pthread_attr_t  *attr,

  int              detachstate

);

/*

 *  16.1.2 Thread Creation, P1003.1c/Draft 10, p. 144

 */

int pthread_create(

  pthread_t              *thread,

  const pthread_attr_t   *attr,

  void                 *(*start_routine)( void * ),

  void                   *arg

);

/*

 *  16.1.3 Wait for Thread Termination, P1003.1c/Draft 10, p. 147

 */

int pthread_join(

  pthread_t   thread,

  void      **value_ptr

);

/*

 *  16.1.4 Detaching a Thread, P1003.1c/Draft 10, p. 149

 */

int pthread_detach(

  pthread_t   thread

);

/*

 * 16.1.5.1 Thread Termination, p1003.1c/Draft 10, p. 150

 */

void pthread_exit(

  void  *value_ptr

);

/*

 * 16.1.6 Get Calling Thread's ID, p1003.1c/Draft 10, p. XXX

 */

pthread_t pthread_self( void );

/*

 *  16.1.7 Compare Thread IDs, p1003.1c/Draft 10, p. 153

 */

int pthread_equal(

  pthread_t  t1,

  pthread_t  t2

);

/*

 *  16.1.8 Dynamic Package Initialization

 */

/*

 *  This is used to statically initialize a pthread_once_t. Example:

 *

 *  pthread_once_t once = PTHREAD_ONCE_INIT;

 *

 *  NOTE:  This is named inconsistently -- it should be INITIALIZER.

 */

#define PTHREAD_ONCE_INIT  { 1, 0 }  /* is initialized and not run */

int pthread_once(

  pthread_once_t  *once_control,

  void           (*init_routine)(void)

);

/*

 *  17.1.1 Thread-Specific Data Key Create, P1003.1c/Draft 10, p. 163

 */

int pthread_key_create(

  pthread_key_t  *key,

  void          (*destructor)( void * )

);

/*

 *  17.1.2 Thread-Specific Data Management, P1003.1c/Draft 10, p. 165

 */

int pthread_setspecific(

  pthread_key_t  key,

  const void    *value

);

void *pthread_getspecific(

  pthread_key_t  key

);

/*

 *  17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167

 */

int pthread_key_delete(

  pthread_key_t  key

);

/*

 *  18.2.1 Canceling Execution of a Thread, P1003.1c/Draft 10, p. 181

 */

#define PTHREAD_CANCEL_ENABLE  0

#define PTHREAD_CANCEL_DISABLE 1

#define PTHREAD_CANCEL_DEFERRED 0

#define PTHREAD_CANCEL_ASYNCHRONOUS 1

int pthread_cancel(

  pthread_t  thread

);

/*

 *  18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183

 */

int pthread_setcancelstate(

  int  state,

  int *oldstate

);

int pthread_setcanceltype(

  int  type,

  int *oldtype

);

void pthread_testcancel( void );

/*

 *  18.2.3.1 Establishing Cancellation Handlers, P1003.1c/Draft 10, p. 184

 */

void pthread_cleanup_push(

  void   (*routine)( void * ),

  void    *arg

);

void pthread_cleanup_pop(

  int    execute

);

#if defined(_POSIX_THREAD_CPUTIME)

/*

 *  20.1.6 Accessing a Thread CPU-time Clock, P1003.4b/D8, p. 58

 */

int pthread_getcpuclockid(

  pthread_t  thread_id,

  clockid_t *clock_id

);

/*

 *  20.1.7 CPU-time Clock Thread Creation Attribute, P1003.4b/D8, p. 59

 */

int pthread_attr_setcputime(

  pthread_attr_t  *attr,

  int              clock_allowed

);

int pthread_attr_getcputime(

  pthread_attr_t  *attr,

  int             *clock_allowed

);

#endif /* defined(_POSIX_THREAD_CPUTIME) */

#endif /* defined(_POSIX_THREADS) */

#ifdef __cplusplus

}

#endif

#endif

/* end of include file */