diff options
Diffstat (limited to 'linuxthreads/sysdeps/pthread')
| -rw-r--r-- | linuxthreads/sysdeps/pthread/Makefile | 3 | ||||
| -rw-r--r-- | linuxthreads/sysdeps/pthread/bits/libc-lock.h | 208 | ||||
| -rw-r--r-- | linuxthreads/sysdeps/pthread/bits/stdio-lock.h | 35 | ||||
| -rw-r--r-- | linuxthreads/sysdeps/pthread/cmpxchg/bits/semaphore.h | 26 | ||||
| -rw-r--r-- | linuxthreads/sysdeps/pthread/no-cmpxchg/bits/semaphore.h | 27 | ||||
| -rw-r--r-- | linuxthreads/sysdeps/pthread/pthread.h | 578 |
6 files changed, 877 insertions, 0 deletions
diff --git a/linuxthreads/sysdeps/pthread/Makefile b/linuxthreads/sysdeps/pthread/Makefile new file mode 100644 index 0000000000..419650c6a6 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/Makefile @@ -0,0 +1,3 @@ +ifeq ($(subdir),libio) +sysdep_headers += bits/stdio-lock.h +endif diff --git a/linuxthreads/sysdeps/pthread/bits/libc-lock.h b/linuxthreads/sysdeps/pthread/bits/libc-lock.h new file mode 100644 index 0000000000..530d48c6da --- /dev/null +++ b/linuxthreads/sysdeps/pthread/bits/libc-lock.h @@ -0,0 +1,208 @@ +/* libc-internal interface for mutex locks. LinuxThreads version. + Copyright (C) 1996, 1997 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. */ + +#ifndef _BITS_LIBC_LOCK_H +#define _BITS_LIBC_LOCK_H 1 + +#include <pthread.h> + +/* Mutex type. */ +#ifdef _LIBC +typedef pthread_mutex_t __libc_lock_t; +#else +typedef struct __libc_lock_opaque__ __libc_lock_t; +#endif + +/* Type for key to thread-specific data. */ +typedef pthread_key_t __libc_key_t; + +/* Define a lock variable NAME with storage class CLASS. The lock must be + initialized with __libc_lock_init before it can be used (or define it + with __libc_lock_define_initialized, below). Use `extern' for CLASS to + declare a lock defined in another module. In public structure + definitions you must use a pointer to the lock structure (i.e., NAME + begins with a `*'), because its storage size will not be known outside + of libc. */ +#define __libc_lock_define(CLASS,NAME) \ + CLASS __libc_lock_t NAME; + +/* Define an initialized lock variable NAME with storage class CLASS. */ +#define __libc_lock_define_initialized(CLASS,NAME) \ + CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER; + +/* Define an initialized recursive lock variable NAME with storage + class CLASS. */ +#define __libc_lock_define_initialized_recursive(CLASS,NAME) \ + CLASS __libc_lock_t NAME = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; + +/* Initialize the named lock variable, leaving it in a consistent, unlocked + state. */ +#define __libc_lock_init(NAME) \ + (__pthread_mutex_init != NULL ? __pthread_mutex_init (&(NAME), NULL) : 0); + +/* Same as last but this time we initialize a recursive mutex. */ +#define __libc_lock_init_recursive(NAME) \ + do { \ + if (__pthread_mutex_init != NULL) \ + { \ + pthread_mutexattr_t __attr; \ + __pthread_mutexattr_init (&__attr); \ + __pthread_mutexattr_setkind_np (&__attr, PTHREAD_MUTEX_RECURSIVE_NP); \ + __pthread_mutex_init (&(NAME), &__attr); \ + __pthread_mutexattr_destroy (&__attr); \ + } \ + } while (0); + +/* Finalize the named lock variable, which must be locked. It cannot be + used again until __libc_lock_init is called again on it. This must be + called on a lock variable before the containing storage is reused. */ +#define __libc_lock_fini(NAME) \ + (__pthread_mutex_destroy != NULL ? __pthread_mutex_destroy (&(NAME)) : 0); + +/* Finalize recursive named lock. */ +#define __libc_lock_fini_recursive(NAME) __libc_lock_fini (NAME) + +/* Lock the named lock variable. */ +#define __libc_lock_lock(NAME) \ + (__pthread_mutex_lock != NULL ? __pthread_mutex_lock (&(NAME)) : 0); + +/* Lock the recursive named lock variable. */ +#define __libc_lock_lock_recursive(NAME) __libc_lock_lock (NAME) + +/* Try to lock the named lock variable. */ +#define __libc_lock_trylock(NAME) \ + (__pthread_mutex_trylock != NULL ? __pthread_mutex_trylock (&(NAME)) : 0) + +/* Try to lock the recursive named lock variable. */ +#define __libc_lock_trylock_recursive(NAME) __libc_lock_trylock (NAME) + +/* Unlock the named lock variable. */ +#define __libc_lock_unlock(NAME) \ + (__pthread_mutex_unlock != NULL ? __pthread_mutex_unlock (&(NAME)) : 0); + +/* Unlock the recursive named lock variable. */ +#define __libc_lock_unlock_recursive(NAME) __libc_lock_unlock (NAME) + + +/* Define once control variable. */ +#define __libc_once_define(CLASS, NAME) \ + CLASS pthread_once_t NAME = PTHREAD_ONCE_INIT + +/* Call handler iff the first call. */ +#define __libc_once(ONCE_CONTROL, INIT_FUNCTION) \ + do { \ + if (__pthread_once != NULL) \ + __pthread_once (&(ONCE_CONTROL), (INIT_FUNCTION)); \ + else if ((ONCE_CONTROL) == 0) { \ + INIT_FUNCTION (); \ + (ONCE_CONTROL) = 1; \ + } \ + } while (0) + + +/* Start critical region with cleanup. */ +#define __libc_cleanup_region_start(FCT, ARG) \ + { struct _pthread_cleanup_buffer _buffer; \ + if (_pthread_cleanup_push_defer != NULL) { \ + _pthread_cleanup_push_defer (&_buffer, (FCT), (ARG)); \ + } + +/* End critical region with cleanup. */ +#define __libc_cleanup_region_end(DOIT) \ + if (_pthread_cleanup_push_defer != NULL) { \ + _pthread_cleanup_pop_restore (&_buffer, (DOIT)); \ + } \ + } + +/* Create thread-specific key. */ +#define __libc_key_create(KEY, DESTRUCTOR) \ + (__pthread_key_create != NULL ? __pthread_key_create (KEY, DESTRUCTOR) : 1) + +/* Get thread-specific data. */ +#define __libc_getspecific(KEY) \ + (__pthread_getspecific != NULL ? __pthread_getspecific (KEY) : NULL) + +/* Set thread-specific data. */ +#define __libc_setspecific(KEY, VALUE) \ + (__pthread_setspecific != NULL ? __pthread_setspecific (KEY, VALUE) : 0) + +#ifdef _LIBC + +/* Fast thread-specific data internal to libc. */ +enum __libc_tsd_key_t { _LIBC_TSD_KEY_MALLOC = 0, _LIBC_TSD_KEY_N }; + +extern void *__libc_internal_tsd_get __P ((enum __libc_tsd_key_t)); +extern int __libc_internal_tsd_set __P ((enum __libc_tsd_key_t, + __const void *)); + +#endif + + +/* Register handlers to execute before and after `fork'. */ +#define __libc_atfork(PREPARE, PARENT, CHILD) \ + (__pthread_atfork != NULL ? __pthread_atfork (PREPARE, PARENT, CHILD) : 0) + + +/* Make the pthread functions weak so that we can elide them from + single-threaded processes. */ +#ifdef weak_extern +weak_extern (__pthread_mutex_init) +weak_extern (__pthread_mutex_destroy) +weak_extern (__pthread_mutex_lock) +weak_extern (__pthread_mutex_trylock) +weak_extern (__pthread_mutex_unlock) +weak_extern (__pthread_mutexattr_init) +weak_extern (__pthread_mutexattr_destroy) +weak_extern (__pthread_mutexattr_setkind_np) +weak_extern (__pthread_key_create) +weak_extern (__pthread_setspecific) +weak_extern (__pthread_getspecific) +weak_extern (__libc_internal_tsd_get) +weak_extern (__libc_internal_tsd_set) +weak_extern (__pthread_once) +weak_extern (__pthread_initialize) +weak_extern (__pthread_atfork) +weak_extern (_pthread_cleanup_push_defer) +weak_extern (_pthread_cleanup_pop_restore) +#else +# pragma weak __pthread_mutex_init +# pragma weak __pthread_mutex_destroy +# pragma weak __pthread_mutex_lock +# pragma weak __pthread_mutex_trylock +# pragma weak __pthread_mutex_unlock +# pragma weak __pthread_mutexattr_init +# pragma weak __pthread_mutexattr_destroy +# pragma weak __pthread_mutexattr_setkind_np +# pragma weak __pthread_key_create +# pragma weak __pthread_setspecific +# pragma weak __pthread_getspecific +# pragma weak __libc_internal_tsd_get +# pragma weak __libc_internal_tsd_set +# pragma weak __pthread_once +# pragma weak __pthread_initialize +# pragma weak __pthread_atfork +# pragma weak _pthread_cleanup_push_defer +# pragma weak _pthread_cleanup_pop_restore +#endif + +/* We need portable names for some functions. E.g., when they are + used as argument to __libc_cleanup_region_start. */ +#define __libc_mutex_unlock __pthread_mutex_unlock + +#endif /* bits/libc-lock.h */ diff --git a/linuxthreads/sysdeps/pthread/bits/stdio-lock.h b/linuxthreads/sysdeps/pthread/bits/stdio-lock.h new file mode 100644 index 0000000000..23ebf407f9 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/bits/stdio-lock.h @@ -0,0 +1,35 @@ +/* Thread package specific definitions of stream lock type. + Copyright (C) 1996, 1997 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. */ + +#include <pthread.h> + +typedef pthread_mutex_t _IO_lock_t; + +/* We need recursive (counting) mutexes. */ +#define _IO_lock_initializer PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP + + +#define _IO_cleanup_region_start(_fct, _fp) \ + __libc_cleanup_region_start (_fct, _fp) +#define _IO_cleanup_region_end(_doit) \ + __libc_cleanup_region_end (_doit) +#define _IO_lock_init(_name) \ + __libc_lock_init_recursive (_name) +#define _IO_lock_fini(_name) \ + __libc_lock_fini_recursive (_name) diff --git a/linuxthreads/sysdeps/pthread/cmpxchg/bits/semaphore.h b/linuxthreads/sysdeps/pthread/cmpxchg/bits/semaphore.h new file mode 100644 index 0000000000..0cdbc05b90 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/cmpxchg/bits/semaphore.h @@ -0,0 +1,26 @@ +/* Copyright (C) 1996, 1997 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. */ + +#ifndef _SEMAPHORE_H +# error "Never include <bits/semaphore.h> directly; use <semaphore.h> instead." +#endif + + +typedef struct { + long int sem_status; +} sem_t; diff --git a/linuxthreads/sysdeps/pthread/no-cmpxchg/bits/semaphore.h b/linuxthreads/sysdeps/pthread/no-cmpxchg/bits/semaphore.h new file mode 100644 index 0000000000..4d801a26a6 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/no-cmpxchg/bits/semaphore.h @@ -0,0 +1,27 @@ +/* Copyright (C) 1996, 1997 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. */ + +#ifndef _SEMAPHORE_H +# error "Never include <bits/semaphore.h> directly; use <semaphore.h> instead." +#endif + + +typedef struct { + long int sem_status; + int sem_spinlock; +} sem_t; diff --git a/linuxthreads/sysdeps/pthread/pthread.h b/linuxthreads/sysdeps/pthread/pthread.h new file mode 100644 index 0000000000..b62706a811 --- /dev/null +++ b/linuxthreads/sysdeps/pthread/pthread.h @@ -0,0 +1,578 @@ +/* Linuxthreads - a simple clone()-based implementation of Posix */ +/* threads for Linux. */ +/* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */ +/* */ +/* This program 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. */ +/* */ +/* This program 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. */ + +#ifndef _PTHREAD_H +#define _PTHREAD_H 1 + +#include <features.h> + +#include <errno.h> +#include <limits.h> +#include <sched.h> +#include <unistd.h> + +#define __need_sigset_t +#include <signal.h> +#define __need_timespec +#include <time.h> + +/* Linux has no ENOTSUP error code. */ +#ifndef ENOTSUP +#define ENOTSUP EOPNOTSUPP +#endif + + +__BEGIN_DECLS + +/*** Types ***/ + +/* Thread identifiers */ +typedef unsigned long int pthread_t; + +/* Thread descriptors */ +typedef struct _pthread_descr_struct *_pthread_descr; + +/* Waiting queues (not abstract because mutexes and conditions aren't). */ +struct _pthread_queue +{ + _pthread_descr head; /* First element, or NULL if queue empty. */ + _pthread_descr tail; /* Last element, or NULL if queue empty. */ +}; + +/* Mutexes (not abstract because of PTHREAD_MUTEX_INITIALIZER). */ +typedef struct +{ + int m_spinlock; /* Spin lock to guarantee mutual exclusion. */ + int m_count; /* 0 if free, > 0 if taken. */ + _pthread_descr m_owner; /* Owner of mutex (for recursive mutexes) */ + int m_kind; /* Kind of mutex */ + struct _pthread_queue m_waiting; /* Threads waiting on this mutex. */ +} pthread_mutex_t; + +#define PTHREAD_MUTEX_INITIALIZER \ + {0, 0, 0, PTHREAD_MUTEX_FAST_NP, {0, 0}} +#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP \ + {0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, {0, 0}} + +/* Conditions (not abstract because of PTHREAD_COND_INITIALIZER */ +typedef struct +{ + int c_spinlock; /* Spin lock to protect the queue. */ + struct _pthread_queue c_waiting; /* Threads waiting on this condition. */ +} pthread_cond_t; + +#define PTHREAD_COND_INITIALIZER {0, {0, 0}} + +#ifdef __USE_UNIX98 +/* Read-write locks. */ +typedef struct +{ + int rw_spinlock; /* Spin lock to guarantee mutual exclusion */ + int rw_readers; /* Number of readers */ + _pthread_descr rw_writer; /* Identity of writer, or NULL if none */ + struct _pthread_queue rw_read_waiting; /* Threads waiting for reading */ + struct _pthread_queue rw_write_waiting; /* Threads waiting for writing */ + int rw_kind; /* Reader/Writer preference selection */ + int rw_pshared; /* Shared between processes or not */ +} pthread_rwlock_t; + +# define PTHREAD_RWLOCK_INITIALIZER \ + { 0, 0, 0, {0, 0}, {0, 0}, \ + PTHREAD_RWLOCK_DEFAULT_NP, PTHREAD_PROCESS_PRIVATE } +#endif + +/* Attributes */ + +enum +{ + PTHREAD_CREATE_JOINABLE, + PTHREAD_CREATE_DETACHED +}; + +enum +{ + PTHREAD_INHERIT_SCHED, + PTHREAD_EXPLICIT_SCHED +}; + +enum +{ + PTHREAD_SCOPE_SYSTEM, + PTHREAD_SCOPE_PROCESS +}; + +typedef struct +{ + int detachstate; + int schedpolicy; + struct sched_param schedparam; + int inheritsched; + int scope; +} pthread_attr_t; + +enum +{ + PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK_NP +#ifdef __USE_UNIX98 + , + PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL +#endif +}; + +typedef struct +{ + int mutexkind; +} pthread_mutexattr_t; + +typedef struct +{ + int dummy; +} pthread_condattr_t; + +#ifdef __USE_UNIX98 +enum +{ + PTHREAD_PROCESS_PRIVATE, + PTHREAD_PROCESS_SHARED +}; + +enum +{ + PTHREAD_RWLOCK_PREFER_READER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NP, + PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP +}; + +typedef struct +{ + int lockkind; + int pshared; +} pthread_rwlockattr_t; +#endif + +/* Keys for thread-specific data */ + +typedef unsigned int pthread_key_t; + +/* Once-only execution */ + +typedef int pthread_once_t; + +#define PTHREAD_ONCE_INIT 0 + +/* Cleanup buffers */ + +struct _pthread_cleanup_buffer +{ + void (*routine) __P ((void *)); /* Function to call. */ + void *arg; /* Its argument. */ + int canceltype; /* Saved cancellation type. */ + struct _pthread_cleanup_buffer *prev; /* Chaining of cleanup functions. */ +}; + +/* Cancellation */ + +enum { PTHREAD_CANCEL_ENABLE, PTHREAD_CANCEL_DISABLE }; +enum { PTHREAD_CANCEL_DEFERRED, PTHREAD_CANCEL_ASYNCHRONOUS }; +#define PTHREAD_CANCELED ((void *) -1) + + +/* Function for handling threads. */ + +/* Create a thread with given attributes ATTR (or default attributes + if ATTR is NULL), and call function START_ROUTINE with given + arguments ARG. */ +extern int pthread_create __P ((pthread_t *__thread, + __const pthread_attr_t *__attr, + void *(*__start_routine) (void *), + void *__arg)); + +/* Obtain the identifier of the current thread. */ +extern pthread_t pthread_self __P ((void)); + +/* Compare two thread identifiers. */ +extern int pthread_equal __P ((pthread_t __thread1, pthread_t __thread2)); + +/* Terminate calling thread. */ +extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__)); + +/* Make calling thread wait for termination of the thread TH. The + exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN + is not NULL. */ +extern int pthread_join __P ((pthread_t __th, void **__thread_return)); + +/* Indicate that the thread TH is never to be joined with PTHREAD_JOIN. + The resources of TH will therefore be freed immediately when it + terminates, instead of waiting for another thread to perform PTHREAD_JOIN + on it. */ +extern int pthread_detach __P ((pthread_t __th)); + + +/* Functions for handling attributes. */ + +/* Initialize thread attribute *ATTR with default attributes + (detachstate is PTHREAD_JOINABLE, scheduling policy is SCHED_OTHER). */ +extern int pthread_attr_init __P ((pthread_attr_t *__attr)); + +/* Destroy thread attribute *ATTR. */ +extern int pthread_attr_destroy __P ((pthread_attr_t *__attr)); + +/* Set the `detachstate' attribute in *ATTR according to DETACHSTATE. */ +extern int pthread_attr_setdetachstate __P ((pthread_attr_t *__attr, + int __detachstate)); + +/* Return in *DETACHSTATE the `detachstate' attribute in *ATTR. */ +extern int pthread_attr_getdetachstate __P ((__const pthread_attr_t *__attr, + int *__detachstate)); + +/* Set scheduling parameters (priority, etc) in *ATTR according to PARAM. */ +extern int pthread_attr_setschedparam __P ((pthread_attr_t *__attr, + __const struct sched_param *__param)); + +/* Return in *PARAM the scheduling parameters of *ATTR. */ +extern int pthread_attr_getschedparam __P ((__const pthread_attr_t *__attr, + struct sched_param *__param)); + +/* Set scheduling policy in *ATTR according to POLICY. */ +extern int pthread_attr_setschedpolicy __P ((pthread_attr_t *__attr, + int __policy)); + +/* Return in *POLICY the scheduling policy of *ATTR. */ +extern int pthread_attr_getschedpolicy __P ((__const pthread_attr_t *__attr, + int *__policy)); + +/* Set scheduling inheritance mode in *ATTR according to INHERIT. */ +extern int pthread_attr_setinheritsched __P ((pthread_attr_t *__attr, + int __inherit)); + +/* Return in *INHERIT the scheduling inheritance mode of *ATTR. */ +extern int pthread_attr_getinheritsched __P ((__const pthread_attr_t *__attr, + int *__inherit)); + +/* Set scheduling contention scope in *ATTR according to SCOPE. */ +extern int pthread_attr_setscope __P ((pthread_attr_t *__attr, int __scope)); + +/* Return in *SCOPE the scheduling contention scope of *ATTR. */ +extern int pthread_attr_getscope __P ((__const pthread_attr_t *__attr, + int *__scope)); + +/* Functions for scheduling control. */ + +/* Set the scheduling parameters for TARGET_THREAD according to POLICY + and *PARAM. */ +extern int pthread_setschedparam __P ((pthread_t __target_thread, int __policy, + __const struct sched_param *__param)); + +/* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */ +extern int pthread_getschedparam __P ((pthread_t __target_thread, + int *__policy, + struct sched_param *__param)); + + +/* Functions for mutex handling. */ + +/* Initialize MUTEX using attributes in *MUTEX_ATTR, or use the + default values if later is NULL. */ +extern int __pthread_mutex_init __P ((pthread_mutex_t *__mutex, + __const pthread_mutexattr_t *__mutex_attr)); +extern int pthread_mutex_init __P ((pthread_mutex_t *__mutex, + __const pthread_mutexattr_t *__mutex_attr)); + +/* Destroy MUTEX. */ +extern int __pthread_mutex_destroy __P ((pthread_mutex_t *__mutex)); +extern int pthread_mutex_destroy __P ((pthread_mutex_t *__mutex)); + +/* Try to lock MUTEX. */ +extern int __pthread_mutex_trylock __P ((pthread_mutex_t *__mutex)); +extern int pthread_mutex_trylock __P ((pthread_mutex_t *__mutex)); + +/* Wait until lock for MUTEX becomes available and lock it. */ +extern int __pthread_mutex_lock __P ((pthread_mutex_t *__mutex)); +extern int pthread_mutex_lock __P ((pthread_mutex_t *__mutex)); + +/* Unlock MUTEX. */ +extern int __pthread_mutex_unlock __P ((pthread_mutex_t *__mutex)); +extern int pthread_mutex_unlock __P ((pthread_mutex_t *__mutex)); + + +/* Functions for handling mutex attributes. */ + +/* Initialize mutex attribute object ATTR with de |