home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / positrtl.zip / pthread.h < prev    next >
Text File  |  2000-03-27  |  13KB  |  377 lines
  1. /*
  2.  * Copyright (c) 1993, 1994 by Chris Provenzano, proven@mit.edu
  3.  * Copyright (c) 1995 by John Birrell <jb@cimlogic.com.au>
  4.  * All rights reserved
  5.  *
  6.  * Modified and extended by Antony T Curtis <antony.curtis@olcs.net>
  7.  * for use with OS/2.
  8.  *
  9.  * Redistribution and use in source and binary forms, with or without
  10.  * modification, are permitted provided that the following conditions
  11.  * are met:
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer.
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in the
  16.  *    documentation and/or other materials provided with the distribution.
  17.  * 3. All advertising materials mentioning features or use of this software
  18.  *    must display the following acknowledgement:
  19.  *  This product includes software developed by Chris Provenzano.
  20.  * 4. The name of Chris Provenzano may not be used to endorse or promote 
  21.  *      products derived from this software without specific prior written
  22.  *      permission.
  23.  *
  24.  * THIS SOFTWARE IS PROVIDED BY CHRIS PROVENZANO ``AS IS'' AND
  25.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27.  * ARE DISCLAIMED.  IN NO EVENT SHALL CHRIS PROVENZANO BE LIABLE FOR ANY 
  28.  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  29.  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
  30.  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31.  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
  32.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
  34.  * SUCH DAMAGE.
  35.  *
  36.  */
  37. #ifndef _PTHREAD_H_
  38. #define _PTHREAD_H_
  39.  
  40. #define EMX_PTHREAD_REV 6
  41.  
  42. #ifdef __MT__
  43.  
  44. /*
  45.  * Header files.
  46.  */
  47. #include <sys/cdefs.h>
  48. #include <sys/types.h>
  49. #include <sys/time.h>
  50. #include <sys/signal.h>
  51. #include <sys/select.h>
  52. #include <limits.h>
  53. #include <unistd.h>
  54.  
  55. #if defined (__cplusplus)
  56. extern "C" {
  57. #endif
  58.  
  59. /* This should really be in time.h */
  60. #ifndef HAVE_TIMESPEC
  61. #define HAVE_TIMESPEC
  62. struct timespec
  63.   {
  64.     long int tv_sec;            /* Seconds.  */
  65.     long int tv_nsec;           /* Nanoseconds.  */
  66.   };
  67. #endif
  68.  
  69. /* This should really be in sys/fctrl.h */
  70. #if !defined(F_RDLCK)
  71. /* For posix fcntl() and `l_type' field of a `struct flock' for lockf().  */
  72. #define F_RDLCK         0       /* Read lock.  */
  73. #define F_WRLCK         1       /* Write lock.  */
  74. #define F_UNLCK         2       /* Remove lock.  */
  75. #endif
  76. #if !defined(F_SETLK)
  77. #define F_SETLK         6       /* Set record locking info (non-blocking).  */
  78. #define F_SETLKW        7       /* Set record locking info (blocking).  */
  79.  
  80. #ifdef PTHREAD_KERNEL
  81. struct flock
  82.   {
  83.     short int l_type;   /* Type of lock: F_RDLCK, F_WRLCK, or F_UNLCK.  */
  84.     short int l_whence; /* Where `l_start' is relative to (like `lseek').  */
  85.     unsigned long l_start;    /* Offset where the lock begins.  */
  86.     unsigned long l_len;      /* Size of the locked area; zero means until EOF.  */
  87.     unsigned int l_pid;      /* Process holding the lock.  */
  88.   };
  89. #else
  90. int flock (int, int);
  91. #endif
  92.  
  93. #endif
  94.  
  95. /*
  96.  * Run-time invariant values:
  97.  */
  98. #define PTHREAD_DESTRUCTOR_ITERATIONS        4
  99. #define PTHREAD_KEYS_MAX            256
  100. #define PTHREAD_STACK_MIN            1024
  101. #define PTHREAD_THREADS_MAX            ULONG_MAX
  102.  
  103. /*
  104.  * Compile time symbolic constants for portability specifications:
  105.  *
  106.  * Note that those commented out are not currently supported by the
  107.  * implementation.
  108.  */
  109. #define _POSIX_THREADS
  110. /* #define _POSIX_THREAD_ATTR_STACKADDR */
  111. /* #define _POSIX_THREAD_ATTR_STACKSIZE */
  112. /* #define _POSIX_THREAD_PRIORITY_SCHEDULING */
  113. /* #define _POSIX_THREAD_PRIO_INHERIT   */
  114. /* #define _POSIX_THREAD_PRIO_PROTECT   */
  115. /* #define _POSIX_THREAD_PROCESS_SHARED */
  116. /* #define _POSIX_THREAD_SAFE_FUNCTIONS */
  117.  
  118. #define THREAD_SPECIFIC_SIGPIPE
  119.  
  120. /*
  121.  * Flags for threads and thread attributes.
  122.  */
  123. #define PTHREAD_DETACHED            0x1
  124. #define PTHREAD_SCOPE_SYSTEM        0x2
  125. #define PTHREAD_INHERIT_SCHED       0x4
  126. #define PTHREAD_NOFLOAT             0x8
  127.  
  128. #define PTHREAD_CREATE_DETACHED     PTHREAD_DETACHED
  129. #define PTHREAD_CREATE_JOINABLE     0
  130. #define PTHREAD_SCOPE_PROCESS       0
  131. #define PTHREAD_EXPLICIT_SCHED      0
  132.  
  133. /*
  134.  * New pthread attribute types.
  135.  */
  136. enum schedparam_policy {
  137.     SCHED_RR,
  138.     SCHED_IO,
  139.     SCHED_FIFO,
  140.     SCHED_OTHER
  141. };
  142.  
  143. /*
  144.  * Forward structure definitions.
  145.  *
  146.  * These are mostly opaque to the user.
  147.  */
  148. struct pthread;
  149. struct pthread_attr;
  150. struct pthread_cond;
  151. struct pthread_cond_attr;
  152. struct pthread_mutex;
  153. struct pthread_mutex_attr;
  154. struct pthread_once;
  155. struct sched_param;
  156.  
  157. /*
  158.  * Primitive system data type definitions required by P1003.1c.
  159.  *
  160.  * Note that P1003.1c specifies that there are no defined comparison
  161.  * or assignment operators for the types pthread_attr_t, pthread_cond_t,
  162.  * pthread_condattr_t, pthread_mutex_t, pthread_mutexattr_t.
  163.  */
  164. typedef struct    pthread            *pthread_t;
  165. typedef struct    pthread_attr        *pthread_attr_t;
  166. typedef struct    pthread_mutex        *pthread_mutex_t; 
  167. typedef struct    pthread_mutex_attr    *pthread_mutexattr_t;
  168. typedef struct    pthread_cond        *pthread_cond_t;
  169. typedef struct    pthread_cond_attr    *pthread_condattr_t;
  170. typedef int                 pthread_key_t;
  171. typedef struct    pthread_once        pthread_once_t;
  172.  
  173. /*
  174.  * Additional type definitions:
  175.  *
  176.  * Note that P1003.1c reserves the prefixes pthread_ and PTHREAD_ for
  177.  * use in header symbols.
  178.  */
  179. typedef void    *pthread_addr_t;
  180. typedef void    *(*pthread_startroutine_t) (void *);
  181. typedef struct timespec timespec_t;
  182.  
  183. /*
  184.  * Once definitions.
  185.  */
  186. struct pthread_once {
  187.     int        state;
  188.     pthread_mutex_t    mutex;
  189. };
  190.  
  191. /* Cancellation */
  192.  
  193. enum { PTHREAD_CANCEL_ENABLE, PTHREAD_CANCEL_DISABLE };
  194. enum { PTHREAD_CANCEL_DEFERRED, PTHREAD_CANCEL_ASYNCHRONOUS };
  195. #define PTHREAD_CANCELED ((void *) -1)
  196.  
  197. /*
  198.  * Flags for once initialization.
  199.  */
  200. #define PTHREAD_NEEDS_INIT  0
  201. #define PTHREAD_DONE_INIT   1
  202. #define PTHREAD_MUTEX_INITIALIZER NULL
  203.  
  204. /*
  205.  * Static once initialization values. 
  206.  */
  207. #define PTHREAD_ONCE_INIT   { PTHREAD_NEEDS_INIT, NULL }
  208.  
  209. /*
  210.  * Default attribute arguments.
  211.  */
  212. #ifndef PTHREAD_KERNEL
  213. #define pthread_condattr_default    NULL
  214. #define pthread_mutexattr_default   NULL
  215. #define pthread_attr_default        NULL
  216. #endif
  217.  
  218. #if !defined(PTHREAD_KERNEL) && !defined(PTHREAD_RTL)
  219. #define sigprocmask(A,B,C)    pthread_sigmask((A),(B),(C))
  220. #define signal(A,B)        pthread_signal((A),(B))
  221. #define raise(A)        pthread_raise(A)
  222. #define    sigaction(A,B,C)    pthread_sigaction((A),(B),(C))
  223. #define sigpending(A)        pthread_sigpending(A)
  224. #define sigsuspend(A)        pthread_sigsuspend(A)
  225. #define pause()            pthread_pause()
  226. #define alarm(A)        pthread_alarm(A)
  227. #define    select(A,B,C,D,E)    pthread_select((A),(B),(C),(D),(E))
  228. #define    sleep(A)        pthread_sleep(A)
  229. #define read(A,B,C)        pthread_read((A),(B),(C))
  230. #define write(A,B,C)        pthread_write((A),(B),(C))
  231. #endif
  232.  
  233. enum pthread_mutextype {
  234.     MUTEX_TYPE_FAST            = 1,
  235.     MUTEX_TYPE_COUNTING_FAST    = 2,    /* Recursive */
  236.     MUTEX_TYPE_MAX
  237. };
  238.  
  239. /*
  240.  * Thread function prototype definitions:
  241.  */
  242. /* __BEGIN_DECLS */
  243. int        pthread_attr_destroy (pthread_attr_t *);
  244. int        pthread_attr_getinheritsched (pthread_attr_t *, int *);
  245. int        pthread_attr_getschedparam (pthread_attr_t *,
  246.             struct sched_param *);
  247. int        pthread_attr_getschedpolicy (pthread_attr_t *, int *);
  248. int        pthread_attr_getscope (pthread_attr_t *, int *);
  249. int        pthread_attr_getstacksize (pthread_attr_t *, size_t *);
  250. int        pthread_attr_getstackaddr (pthread_attr_t *, void **);
  251. int        pthread_attr_getdetachstate (pthread_attr_t *, int *);
  252. int        pthread_attr_init (pthread_attr_t *);
  253. int        pthread_attr_setinheritsched (pthread_attr_t *, int);
  254. int        pthread_attr_setprio(pthread_attr_t *, int);
  255. int        pthread_attr_setschedparam (pthread_attr_t *,
  256.             struct sched_param *);
  257. int        pthread_attr_setschedpolicy (pthread_attr_t *, int);
  258. int        pthread_attr_setscope (pthread_attr_t *, int);
  259. int        pthread_attr_setstacksize (pthread_attr_t *, size_t);
  260. int        pthread_attr_setstackaddr (pthread_attr_t *, void *);
  261. int        pthread_attr_setdetachstate (pthread_attr_t *, int);
  262. void        pthread_cleanup_pop (int execute);
  263. void        pthread_cleanup_push (void (*routine) (void *),
  264.             void *routine_arg);
  265. int        pthread_condattr_destroy (pthread_condattr_t *attr);
  266. int        pthread_condattr_init (pthread_condattr_t *attr);
  267. int        pthread_condattr_getpshared (pthread_condattr_t *attr,
  268.             int *pshared);
  269. int        pthread_condattr_setpshared (pthread_condattr_t *attr,
  270.             int pshared);
  271. int        pthread_cond_broadcast (pthread_cond_t *);
  272. int        pthread_cond_destroy (pthread_cond_t *);
  273. int        pthread_cond_init (pthread_cond_t *,
  274.             const pthread_condattr_t *);
  275. int        pthread_cond_signal (pthread_cond_t *);
  276. int        pthread_cond_timedwait (pthread_cond_t *,
  277.             pthread_mutex_t *, const timespec_t * abstime);
  278. int        pthread_cond_wait (pthread_cond_t *, pthread_mutex_t *);
  279. int        pthread_create (pthread_t *, const pthread_attr_t *,
  280.             pthread_startroutine_t start_routine, void *);
  281. int        pthread_detach (pthread_t *);
  282. int        pthread_equal (pthread_t, pthread_t);
  283. void        pthread_exit (void *);
  284. void        *pthread_getspecific (pthread_key_t);
  285. void        pthread_init (void);
  286. int        pthread_join (pthread_t, void **);
  287. int        pthread_key_create (pthread_key_t *,
  288.             void (*routine) (void *));
  289. int        pthread_key_delete (pthread_key_t);
  290. int        pthread_kill (struct pthread *, int);
  291. int        pthread_mutexattr_destroy (pthread_mutexattr_t *);
  292. int        pthread_mutexattr_getprioceiling (pthread_mutexattr_t *,
  293.             int *prioceiling);
  294. int        pthread_mutexattr_getprotocol (pthread_mutexattr_t *,
  295.             int *protocol);
  296. int        pthread_mutexattr_getpshared (pthread_mutexattr_t *,
  297.             int *pshared);
  298. int        pthread_mutexattr_init (pthread_mutexattr_t *);
  299. int        pthread_mutexattr_setprioceiling (pthread_mutexattr_t *,
  300.             int prioceiling);
  301. int        pthread_mutexattr_setprotocol (pthread_mutexattr_t *,
  302.             int protocol);
  303. int        pthread_mutexattr_setpshared (pthread_mutexattr_t *,
  304.             int pshared);
  305. int        pthread_mutex_destroy (pthread_mutex_t *);
  306. int        pthread_mutex_getprioceiling (pthread_mutex_t *);
  307. int        pthread_mutex_init (pthread_mutex_t *,
  308.             const pthread_mutexattr_t *);
  309. int        pthread_mutex_lock (pthread_mutex_t *);
  310. int        pthread_mutex_setprioceiling (pthread_mutex_t *);
  311. int        pthread_mutex_trylock (pthread_mutex_t *);
  312. int        pthread_mutex_unlock (pthread_mutex_t *);
  313. int        pthread_once (pthread_once_t *,
  314.             void (*init_routine) (void));
  315. pthread_t    pthread_self (void);
  316. int        pthread_setcancelstate (int, int *);
  317. int        pthread_setcanceltype (int, int *);
  318. int        pthread_setspecific (pthread_key_t, const void *);
  319. int        pthread_testcancel (void);
  320.  
  321.  
  322. int        pthread_getprio (pthread_t);
  323. int        pthread_setprio (pthread_t, int);
  324. void        pthread_yield (void);
  325. /* int        pthread_setschedparam (pthread_t pthread, int policy,
  326.             struct sched_param * param);                */
  327. /* int        pthread_getschedparam (pthread_t pthread, int *policy,
  328.             struct sched_param * param);                */
  329. int        pthread_attr_setfloatstate (pthread_attr_t *, int);
  330. int        pthread_attr_getfloatstate (pthread_attr_t *, int *);
  331. int        pthread_attr_setcleanup (pthread_attr_t *,
  332.             void (*routine) (void *), void *);
  333.  
  334. int        pthread_suspend_np(pthread_t);
  335. int        pthread_resume_np(pthread_t);
  336. int        pthread_attr_setcreatesuspend_np(pthread_attr_t *);
  337. int        pthread_mutexattr_setkind_np(pthread_mutexattr_t *, int);
  338. int        pthread_mutexattr_getkind_np(pthread_mutexattr_t);
  339.  
  340. int        pthread_sigmask (int, const sigset_t *, sigset_t *);
  341.  
  342. #ifndef PTHREAD_RTL
  343. unsigned    pthread_alarm(unsigned);
  344. int        pthread_pause(void);
  345. int        pthread_raise(int);
  346. int        pthread_select(int, struct _fd_set *, struct _fd_set *, struct _fd_set *,struct timeval *);
  347. void (*        pthread_signal(int, void (*)(int)))(int);
  348. int        pthread_sigaction(int, const struct sigaction *, struct sigaction *);
  349. int        pthread_sigpending(sigset_t *);
  350. int        pthread_sigsuspend(const sigset_t *);
  351. unsigned    pthread_sleep(unsigned);
  352. int        pthread_read(int, void *, size_t);
  353. int        pthread_write(int, const void *, size_t);
  354. #endif
  355.  
  356. /* __END_DECLS */
  357.  
  358. #if defined (__cplusplus)
  359. }
  360. #endif
  361. #endif
  362. #endif
  363. #if !defined(PTHREAD_KERNEL) && !defined(PTHREAD_RTL)
  364. #define sigprocmask(A,B,C)    pthread_sigmask((A),(B),(C))
  365. #define signal(A,B)        pthread_signal((A),(B))
  366. #define raise(A)        pthread_raise(A)
  367. #define    sigaction(A,B,C)    pthread_sigaction((A),(B),(C))
  368. #define sigpending(A)        pthread_sigpending(A)
  369. #define sigsuspend(A)        pthread_sigsuspend(A)
  370. #define pause()            pthread_pause()
  371. #define alarm(A)        pthread_alarm(A)
  372. #define    select(A,B,C,D,E)    pthread_select((A),(B),(C),(D),(E))
  373. #define    sleep(A)        pthread_sleep(A)
  374. #define read(A,B,C)        pthread_read((A),(B),(C))
  375. #define write(A,B,C)        pthread_write((A),(B),(C))
  376. #endif
  377.