pthread.h

GNU Hurd 源代码

/* Copyright (C) 2000, 2002, 2005 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/*
 *	POSIX Threads Extension: ???			<pthread.h>
 */

#ifndef _PTHREAD_H
#define _PTHREAD_H	1

#include <features.h>

#include <sched.h>
#include <time.h>

__BEGIN_DECLS

#include <bits/pthread.h>

/* Possible values for the process shared attribute.  */
enum __pthread_process_shared
  {
    PTHREAD_PROCESS_PRIVATE = 0,
#define PTHREAD_PROCESS_PRIVATE 0
    PTHREAD_PROCESS_SHARED
#define PTHREAD_PROCESS_SHARED 1
  };


/* Thread attributes.  */

/* Possible values for the inheritsched attribute.  */
enum __pthread_inheritsched
  {
    PTHREAD_EXPLICIT_SCHED = 0,
#define PTHREAD_EXPLICIT_SCHED 0
    PTHREAD_INHERIT_SCHED
#define PTHREAD_INHERIT_SCHED 1
  };

/* Possible values for the `contentionscope' attribute.  */
enum __pthread_contentionscope
  {
    PTHREAD_SCOPE_SYSTEM = 0,
#define PTHREAD_SCOPE_SYSTEM 0
    PTHREAD_SCOPE_PROCESS,
#define PTHREAD_SCOPE_PROCESS 1
  };

/* Possible values for the `detachstate' attribute.  */
enum __pthread_detachstate
  {
    PTHREAD_CREATE_JOINABLE = 0,
#define PTHREAD_CREATE_JOINABLE 0
    PTHREAD_CREATE_DETACHED
#define PTHREAD_CREATE_DETACHED 1
  };

#include <bits/thread-attr.h>

typedef struct __pthread_attr pthread_attr_t;

/* Initialize the thread attribute object in *ATTR to the default
   values.  */
extern int pthread_attr_init (pthread_attr_t *attr);

/* Destroy the thread attribute object in *ATTR.  */
extern int pthread_attr_destroy (pthread_attr_t *attr);


/* Return the value of the inheritsched attribute in *ATTR in
   *INHERITSCHED.  */
extern int pthread_attr_getinheritsched (const pthread_attr_t *attr,
					 int *inheritsched);

/* Set the value of the inheritsched attribute in *ATTR to
   INHERITSCHED.  */
extern int pthread_attr_setinheritsched (pthread_attr_t *attr,
					 int inheritsched);


/* Return the value of the schedparam attribute in *ATTR in *PARAM.  */
extern int pthread_attr_getschedparam (const pthread_attr_t *attr,
				       struct sched_param *param);

/* Set the value of the schedparam attribute in *ATTR to PARAM.  */
extern int pthread_attr_setschedparam (pthread_attr_t *attr,
				       const struct sched_param *param);


/* Return the value of the schedpolicy attribute in *ATTR to *POLICY.  */
extern int pthread_attr_getschedpolicy (const pthread_attr_t *attr,
					int *policy);

/* Set the value of the schedpolicy attribute in *ATTR to POLICY.  */
extern int pthread_attr_setschedpolicy (pthread_attr_t *attr,
					int policy);


/* Return the value of the contentionscope attribute in *ATTR in
   *CONTENTIONSCOPE.  */
extern int pthread_attr_getscope (const pthread_attr_t *attr,
				  int *contentionscope);

/* Set the value of the contentionscope attribute in *ATTR to
   CONTENTIONSCOPE.  */
extern int pthread_attr_setscope (pthread_attr_t *attr,
				  int contentionscope);


/* Return the value of the stackaddr attribute in *ATTR in
   *STACKADDR.  */
extern int pthread_attr_getstackaddr (const pthread_attr_t *attr,
				      void **stackaddr);

/* Set the value of the stackaddr attribute in *ATTR to STACKADDR.  */
extern int pthread_attr_setstackaddr (pthread_attr_t *attr,
				      void *stackaddr);


/* Return the value of the stackaddr and stacksize attributes in *ATTR
   in *STACKADDR and *STACKSIZE respectively.  */
extern int pthread_attr_getstack (const pthread_attr_t *attr,
				  void **stackaddr,
				  size_t *stacksize);

/* Set the value of the stackaddr and stacksize attributes in *ATTR to
   STACKADDR and STACKSIZE respectively.  */
extern int pthread_attr_setstack (pthread_attr_t *attr,
				  void *stackaddr,
				  size_t stacksize);


/* Return the value of the detachstate attribute in *ATTR in
   *DETACHSTATE.  */
extern int pthread_attr_getdetachstate (const pthread_attr_t *attr,
					int *detachstate);

/* Set the value of the detachstate attribute in *ATTR to
   DETACHSTATE.  */
extern int pthread_attr_setdetachstate (pthread_attr_t *attr,
					int detachstate);


/* Return the value of the guardsize attribute in *ATTR in
   *GUARDSIZE.  */
extern int pthread_attr_getguardsize (const pthread_attr_t *attr,
				      size_t *guardsize);

/* Set the value of the guardsize attribute in *ATTR to GUARDSIZE.  */
extern int pthread_attr_setguardsize (pthread_attr_t *attr,
				      size_t guardsize);


/* Return the value of the stacksize attribute in *ATTR in
   *STACKSIZE.  */
extern int pthread_attr_getstacksize (const pthread_attr_t *attr,
				      size_t *stacksize);

/* Set the value of the stacksize attribute in *ATTR to STACKSIZE.  */
extern int pthread_attr_setstacksize (pthread_attr_t *attr,
				      size_t stacksize);


/* Create a thread with attributes given by ATTR, executing
   START_ROUTINE with argument ARG.  */
extern int pthread_create (pthread_t *__threadp,
			   __const pthread_attr_t *__attr,
			   void *(*__start_routine)(void *), void *__arg);

/* Terminate the current thread and make STATUS available to any
   thread that might join us.  */
extern void pthread_exit (void *__status) __attribute__ ((noreturn));

/* Make calling thread wait for termination of thread THREAD.  Return
   the exit status of the thread in *STATUS.  */
extern int pthread_join (pthread_t __threadp, void **__status);

/* Indicate that the storage for THREAD can be reclaimed when it
   terminates.  */
extern int pthread_detach (pthread_t __threadp);

/* Compare thread IDs T1 and T2.  Return nonzero if they are equal, 0
   if they are not.  */
extern int pthread_equal (pthread_t __t1, pthread_t __t2);

/* Return the thread ID of the calling thread.  */
extern pthread_t pthread_self (void);


/* Mutex attributes.  */

enum __pthread_mutex_protocol
  {
    PTHREAD_PRIO_NONE = 0,
#define PTHREAD_PRIO_NONE 0
    PTHREAD_PRIO_INHERIT,
#define PTHREAD_PRIO_INHERIT 1
    PTHREAD_PRIO_PROTECT
#define PTHREAD_PRIO_PROTECT 2
  };

enum __pthread_mutex_type
  {
    PTHREAD_MUTEX_NORMAL = 0,
#define PTHREAD_MUTEX_NORMAL 0
#define PTHREAD_MUTEX_DEFAULT 0
    PTHREAD_MUTEX_ERRORCHECK,
#define PTHREAD_MUTEX_ERRORCHECK 1
    PTHREAD_MUTEX_RECURSIVE,
#define PTHREAD_MUTEX_RECURSIVE 2
  };

#include <bits/mutex-attr.h>

typedef struct __pthread_mutexattr pthread_mutexattr_t;

/* Initialize the mutex attribute object in *ATTR to the default
   values.  */
extern int pthread_mutexattr_init(pthread_mutexattr_t *attr);

/* Destroy the mutex attribute structure in *ATTR.  */
extern int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);


/* Return the value of the prioceiling attribute in *ATTR in
   *PRIOCEILING.  */
extern int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr,
					    int *prioceiling);

/* Set the value of the prioceiling attribute in *ATTR to
   PRIOCEILING.  */
extern int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr,
					    int prioceiling);


/* Return the value of the protocol attribute in *ATTR in
   *PROTOCOL.  */
extern int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr,
					 int *protocol);

/* Set the value of the protocol attribute in *ATTR to PROTOCOL.  */
extern int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr,
					 int protocol);


/* Return the value of the process shared attribute in *ATTR in
   *PSHARED.  */
extern int pthread_mutexattr_getpshared(const pthread_mutexattr_t *attr,
					int *pshared);

/* Set the value of the process shared attribute in *ATTR to
   PSHARED.  */
extern int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
					int pshared);


/* Return the value of the type attribute in *ATTR in *TYPE.  */
extern int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr,
				     int *type);

/* Set the value of the type attribute in *ATTR to TYPE.  */
extern int pthread_mutexattr_settype(pthread_mutexattr_t *attr,
				     int type);


/* Mutexes.  */

#include <bits/mutex.h>

typedef struct __pthread_mutex pthread_mutex_t;

#define PTHREAD_MUTEX_INITIALIZER __PTHREAD_MUTEX_INITIALIZER

/* Create a mutex with attributes given by ATTR and store it in
   *__MUTEX.  */
extern int pthread_mutex_init (struct __pthread_mutex *__mutex,
			       const pthread_mutexattr_t *attr);

/* Destroy the mutex __MUTEX.  */
extern int pthread_mutex_destroy (struct __pthread_mutex *__mutex);

/* Wait until lock for MUTEX becomes available and lock it.  */
extern int pthread_mutex_lock (pthread_mutex_t *__mutex);

/* Try to lock MUTEX.  */
extern int pthread_mutex_trylock (pthread_mutex_t *__mutex);

/* Try to lock MUTEX, block until *ABSTIME if it is already held.  */
extern int pthread_mutex_timedlock (struct __pthread_mutex *mutex,
				    const struct timespec *abstime);

/* Unlock MUTEX.  */
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex);


/* Return the priority ceiling of mutex *MUTEX in *PRIOCEILING.  */
extern int pthread_mutex_getprioceiling (const pthread_mutex_t *mutex,
					 int *prioceiling);

/* After acquiring the mutex *MUTEX, set its priority ceiling to PRIO
   and return the old priority ceiling in *OLDPRIO.  Before returning,
   release the mutex.  */
extern int pthread_mutex_setprioceiling (pthread_mutex_t *mutex, int prio,
					 int *oldprio);



/* Condition attributes.  */

#include <bits/condition-attr.h>

typedef struct __pthread_condattr pthread_condattr_t;

/* Initialize the condition attribute in *ATTR to the default
   values.  */
extern int pthread_condattr_init (pthread_condattr_t *attr);

/* Destroy the condition attribute structure in *ATTR.  */
extern int pthread_condattr_destroy (pthread_condattr_t *attr);


/* Return the value of the clock attribute in *ATTR in *CLOCK_ID.  */
extern int pthread_condattr_getclock (const pthread_condattr_t *attr,
				      clockid_t *clock_id);

/* Set the value of the clock attribute in *ATTR to CLOCK_ID.  */
extern int pthread_condattr_setclock (pthread_condattr_t *attr,
				      clockid_t clock_id);


/* Return the value of the process shared attribute in *ATTR in