path: root/implement.h

/*
 * implement.h
 *
 * Definitions that don't need to be public.
 *
 * Keeps all the internals out of pthread.h
 *
 * Pthreads-win32 - POSIX Threads Library for Win32
 * Copyright (C) 1998
 *
 * This 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.
 *
 * This 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 this library; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA
 */

#ifndef _IMPLEMENT_H
#define _IMPLEMENT_H

#ifdef __MINGW32__
#define PT_STDCALL
#else
#ifdef __cplusplus
#define PT_STDCALL __stdcall
#else
#define PT_STDCALL __stdcall
#endif
#endif

/* changed include from <semaphore.h> to use local file during development */
#include "semaphore.h"

typedef enum {
  /*
   * This enumeration represents the state of the thread;
   * The thread is still "alive" if the numeric value of the
   * state is greater or equal "PThreadStateRunning".
   */
  PThreadStateInitial = 0,      /* Thread not running                   */
  PThreadStateRunning,          /* Thread alive & kicking               */
  PThreadStateSuspended,        /* Thread alive but suspended           */
  PThreadStateCanceling,        /* Thread alive but and is              */
                                /* in the process of terminating        */
                                /* due to a cancellation request        */
  PThreadStateException,        /* Thread alive but exiting             */
                                /* due to an exception                  */
  PThreadStateLast
}
PThreadState;


typedef enum {
  /*
   * This enumeration represents the reason why a thread has
   * terminated/is terminating.
   */
  PThreadDemisePeaceful = 0,    /* Death due natural causes     */
  PThreadDemiseCancelled,       /* Death due to user cancel     */
  PThreadDemiseException,       /* Death due to unhandled       */
                                /* exception                    */
  PThreadDemiseNotDead  /* I'm not dead!                */
}
PThreadDemise;

struct pthread_t_ {
  DWORD             thread;
  HANDLE            threadH;
  PThreadState      state;
  PThreadDemise     demise;
  void *            exitStatus;
  void *            parms;
  int               ptErrno;
  int               detachState;
  CriticalSection   cancelLock;  /* Used for async-cancel safety */
  int               cancelState;
  int               cancelType;
  HANDLE            cancelEvent;
#if HAVE_SIGSET_T
  sigset_t          sigmask;
#endif /* HAVE_SIGSET_T */
  int               implicit:1;
  void *            keys;
};


/* 
 * Special value to mark attribute objects as valid.
 */
#define PTW32_ATTR_VALID ((unsigned long) 0xC4C0FFEE)

struct pthread_attr_t_ {
  unsigned long     valid;
  void *            stackaddr;
  size_t            stacksize;
  int               detachstate;
  int               priority;
#if HAVE_SIGSET_T
  sigset_t          sigmask;
#endif /* HAVE_SIGSET_T */
};


/*
 * ====================
 * ====================
 * Mutexes and Condition Variables
 * ====================
 * ====================
 */

/*
 * The following macros are used to serialise access to an object,
 * including possibly before it is initialised.
 * See mutex.c:pthread_mutex_lock() for an example.
 */

#define PTW32_OBJECT_GET(type, pObject, Dest) \
  while (((Dest) = (type) InterlockedExchange((LPLONG)(pObject), \
                                              (LONG)PTW32_OBJECT_IN_USE)) \
         == (type)PTW32_OBJECT_IN_USE) \
    { \
      Sleep(0); \
    }

#define PTW32_OBJECT_SET(pObject, value) \
  (void) InterlockedExchange((LPLONG)(pObject), (LONG)(value))

#define PTW32_OBJECT_TRYGET(type, pObject, Dest) \
  ((((Dest) = (type) InterlockedExchange((LPLONG)(pObject), \
                                         (LONG)PTW32_OBJECT_IN_USE)) \
    == (type)PTW32_OBJECT_IN_USE) ? ((void) InterlockedExchange((LPLONG)(pObject), \
                                                                (LONG)(Dest)) , 0) \
                                  : 1)

#define PTW32_OBJECT_IN_USE    ((void *) -2)
#define PTW32_OBJECT_AUTO_INIT ((void *) -1)
#define PTW32_OBJECT_INVALID   NULL

struct pthread_mutexattr_t_ {
  int               pshared;
  int               type;
};

struct pthread_mutex_t_ {
  long              lock_idx;
  long              try_lock;
  int               pshared;
  int               type;
  pthread_t         owner;
  long              waiters;     /* These last elements ensure fairness */
  pthread_t         lastOwner;   /* and guard against canceled threads. */
  pthread_t         lastWaiter;
};

struct pthread_key_t_ {
  DWORD             key;
  void (*destructor) (void *);
  pthread_mutex_t   threadsLock;
  void *            threads;
};


typedef struct ThreadParms ThreadParms;
typedef struct ThreadKeyAssoc ThreadKeyAssoc;

struct ThreadParms {
  pthread_t         tid;
  void *(*start)   (void *);
  void *            arg;
};


struct pthread_cond_t_ {
  long            nWaitersBlocked;   /* Number of threads blocked            */
  long            nWaitersUnblocked; /* Number of threads unblocked          */
  long            nWaitersToUnblock; /* Number of threads to unblock         */
  sem_t           semBlockQueue;     /* Queue up threads waiting for the     */
                                     /*   condition to become signalled      */
  sem_t           semBlockLock;      /* Semaphore that guards access to      */
                                     /* | waiters blocked count/block queue  */
                                     /* +-> Mandatory Sync.LEVEL-1           */
  pthread_mutex_t mtxUnblockLock;    /* Mutex that guards access to          */
                                     /* | waiters (to)unblock(ed) counts     */
                                     /* +-> Optional* Sync.LEVEL-2           */
};                                   /* Opt*) for _timedwait and cancellation*/


struct pthread_condattr_t_ {
  int               pshared;
};

#define PTW32_RWLOCK_MAGIC 0xfacade2

struct pthread_rwlock_t_ {
  pthread_mutex_t   mtxExclusiveAccess;
  pthread_mutex_t   mtxSharedAccessCompleted;
  pthread_cond_t    cndSharedAccessCompleted;
  int               nSharedAccessCount;
  int               nExclusiveAccessCount;
  int               nCompletedSharedAccessCount;
  int               nMagic;
};

struct pthread_rwlockattr_t_ {
  int               pshared;
};

struct ThreadKeyAssoc {
  /*
   * Purpose:
   *      This structure creates an association between a
   *      thread and a key.
   *      It is used to implement the implicit invocation
   *      of a user defined destroy routine for thread
   *      specific data registered by a user upon exiting a
   *      thread.
   *
   * Attributes:
   *      lock
   *              protects access to the rest of the structure
   *
   *      thread
   *              reference to the thread that owns the association.
   *              As long as this is not NULL, the association remains
   *              referenced by the pthread_t.
   *
   *      key
   *              reference to the key that owns the association.
   *              As long as this is not NULL, the association remains
   *              referenced by the pthread_key_t.
   *
   *      nextKey
   *              The pthread_t->keys attribute is the head of a
   *              chain of associations that runs through the nextKey
   *              link. This chain provides the 1 to many relationship
   *              between a pthread_t and all pthread_key_t on which
   *              it called pthread_setspecific.
   *
   *      nextThread
   *              The pthread_key_t->threads attribute is the head of
   *              a chain of assoctiations that runs through the
   *              nextThreads link. This chain provides the 1 to many
   *              relationship between a pthread_key_t and all the 
   *              PThreads that have called pthread_setspecific for
   *              this pthread_key_t.
   *
   *
   * Notes:
   *      1)      As long as one of the attributes, thread or key, is
   *              not NULL, the association is being referenced; once
   *              both are NULL, the association must be released.
   *
   *      2)      Under WIN32, an association is only created by
   *              pthread_setspecific if the user provided a
   *              destroyRoutine when they created the key.
   *
   *
   */
  pthread_mutex_t   lock;
  pthread_t         thread;
  pthread_key_t     key;
  ThreadKeyAssoc *  nextKey;
  ThreadKeyAssoc *  nextThread;
};


#if defined(_MSC_VER) && !defined(__cplusplus)
/*
 * --------------------------------------------------------------
 * MAKE_SOFTWARE_EXCEPTION
 *      This macro constructs a software exception code following
 *      the same format as the standard Win32 error codes as defined
 *      in WINERROR.H
 *  Values are 32 bit values layed out as follows:
 *
 *   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
 *  +---+-+-+-----------------------+-------------------------------+
 *  |Sev|C|R|     Facility          |               Code            |
 *  +---+-+-+-----------------------+-------------------------------+
 *
 * Severity Values:
 */
#define SE_SUCCESS              0x00
#define SE_INFORMATION          0x01
#define SE_WARNING              0x02
#define SE_ERROR                0x03

#define MAKE_SOFTWARE_EXCEPTION( _severity, _facility, _exception ) \
( (DWORD) ( ( (_severity) << 30 ) |     /* Severity code        */ \
            ( 1 << 29 ) |               /* MS=0, User=1         */ \
            ( 0 << 28 ) |               /* Reserved             */ \
            ( (_facility) << 16 ) |     /* Facility Code        */ \
            ( (_exception) <<  0 )      /* Exception Code       */ \
            ) )

/*
 * We choose one specific Facility/Error code combination to
 * identify our software exceptions vs. WIN32 exceptions.
 * We store our actual component and error code within
 * the optional information array.
 */
#define EXCEPTION_PTW32_SERVICES        \
     MAKE_SOFTWARE_EXCEPTION( SE_ERROR, \
                              PTW32_SERVICES_FACILITY, \
                              PTW32_SERVICES_ERROR )

#define PTW32_SERVICES_FACILITY         0xBAD
#define PTW32_SERVICES_ERROR            0xDEED

#endif /* _MSC_VER */

/*
 * Services available through EXCEPTION_PTW32_SERVICES
 * and also used [as parameters to ptw32_throw()] as
 * generic exception selectors.
 */
#define PTW32_EPS_CANCEL       0
#define PTW32_EPS_EXIT         1


/* Declared in global.c */
extern int ptw32_processInitialized;
extern pthread_key_t ptw32_selfThreadKey;
extern pthread_key_t ptw32_cleanupKey;
extern CRITICAL_SECTION ptw32_mutex_test_init_lock;
extern CRITICAL_SECTION ptw32_cond_test_init_lock;
extern CRITICAL_SECTION ptw32_rwlock_test_init_lock;
extern BOOL (WINAPI *ptw32_try_enter_critical_section)(LPCRITICAL_SECTION);
extern int ptw32_mutex_mapped_default;

/* Declared in misc.c */
#ifdef NEED_CALLOC
#define calloc(n, s) ptw32_calloc(n, s)
void *ptw32_calloc(size_t n, size_t s);
#endif

/* Declared in private.c */
void ptw32_throw(DWORD exception);

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/*
 * =====================
 * =====================
 * Forward Declarations
 * =====================
 * =====================
 */
int ptw32_processInitialize (void);

void ptw32_processTerminate (void);

void ptw32_threadDestroy (pthread_t tid);

void ptw32_cleanupStack (void);

pthread_t ptw32_new (void);

#if ! defined (__MINGW32__) || defined (__MSVCRT__)
unsigned PT_STDCALL
#else
void
#endif
ptw32_threadStart (ThreadParms * threadParms);

void ptw32_callUserDestroyRoutines (pthread_t thread);

int ptw32_tkAssocCreate (ThreadKeyAssoc ** assocP,
                            pthread_t thread,
                            pthread_key_t key);

void ptw32_tkAssocDestroy (ThreadKeyAssoc * assoc);

int ptw32_sem_timedwait (sem_t * sem,
                            const struct timespec * abstime);

#ifdef NEED_SEM
void ptw32_decrease_semaphore(sem_t * sem);
BOOL ptw32_increase_semaphore(sem_t * sem,
                                 unsigned int n);
#endif /* NEED_SEM */

#ifdef __cplusplus
}
#endif /* __cplusplus */


/*
 * Check for old and new versions of cygwin. See the FAQ file:
 *
 * Question 1 - How do I get pthreads-win32 to link under Cygwin or Mingw32?
 *
 * Patch by Anders Norlander <anorland@hem2.passagen.se>
 */
#if defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(NEED_CREATETHREAD)

/* 
 * Macro uses args so we can cast start_proc to LPTHREAD_START_ROUTINE
 * in order to avoid warnings because of return type
 */

#define _beginthreadex(security, \
                       stack_size, \
                       start_proc, \
                       arg, \
                       flags, \
                       pid) \
        CreateThread(security, \
                     stack_size, \
                     (LPTHREAD_START_ROUTINE) start_proc, \
                     arg, \
                     flags, \
                     pid)

#define _endthreadex ExitThread

#endif /* __CYGWIN32__ || __CYGWIN__ || NEED_CREATETHREAD*/


#endif /* _IMPLEMENT_H */