source: win32/libpthreads-w32-2.8.0/include/implement.h @ 256

Last change on this file since 256 was 191, checked in by tim, 15 years ago

updated scons build scripts to handle MinGW
added binaries for MinGW build dependencies
File size: 20.4 KB
Line 
1/*
2 * implement.h
3 *
4 * Definitions that don't need to be public.
5 *
6 * Keeps all the internals out of pthread.h
7 *
8 * --------------------------------------------------------------------------
9 *
10 *      Pthreads-win32 - POSIX Threads Library for Win32
11 *      Copyright(C) 1998 John E. Bossom
12 *      Copyright(C) 1999,2005 Pthreads-win32 contributors
13 *
14 *      Contact Email: rpj@callisto.canberra.edu.au
15 *
16 *      The current list of contributors is contained
17 *      in the file CONTRIBUTORS included with the source
18 *      code distribution. The list can also be seen at the
19 *      following World Wide Web location:
20 *      http://sources.redhat.com/pthreads-win32/contributors.html
21 *
22 *      This library is free software; you can redistribute it and/or
23 *      modify it under the terms of the GNU Lesser General Public
24 *      License as published by the Free Software Foundation; either
25 *      version 2 of the License, or (at your option) any later version.
26 *
27 *      This library is distributed in the hope that it will be useful,
28 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
29 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
30 *      Lesser General Public License for more details.
31 *
32 *      You should have received a copy of the GNU Lesser General Public
33 *      License along with this library in the file COPYING.LIB;
34 *      if not, write to the Free Software Foundation, Inc.,
35 *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
36 */
37
38#ifndef _IMPLEMENT_H
39#define _IMPLEMENT_H
40
41#ifdef _WIN32_WINNT
42#undef _WIN32_WINNT
43#endif
44#define _WIN32_WINNT 0x400
45
46#include <windows.h>
47
48/*
49 * In case windows.h doesn't define it (e.g. WinCE perhaps)
50 */
51#ifdef WINCE
52typedef VOID (APIENTRY *PAPCFUNC)(DWORD dwParam);
53#endif
54
55/*
56 * note: ETIMEDOUT is correctly defined in winsock.h
57 */
58#include <winsock.h>
59
60/*
61 * In case ETIMEDOUT hasn't been defined above somehow.
62 */
63#ifndef ETIMEDOUT
64#  define ETIMEDOUT 10060       /* This is the value in winsock.h. */
65#endif
66
67#if !defined(malloc)
68#include <malloc.h>
69#endif
70
71#if !defined(INT_MAX)
72#include <limits.h>
73#endif
74
75/* use local include files during development */
76#include "semaphore.h"
77#include "sched.h"
78
79#if defined(HAVE_C_INLINE) || defined(__cplusplus)
80#define INLINE inline
81#else
82#define INLINE
83#endif
84
85#if defined (__MINGW32__) || (_MSC_VER >= 1300)
86#define PTW32_INTERLOCKED_LONG long
87#define PTW32_INTERLOCKED_LPLONG long*
88#else
89#define PTW32_INTERLOCKED_LONG PVOID
90#define PTW32_INTERLOCKED_LPLONG PVOID*
91#endif
92
93#if defined(__MINGW32__)
94#include <stdint.h>
95#elif defined(__BORLANDC__)
96#define int64_t ULONGLONG
97#else
98#define int64_t _int64
99#endif
100
101typedef enum
102{
103  /*
104   * This enumeration represents the state of the thread;
105   * The thread is still "alive" if the numeric value of the
106   * state is greater or equal "PThreadStateRunning".
107   */
108  PThreadStateInitial = 0,      /* Thread not running                   */
109  PThreadStateRunning,          /* Thread alive & kicking               */
110  PThreadStateSuspended,        /* Thread alive but suspended           */
111  PThreadStateCancelPending,    /* Thread alive but is                  */
112  /* has cancelation pending.        */
113  PThreadStateCanceling,        /* Thread alive but is                  */
114  /* in the process of terminating        */
115  /* due to a cancellation request        */
116  PThreadStateException,        /* Thread alive but exiting             */
117  /* due to an exception                  */
118  PThreadStateLast
119}
120PThreadState;
121
122
123typedef struct ptw32_thread_t_ ptw32_thread_t;
124
125struct ptw32_thread_t_
126{
127#ifdef _UWIN
128  DWORD dummy[5];
129#endif
130  DWORD thread;
131  HANDLE threadH;               /* Win32 thread handle - POSIX thread is invalid if threadH == 0 */
132  pthread_t ptHandle;           /* This thread's permanent pthread_t handle */
133  ptw32_thread_t * prevReuse;   /* Links threads on reuse stack */
134  volatile PThreadState state;
135  void *exitStatus;
136  void *parms;
137  int ptErrno;
138  int detachState;
139  pthread_mutex_t threadLock;   /* Used for serialised access to public thread state */
140  int sched_priority;           /* As set, not as currently is */
141  pthread_mutex_t cancelLock;   /* Used for async-cancel safety */
142  int cancelState;
143  int cancelType;
144  HANDLE cancelEvent;
145#ifdef __CLEANUP_C
146  jmp_buf start_mark;
147#endif                          /* __CLEANUP_C */
148#if HAVE_SIGSET_T
149  sigset_t sigmask;
150#endif                          /* HAVE_SIGSET_T */
151  int implicit:1;
152  void *keys;
153  void *nextAssoc;
154};
155
156
157/*
158 * Special value to mark attribute objects as valid.
159 */
160#define PTW32_ATTR_VALID ((unsigned long) 0xC4C0FFEE)
161
162struct pthread_attr_t_
163{
164  unsigned long valid;
165  void *stackaddr;
166  size_t stacksize;
167  int detachstate;
168  struct sched_param param;
169  int inheritsched;
170  int contentionscope;
171#if HAVE_SIGSET_T
172  sigset_t sigmask;
173#endif                          /* HAVE_SIGSET_T */
174};
175
176
177/*
178 * ====================
179 * ====================
180 * Semaphores, Mutexes and Condition Variables
181 * ====================
182 * ====================
183 */
184
185struct sem_t_
186{
187  int value;
188  pthread_mutex_t lock;
189  HANDLE sem;
190#ifdef NEED_SEM
191  int leftToUnblock;
192#endif
193};
194
195#define PTW32_OBJECT_AUTO_INIT ((void *) -1)
196#define PTW32_OBJECT_INVALID   NULL
197
198struct pthread_mutex_t_
199{
200  LONG lock_idx;                /* Provides exclusive access to mutex state
201                                   via the Interlocked* mechanism.
202                                    0: unlocked/free.
203                                    1: locked - no other waiters.
204                                   -1: locked - with possible other waiters.
205                                */
206  int recursive_count;          /* Number of unlocks a thread needs to perform
207                                   before the lock is released (recursive
208                                   mutexes only). */
209  int kind;                     /* Mutex type. */
210  pthread_t ownerThread;
211  HANDLE event;                 /* Mutex release notification to waiting
212                                   threads. */
213};
214
215struct pthread_mutexattr_t_
216{
217  int pshared;
218  int kind;
219};
220
221/*
222 * Possible values, other than PTW32_OBJECT_INVALID,
223 * for the "interlock" element in a spinlock.
224 *
225 * In this implementation, when a spinlock is initialised,
226 * the number of cpus available to the process is checked.
227 * If there is only one cpu then "interlock" is set equal to
228 * PTW32_SPIN_USE_MUTEX and u.mutex is a initialised mutex.
229 * If the number of cpus is greater than 1 then "interlock"
230 * is set equal to PTW32_SPIN_UNLOCKED and the number is
231 * stored in u.cpus. This arrangement allows the spinlock
232 * routines to attempt an InterlockedCompareExchange on "interlock"
233 * immediately and, if that fails, to try the inferior mutex.
234 *
235 * "u.cpus" isn't used for anything yet, but could be used at
236 * some point to optimise spinlock behaviour.
237 */
238#define PTW32_SPIN_UNLOCKED    (1)
239#define PTW32_SPIN_LOCKED      (2)
240#define PTW32_SPIN_USE_MUTEX   (3)
241
242struct pthread_spinlock_t_
243{
244  long interlock;               /* Locking element for multi-cpus. */
245  union
246  {
247    int cpus;                   /* No. of cpus if multi cpus, or   */
248    pthread_mutex_t mutex;      /* mutex if single cpu.            */
249  } u;
250};
251
252struct pthread_barrier_t_
253{
254  unsigned int nCurrentBarrierHeight;
255  unsigned int nInitialBarrierHeight;
256  int iStep;
257  int pshared;
258  sem_t semBarrierBreeched[2];
259};
260
261struct pthread_barrierattr_t_
262{
263  int pshared;
264};
265
266struct pthread_key_t_
267{
268  DWORD key;
269  void (*destructor) (void *);
270  pthread_mutex_t keyLock;
271  void *threads;
272};
273
274
275typedef struct ThreadParms ThreadParms;
276typedef struct ThreadKeyAssoc ThreadKeyAssoc;
277
278struct ThreadParms
279{
280  pthread_t tid;
281  void *(*start) (void *);
282  void *arg;
283};
284
285
286struct pthread_cond_t_
287{
288  long nWaitersBlocked;         /* Number of threads blocked            */
289  long nWaitersGone;            /* Number of threads timed out          */
290  long nWaitersToUnblock;       /* Number of threads to unblock         */
291  sem_t semBlockQueue;          /* Queue up threads waiting for the     */
292  /*   condition to become signalled      */
293  sem_t semBlockLock;           /* Semaphore that guards access to      */
294  /* | waiters blocked count/block queue  */
295  /* +-> Mandatory Sync.LEVEL-1           */
296  pthread_mutex_t mtxUnblockLock;       /* Mutex that guards access to          */
297  /* | waiters (to)unblock(ed) counts     */
298  /* +-> Optional* Sync.LEVEL-2           */
299  pthread_cond_t next;          /* Doubly linked list                   */
300  pthread_cond_t prev;
301};
302
303
304struct pthread_condattr_t_
305{
306  int pshared;
307};
308
309#define PTW32_RWLOCK_MAGIC 0xfacade2
310
311struct pthread_rwlock_t_
312{
313  pthread_mutex_t mtxExclusiveAccess;
314  pthread_mutex_t mtxSharedAccessCompleted;
315  pthread_cond_t cndSharedAccessCompleted;
316  int nSharedAccessCount;
317  int nExclusiveAccessCount;
318  int nCompletedSharedAccessCount;
319  int nMagic;
320};
321
322struct pthread_rwlockattr_t_
323{
324  int pshared;
325};
326
327/*
328 * MCS lock queue node - see ptw32_MCS_lock.c
329 */
330struct ptw32_mcs_node_t_
331{
332  struct ptw32_mcs_node_t_ **lock;        /* ptr to tail of queue */
333  struct ptw32_mcs_node_t_  *next;        /* ptr to successor in queue */
334  LONG                       readyFlag;   /* set after lock is released by
335                                             predecessor */
336  LONG                       nextFlag;    /* set after 'next' ptr is set by
337                                             successor */
338};
339
340typedef struct ptw32_mcs_node_t_   ptw32_mcs_local_node_t;
341typedef struct ptw32_mcs_node_t_  *ptw32_mcs_lock_t;
342
343
344struct ThreadKeyAssoc
345{
346  /*
347   * Purpose:
348   *      This structure creates an association between a thread and a key.
349   *      It is used to implement the implicit invocation of a user defined
350   *      destroy routine for thread specific data registered by a user upon
351   *      exiting a thread.
352   *
353   *      Graphically, the arrangement is as follows, where:
354   *
355   *         K - Key with destructor
356   *            (head of chain is key->threads)
357   *         T - Thread that has called pthread_setspecific(Kn)
358   *            (head of chain is thread->keys)
359   *         A - Association. Each association is a node at the
360   *             intersection of two doubly-linked lists.
361   *
362   *                 T1    T2    T3
363   *                 |     |     |
364   *                 |     |     |
365   *         K1 -----+-----A-----A----->
366   *                 |     |     |
367   *                 |     |     |
368   *         K2 -----A-----A-----+----->
369   *                 |     |     |
370   *                 |     |     |
371   *         K3 -----A-----+-----A----->
372   *                 |     |     |
373   *                 |     |     |
374   *                 V     V     V
375   *
376   *      Access to the association is guarded by two locks: the key's
377   *      general lock (guarding the row) and the thread's general
378   *      lock (guarding the column). This avoids the need for a
379   *      dedicated lock for each association, which not only consumes
380   *      more handles but requires that: before the lock handle can
381   *      be released - both the key must be deleted and the thread
382   *      must have called the destructor. The two-lock arrangement
383   *      allows the resources to be freed as soon as either thread or
384   *      key is concluded.
385   *
386   *      To avoid deadlock: whenever both locks are required, the key
387   *      and thread locks are always acquired in the order: key lock
388   *      then thread lock. An exception to this exists when a thread
389   *      calls the destructors, however this is done carefully to
390   *      avoid deadlock.
391   *
392   *      An association is created when a thread first calls
393   *      pthread_setspecific() on a key that has a specified
394   *      destructor.
395   *
396   *      An association is destroyed either immediately after the
397   *      thread calls the key destructor function on thread exit, or
398   *      when the key is deleted.
399   *
400   * Attributes:
401   *      thread
402   *              reference to the thread that owns the
403   *              association. This is actually the pointer to the
404   *              thread struct itself. Since the association is
405   *              destroyed before the thread exits, this can never
406   *              point to a different logical thread to the one that
407   *              created the assoc, i.e. after thread struct reuse.
408   *
409   *      key
410   *              reference to the key that owns the association.
411   *
412   *      nextKey
413   *              The pthread_t->keys attribute is the head of a
414   *              chain of associations that runs through the nextKey
415   *              link. This chain provides the 1 to many relationship
416   *              between a pthread_t and all pthread_key_t on which
417   *              it called pthread_setspecific.
418   *
419   *      prevKey
420   *              Similarly.
421   *
422   *      nextThread
423   *              The pthread_key_t->threads attribute is the head of
424   *              a chain of assoctiations that runs through the
425   *              nextThreads link. This chain provides the 1 to many
426   *              relationship between a pthread_key_t and all the
427   *              PThreads that have called pthread_setspecific for
428   *              this pthread_key_t.
429   *
430   *      prevThread
431   *              Similarly.
432   *
433   * Notes:
434   *      1)      As soon as either the key or the thread is no longer
435   *              referencing the association, it can be destroyed. The
436   *              association will be removed from both chains.
437   *
438   *      2)      Under WIN32, an association is only created by
439   *              pthread_setspecific if the user provided a
440   *              destroyRoutine when they created the key.
441   *
442   *
443   */
444  ptw32_thread_t * thread;
445  pthread_key_t key;
446  ThreadKeyAssoc *nextKey;
447  ThreadKeyAssoc *nextThread;
448  ThreadKeyAssoc *prevKey;
449  ThreadKeyAssoc *prevThread;
450};
451
452
453#ifdef __CLEANUP_SEH
454/*
455 * --------------------------------------------------------------
456 * MAKE_SOFTWARE_EXCEPTION
457 *      This macro constructs a software exception code following
458 *      the same format as the standard Win32 error codes as defined
459 *      in WINERROR.H
460 *  Values are 32 bit values layed out as follows:
461 *
462 *   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
463 *  +---+-+-+-----------------------+-------------------------------+
464 *  |Sev|C|R|     Facility          |               Code            |
465 *  +---+-+-+-----------------------+-------------------------------+
466 *
467 * Severity Values:
468 */
469#define SE_SUCCESS              0x00
470#define SE_INFORMATION          0x01
471#define SE_WARNING              0x02
472#define SE_ERROR                0x03
473
474#define MAKE_SOFTWARE_EXCEPTION( _severity, _facility, _exception ) \
475( (DWORD) ( ( (_severity) << 30 ) |     /* Severity code        */ \
476            ( 1 << 29 ) |               /* MS=0, User=1         */ \
477            ( 0 << 28 ) |               /* Reserved             */ \
478            ( (_facility) << 16 ) |     /* Facility Code        */ \
479            ( (_exception) <<  0 )      /* Exception Code       */ \
480            ) )
481
482/*
483 * We choose one specific Facility/Error code combination to
484 * identify our software exceptions vs. WIN32 exceptions.
485 * We store our actual component and error code within
486 * the optional information array.
487 */
488#define EXCEPTION_PTW32_SERVICES        \
489     MAKE_SOFTWARE_EXCEPTION( SE_ERROR, \
490                              PTW32_SERVICES_FACILITY, \
491                              PTW32_SERVICES_ERROR )
492
493#define PTW32_SERVICES_FACILITY         0xBAD
494#define PTW32_SERVICES_ERROR            0xDEED
495
496#endif /* __CLEANUP_SEH */
497
498/*
499 * Services available through EXCEPTION_PTW32_SERVICES
500 * and also used [as parameters to ptw32_throw()] as
501 * generic exception selectors.
502 */
503
504#define PTW32_EPS_EXIT                  (1)
505#define PTW32_EPS_CANCEL                (2)
506
507
508/* Useful macros */
509#define PTW32_MAX(a,b)  ((a)<(b)?(b):(a))
510#define PTW32_MIN(a,b)  ((a)>(b)?(b):(a))
511
512
513/* Declared in global.c */
514extern PTW32_INTERLOCKED_LONG (WINAPI *
515                               ptw32_interlocked_compare_exchange)
516  (PTW32_INTERLOCKED_LPLONG, PTW32_INTERLOCKED_LONG, PTW32_INTERLOCKED_LONG);
517
518/* Declared in pthread_cancel.c */
519extern DWORD (*ptw32_register_cancelation) (PAPCFUNC, HANDLE, DWORD);
520
521/* Thread Reuse stack bottom marker. Must not be NULL or any valid pointer to memory. */
522#define PTW32_THREAD_REUSE_EMPTY ((ptw32_thread_t *) 1)
523
524extern int ptw32_processInitialized;
525extern ptw32_thread_t * ptw32_threadReuseTop;
526extern ptw32_thread_t * ptw32_threadReuseBottom;
527extern pthread_key_t ptw32_selfThreadKey;
528extern pthread_key_t ptw32_cleanupKey;
529extern pthread_cond_t ptw32_cond_list_head;
530extern pthread_cond_t ptw32_cond_list_tail;
531
532extern int ptw32_mutex_default_kind;
533
534extern int ptw32_concurrency;
535
536extern int ptw32_features;
537
538extern BOOL ptw32_smp_system;  /* True: SMP system, False: Uni-processor system */
539
540extern CRITICAL_SECTION ptw32_thread_reuse_lock;
541extern CRITICAL_SECTION ptw32_mutex_test_init_lock;
542extern CRITICAL_SECTION ptw32_cond_list_lock;
543extern CRITICAL_SECTION ptw32_cond_test_init_lock;
544extern CRITICAL_SECTION ptw32_rwlock_test_init_lock;
545extern CRITICAL_SECTION ptw32_spinlock_test_init_lock;
546
547#ifdef _UWIN
548extern int pthread_count;
549#endif
550
551#ifdef __cplusplus
552extern "C"
553{
554#endif                          /* __cplusplus */
555
556/*
557 * =====================
558 * =====================
559 * Forward Declarations
560 * =====================
561 * =====================
562 */
563
564  int ptw32_is_attr (const pthread_attr_t * attr);
565
566  int ptw32_cond_check_need_init (pthread_cond_t * cond);
567  int ptw32_mutex_check_need_init (pthread_mutex_t * mutex);
568  int ptw32_rwlock_check_need_init (pthread_rwlock_t * rwlock);
569
570  PTW32_INTERLOCKED_LONG WINAPI
571    ptw32_InterlockedCompareExchange (PTW32_INTERLOCKED_LPLONG location,
572                                      PTW32_INTERLOCKED_LONG value,
573                                      PTW32_INTERLOCKED_LONG comparand);
574
575  LONG WINAPI
576    ptw32_InterlockedExchange (LPLONG location,
577                               LONG value);
578
579  DWORD
580    ptw32_RegisterCancelation (PAPCFUNC callback,
581                               HANDLE threadH, DWORD callback_arg);
582
583  int ptw32_processInitialize (void);
584
585  void ptw32_processTerminate (void);
586
587  void ptw32_threadDestroy (pthread_t tid);
588
589  void ptw32_pop_cleanup_all (int execute);
590
591  pthread_t ptw32_new (void);
592
593  pthread_t ptw32_threadReusePop (void);
594
595  void ptw32_threadReusePush (pthread_t thread);
596
597  int ptw32_getprocessors (int *count);
598
599  int ptw32_setthreadpriority (pthread_t thread, int policy, int priority);
600
601  void ptw32_rwlock_cancelwrwait (void *arg);
602
603#if ! defined (__MINGW32__) || defined (__MSVCRT__)
604  unsigned __stdcall
605#else
606  void
607#endif
608    ptw32_threadStart (void *vthreadParms);
609
610  void ptw32_callUserDestroyRoutines (pthread_t thread);
611
612  int ptw32_tkAssocCreate (ptw32_thread_t * thread, pthread_key_t key);
613
614  void ptw32_tkAssocDestroy (ThreadKeyAssoc * assoc);
615
616  int ptw32_semwait (sem_t * sem);
617
618  DWORD ptw32_relmillisecs (const struct timespec * abstime);
619
620  void ptw32_mcs_lock_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node);
621
622  void ptw32_mcs_lock_release (ptw32_mcs_local_node_t * node);
623
624#ifdef NEED_FTIME
625  void ptw32_timespec_to_filetime (const struct timespec *ts, FILETIME * ft);
626  void ptw32_filetime_to_timespec (const FILETIME * ft, struct timespec *ts);
627#endif
628
629/* Declared in misc.c */
630#ifdef NEED_CALLOC
631#define calloc(n, s) ptw32_calloc(n, s)
632  void *ptw32_calloc (size_t n, size_t s);
633#endif
634
635/* Declared in private.c */
636  void ptw32_throw (DWORD exception);
637
638#ifdef __cplusplus
639}
640#endif                          /* __cplusplus */
641
642
643#ifdef _UWIN_
644#   ifdef       _MT
645#       ifdef __cplusplus
646extern "C"
647{
648#       endif
649  _CRTIMP unsigned long __cdecl _beginthread (void (__cdecl *) (void *),
650                                              unsigned, void *);
651  _CRTIMP void __cdecl _endthread (void);
652  _CRTIMP unsigned long __cdecl _beginthreadex (void *, unsigned,
653                                                unsigned (__stdcall *) (void *),
654                                                void *, unsigned, unsigned *);
655  _CRTIMP void __cdecl _endthreadex (unsigned);
656#       ifdef __cplusplus
657}
658#       endif
659#   endif
660#else
661#   include <process.h>
662#endif
663
664
665/*
666 * Defaults. Could be overridden when building the inlined version of the dll.
667 * See ptw32_InterlockedCompareExchange.c
668 */
669#ifndef PTW32_INTERLOCKED_COMPARE_EXCHANGE
670#define PTW32_INTERLOCKED_COMPARE_EXCHANGE ptw32_interlocked_compare_exchange
671#endif
672
673#ifndef PTW32_INTERLOCKED_EXCHANGE
674#define PTW32_INTERLOCKED_EXCHANGE InterlockedExchange
675#endif
676
677
678/*
679 * Check for old and new versions of cygwin. See the FAQ file:
680 *
681 * Question 1 - How do I get pthreads-win32 to link under Cygwin or Mingw32?
682 *
683 * Patch by Anders Norlander <anorland@hem2.passagen.se>
684 */
685#if defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(NEED_CREATETHREAD)
686
687/*
688 * Macro uses args so we can cast start_proc to LPTHREAD_START_ROUTINE
689 * in order to avoid warnings because of return type
690 */
691
692#define _beginthreadex(security, \
693                       stack_size, \
694                       start_proc, \
695                       arg, \
696                       flags, \
697                       pid) \
698        CreateThread(security, \
699                     stack_size, \
700                     (LPTHREAD_START_ROUTINE) start_proc, \
701                     arg, \
702                     flags, \
703                     pid)
704
705#define _endthreadex ExitThread
706
707#endif                          /* __CYGWIN32__ || __CYGWIN__ || NEED_CREATETHREAD */
708
709
710#endif                          /* _IMPLEMENT_H */
Note: See TracBrowser for help on using the repository browser.