From 2c2eb19365e549cd26747f2b70b666bc9bbea4c2 Mon Sep 17 00:00:00 2001 From: Julian Elischer Date: Mon, 22 Jan 1996 00:24:56 +0000 Subject: [PATCH] Submitted by: john birrel Obtained from: uthread package thrreads definitions --- include/pthread.h | 276 ++++++++++++++++++++++++++++++++++++++++++++++ include/timers.h | 45 ++++++++ 2 files changed, 321 insertions(+) create mode 100644 include/pthread.h create mode 100644 include/timers.h diff --git a/include/pthread.h b/include/pthread.h new file mode 100644 index 000000000000..5665609452cb --- /dev/null +++ b/include/pthread.h @@ -0,0 +1,276 @@ +/* + * Copyright (c) 1993, 1994 by Chris Provenzano, proven@mit.edu + * Copyright (c) 1995 by John Birrell + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Chris Provenzano. + * 4. The name of Chris Provenzano may not be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY CHRIS PROVENZANO ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL CHRIS PROVENZANO BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + */ +#ifndef _PTHREAD_H_ +#define _PTHREAD_H_ + +/* + * Header files. + */ +#include +#include +#include + +/* + * Forward thread structure definition. This is opaque to the user. + */ +struct pthread; + +/* + * Queue definitions. + */ +struct pthread_queue { + struct pthread *q_next; + struct pthread *q_last; + void *q_data; +}; + +/* + * Static queue initialization values. + */ +#define PTHREAD_QUEUE_INITIALIZER { NULL, NULL, NULL } + +/* + * Mutex definitions. + */ +enum pthread_mutextype { + MUTEX_TYPE_FAST = 1, + MUTEX_TYPE_COUNTING_FAST = 2, /* Recursive */ + MUTEX_TYPE_MAX +}; + +union pthread_mutex_data { + void *m_ptr; + int m_count; +}; + +struct pthread_mutex { + enum pthread_mutextype m_type; + struct pthread_queue m_queue; + struct pthread *m_owner; + union pthread_mutex_data m_data; + long m_flags; +}; + +/* + * Flags for mutexes. + */ +#define MUTEX_FLAGS_PRIVATE 0x01 +#define MUTEX_FLAGS_INITED 0x02 +#define MUTEX_FLAGS_BUSY 0x04 + +/* + * Static mutex initialization values. + */ +#define PTHREAD_MUTEX_INITIALIZER \ + { MUTEX_TYPE_FAST, PTHREAD_QUEUE_INITIALIZER, \ + NULL, { NULL }, MUTEX_FLAGS_INITED } + +struct pthread_mutex_attr { + enum pthread_mutextype m_type; + long m_flags; +}; + +/* + * Condition variable definitions. + */ +enum pthread_cond_type { + COND_TYPE_FAST, + COND_TYPE_MAX +}; + +struct pthread_cond { + enum pthread_cond_type c_type; + struct pthread_queue c_queue; + void *c_data; + long c_flags; +}; + +struct pthread_cond_attr { + enum pthread_cond_type c_type; + long c_flags; +}; + +/* + * Flags for condition variables. + */ +#define COND_FLAGS_PRIVATE 0x01 +#define COND_FLAGS_INITED 0x02 +#define COND_FLAGS_BUSY 0x04 + +/* + * Static cond initialization values. + */ +#define PTHREAD_COND_INITIALIZER \ + { COND_TYPE_FAST, PTHREAD_QUEUE_INITIALIZER, NULL, COND_FLAGS_INITED } + +/* + * Cleanup definitions. + */ +struct pthread_cleanup { + struct pthread_cleanup *next; + void (*routine) (); + void *routine_arg; +}; + +/* + * Scheduling definitions. + */ +enum schedparam_policy { + SCHED_RR, + SCHED_IO, + SCHED_FIFO, + SCHED_OTHER +}; + +struct pthread_attr { + enum schedparam_policy schedparam_policy; + int prio; + int suspend; + int flags; + void *arg_attr; + void (*cleanup_attr) (); + void *stackaddr_attr; + size_t stacksize_attr; +}; + +struct sched_param { + int prio; + void *no_data; +}; + +/* + * Once definitions. + */ +struct pthread_once { + int state; + struct pthread_mutex mutex; +}; + +/* + * Flags for once initialization. + */ +#define PTHREAD_NEEDS_INIT 0 +#define PTHREAD_DONE_INIT 1 + +/* + * Static once initialization values. + */ +#define PTHREAD_ONCE_INIT { PTHREAD_NEEDS_INIT, PTHREAD_MUTEX_INITIALIZER } + +/* + * Type definitions. + */ +typedef int pthread_key_t; +typedef struct pthread *pthread_t; +typedef struct pthread_attr pthread_attr_t; +typedef struct pthread_cond pthread_cond_t; +typedef struct pthread_cond_attr pthread_condattr_t; +typedef struct pthread_mutex pthread_mutex_t; +typedef struct pthread_mutex_attr pthread_mutexattr_t; +typedef struct pthread_once pthread_once_t; +typedef void *pthread_addr_t; +typedef void *(*pthread_startroutine_t) (void *); + +/* + * Default attribute arguments. + */ +#define pthread_condattr_default NULL +#define pthread_mutexattr_default NULL +#ifndef PTHREAD_KERNEL +#define pthread_attr_default NULL +#endif + +/* + * Thread function prototype definitions: + */ +__BEGIN_DECLS +int pthread_create __P((pthread_t *, const pthread_attr_t *, + void *(*start_routine) (void *), void *)); +void pthread_exit __P((void *)); +pthread_t pthread_self __P((void)); +int pthread_equal __P((pthread_t, pthread_t)); +int pthread_getprio __P((pthread_t)); +int pthread_setprio __P((pthread_t, int)); +int pthread_join __P((pthread_t, void **)); +int pthread_detach __P((pthread_t *)); +int pthread_resume __P((pthread_t)); +int pthread_suspend __P((pthread_t)); +void pthread_yield __P((void)); +int pthread_setschedparam __P((pthread_t pthread, int policy, + struct sched_param * param)); +int pthread_getschedparam __P((pthread_t pthread, int *policy, + struct sched_param * param)); +int pthread_kill __P((struct pthread *, int)); +int pthread_cleanup_push __P((void (*routine) (void *), void *routine_arg)); +void pthread_cleanup_pop __P((int execute)); +int pthread_cond_init __P((pthread_cond_t *, const pthread_condattr_t *)); +int pthread_cond_timedwait __P((pthread_cond_t *, pthread_mutex_t *, + const struct timespec * abstime)); +int pthread_cond_wait __P((pthread_cond_t *, pthread_mutex_t *)); +int pthread_cond_signal __P((pthread_cond_t *)); +int pthread_cond_broadcast __P((pthread_cond_t *)); +int pthread_cond_destroy __P((pthread_cond_t *)); +int pthread_mutex_init __P((pthread_mutex_t *, const pthread_mutexattr_t *)); +int pthread_mutex_lock __P((pthread_mutex_t *)); +int pthread_mutex_unlock __P((pthread_mutex_t *)); +int pthread_mutex_trylock __P((pthread_mutex_t *)); +int pthread_mutex_destroy __P((pthread_mutex_t *)); +int pthread_attr_init __P((pthread_attr_t *)); +int pthread_attr_destroy __P((pthread_attr_t *)); +int pthread_attr_setstacksize __P((pthread_attr_t *, size_t)); +int pthread_attr_getstacksize __P((pthread_attr_t *, size_t *)); +int pthread_attr_setstackaddr __P((pthread_attr_t *, void *)); +int pthread_attr_getstackaddr __P((pthread_attr_t *, void **)); +int pthread_attr_setdetachstate __P((pthread_attr_t *, int)); +int pthread_attr_getdetachstate __P((pthread_attr_t *, int *)); +int pthread_attr_setscope __P((pthread_attr_t *, int)); +int pthread_attr_getscope __P((pthread_attr_t *, int *)); +int pthread_attr_setinheritsched __P((pthread_attr_t *, int)); +int pthread_attr_getinheritsched __P((pthread_attr_t *, int *)); +int pthread_attr_setschedpolicy __P((pthread_attr_t *, int)); +int pthread_attr_getschedpolicy __P((pthread_attr_t *, int *)); +int pthread_attr_setschedparam __P((pthread_attr_t *, struct sched_param *)); +int pthread_attr_getschedparam __P((pthread_attr_t *, struct sched_param *)); +int pthread_attr_setfloatstate __P((pthread_attr_t *, int)); +int pthread_attr_getfloatstate __P((pthread_attr_t *, int *)); +int pthread_attr_setcleanup __P((pthread_attr_t *, void (*routine) (void *), void *)); +int pthread_attr_setcreatesuspend __P((pthread_attr_t *)); +int pthread_once __P((pthread_once_t *, void (*init_routine) (void))); +int pthread_keycreate __P((pthread_key_t *, void (*routine) (void *))); +int pthread_setspecific __P((pthread_key_t, const void *)); +int pthread_getspecific __P((pthread_key_t, void **)); +int pthread_key_delete __P((pthread_key_t)); +__END_DECLS + +#endif diff --git a/include/timers.h b/include/timers.h new file mode 100644 index 000000000000..5a66ee72a4d5 --- /dev/null +++ b/include/timers.h @@ -0,0 +1,45 @@ +/* ==== timers.h ============================================================ + * Copyright (c) 1994 by Chris Provenzano, proven@mit.edu + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by Chris Provenzano. + * 4. The name of Chris Provenzano may not be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY CHRIS PROVENZANO ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL CHRIS PROVENZANO BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: timers.h,v 1.1 1995/09/26 00:26:09 jb Exp jb $ + * + * Description : Basic timers header. + * + * 1.00 94/06/13 proven + * -Started coding this file. + */ + +#ifndef _TIMERS_H_ +#define _TIMERS_H_ + +#include + +#endif