winsup/cygwin/thread.h

   1 /* thread.h: Locking and threading module definitions
   2
   3    Copyright 1998, 1999 Cygnus Solutions.
   4
   5    Written by Marco Fuykschot <marco@ddi.nl>
   6
   7 This file is part of Cygwin.
   8
   9 This software is a copyrighted work licensed under the terms of the
  10 Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
  11 details. */
  12
  13 #ifndef _CYGNUS_THREADS_
  14 #define _CYGNUS_THREADS_
  15
  16 #define LOCK_FD_LIST     1
  17 #define LOCK_MEMORY_LIST 2
  18 #define LOCK_MMAP_LIST   3
  19 #define LOCK_DLL_LIST    4
  20 #define LOCK_THREAD_LIST 5
  21 #define LOCK_MUTEX_LIST  6
  22 #define LOCK_SEM_LIST    7
  23
  24 #define WRITE_LOCK 1
  25 #define READ_LOCK  2
  26
  27 extern "C"
  28 {
  29 #if defined (_CYG_THREAD_FAILSAFE) && defined (_MT_SAFE)
  30   void AssertResourceOwner (int, int);
  31 #else
  32 #define AssertResourceOwner(i,ii)
  33 #endif
  34 }
  35
  36 #ifndef _MT_SAFE
  37
  38 #define SetResourceLock(i,n,c)
  39 #define ReleaseResourceLock(i,n,c)
  40
  41 #else
  42
  43 #include <pthread.h>
  44 #include <pwd.h>
  45 #include <grp.h>
  46 #include <stdio.h>
  47 #include <mntent.h>
  48 #include <time.h>
  49
  50 extern "C" {
  51
  52 struct _winsup_t
  53 {
  54 /*
  55  Needed for the group functions
  56 */
  57   struct group _grp;
  58   char *_namearray[2];
  59   char _linebuf[100];
  60   int _grp_pos;
  61
  62 /* console.cc */
  63   unsigned _rarg;
  64   char _my_title_buf[TITLESIZE + 1];
  65
  66 /* dlfcn.cc */
  67   int _dl_error;
  68   char _dl_buffer[256];
  69
  70 /* passwd.cc */
  71   struct passwd _res;
  72   char _tmpbuf[100];
  73   char _pass[_PASSWORD_LEN];
  74   int _pw_pos;
  75
  76 /* path.cc */
  77   struct mntent _ret;
  78   char *_current_directory_name;
  79   char *_current_directory_posix_name;
  80   unsigned long _current_directory_hash;
  81   int _iteration;
  82
  83 /* strerror */
  84   char _strerror_buf[20];
  85
  86 /* syscalls.cc */
  87   char _dacl_buf[1024];
  88   char _sacl_buf[1024];
  89   char _ownr_buf[1024];
  90   char _grp_buf[1024];
  91
  92 /* sysloc.cc */
  93   char *_process_ident;
  94   int _process_logopt;
  95   int _process_facility;
  96   int _process_logmask;
  97
  98 /* times.cc */
  99   char _b[20];
 100   struct tm _localtime_buf;
 101   char _buf1[33];
 102   char _buf2[33];
 103
 104 /* uinfo.cc */
 105   char _username[MAX_USER_NAME];
 106 };
 107
 108
 109 struct __reent_t
 110 {
 111   struct _reent *_clib;
 112   struct _winsup_t *_winsup;
 113 };
 114
 115 _reent *_reent_clib ();
 116 _winsup_t *_reent_winsup ();
 117 void SetResourceLock (int, int, const char *);
 118 void ReleaseResourceLock (int, int, const char *);
 119
 120 #ifdef _CYG_THREAD_FAILSAFE
 121 void AssertResourceOwner (int, int);
 122 #else
 123 #define AssertResourceOwner(i,ii)
 124 #endif
 125 }
 126
 127 class per_process;
 128 class pinfo;
 129
 130 class ResourceLocks
 131 {
 132 public:
 133 ResourceLocks ():inited (false) {};
 134 LPCRITICAL_SECTION Lock (int);
 135 void Init ();
 136 void Delete ();
 137 #ifdef _CYG_THREAD_FAILSAFE
 138 DWORD owner;
 139 DWORD count;
 140 #endif
 141 private:
 142 CRITICAL_SECTION lock;
 143 bool inited;
 144 };
 145
 146
 147 #define MT_MAX_ITEMS 128
 148
 149 // thread classes\lists
 150
 151 class MTitem
 152 {
 153 public:
 154 HANDLE win32_obj_id;
 155 UINT return_value;
 156 bool used;
 157 char joinable;       // for thread only
 158 bool HandleOke () {return win32_obj_id;};
 159 virtual void Destroy ();
 160 virtual int Id () {return (int) win32_obj_id;};
 161 };
 162
 163 class ThreadItem:public MTitem
 164 {
 165 public:
 166 pthread_attr_t attr;
 167 TFD (function);
 168 void *arg;
 169 void *return_ptr;
 170 bool suspended;
 171 DWORD thread_id;
 172 DWORD GetThreadId () {return thread_id;};
 173
 174 /* signal handling */
 175 struct sigaction *sigs;
 176 sigset_t *sigmask;
 177 LONG *sigtodo;
 178 };
 179
 180 class MutexItem:public MTitem
 181 {
 182 public:
 183 int Lock ();
 184 int TryLock ();
 185 int UnLock ();
 186 };
 187
 188 class SemaphoreItem:public MTitem
 189 {
 190 public:
 191 int shared;
 192 int Wait ();
 193 int Post ();
 194 int TryWait ();
 195 };
 196
 197
 198 typedef struct
 199 {
 200 MTitem *items[MT_MAX_ITEMS];
 201 int index;
 202 }
 203 MTList;
 204
 205 class MTinterface
 206 {
 207 public:
 208 // General
 209 DWORD reent_index;
 210 DWORD thread_key;
 211
 212 // Used for main thread data, and sigproc thread
 213 struct __reent_t reents;
 214 struct _winsup_t winsup_reent;
 215 ThreadItem mainthread;
 216
 217 void Init0 ();
 218 void Init1 ();
 219 void ClearReent ();
 220
 221 void ReleaseItem (MTitem *);
 222
 223 // Thread functions
 224 ThreadItem *CreateThread (pthread_t *, TFD (func), void *, pthread_attr_t);
 225 ThreadItem *GetCallingThread ();
 226 ThreadItem *GetThread (pthread_t *);
 227
 228 // Mutex functions
 229 MutexItem *CreateMutex (pthread_mutex_t *);
 230 MutexItem *GetMutex (pthread_mutex_t *);
 231
 232 // Semaphore functions
 233 SemaphoreItem *CreateSemaphore (sem_t *, int, int);
 234 SemaphoreItem *GetSemaphore (sem_t * t);
 235
 236 private:
 237 // General Administration
 238 MTitem * Find (void *, int (*compare) (void *, void *), int &, MTList *);
 239 MTitem *GetItem (int, MTList *);
 240 MTitem *SetItem (int, MTitem *, MTList *);
 241 int Find (MTitem &, MTList *);
 242 int FindNextUnused (MTList *);
 243
 244 MTList threadlist;
 245 MTList mutexlist;
 246 MTList semalist;
 247 };
 248
 249
 250 extern "C"
 251 {
 252
 253 void *thread_init_wrapper (void *);
 254
 255 /*  ThreadCreation */
 256 int __pthread_create (pthread_t * thread, const pthread_attr_t * attr, TFD (start_routine), void *arg);
 257 int __pthread_attr_init (pthread_attr_t * attr);
 258 int __pthread_attr_destroy (pthread_attr_t * attr);
 259 int __pthread_attr_setstacksize (pthread_attr_t * attr, size_t size);
 260 int __pthread_attr_getstacksize (pthread_attr_t * attr, size_t * size);
 261 /*
 262 __pthread_attr_setstackaddr(...);
 263 __pthread_attr_getstackaddr(...);
 264 */
 265
 266 /* Thread Exit */
 267 int __pthread_exit (void *value_ptr);
 268 int __pthread_join(pthread_t *thread, void **return_val);
 269 int __pthread_detach(pthread_t *thread);
 270
 271 /* Thread suspend */
 272
 273 int __pthread_suspend(pthread_t *thread);
 274 int __pthread_continue(pthread_t *thread);
 275
 276 unsigned long __pthread_getsequence_np (pthread_t * thread);
 277
 278 /* Thread SpecificData */
 279 int __pthread_key_create (pthread_key_t * key);
 280 int __pthread_key_delete (pthread_key_t * key);
 281 int __pthread_setspecific (pthread_key_t * key, const void *value);
 282 void *__pthread_getspecific (pthread_key_t * key);
 283
 284
 285 /* Thread signal */
 286 int __pthread_kill (pthread_t * thread, int sig);
 287 int __pthread_sigmask (int operation, const sigset_t * set, sigset_t * old_set);
 288
 289 /*  ID */
 290 pthread_t __pthread_self ();
 291 int __pthread_equal (pthread_t * t1, pthread_t * t2);
 292
 293
 294 /* Mutexes  */
 295 int __pthread_mutex_init (pthread_mutex_t *, const pthread_mutexattr_t *);
 296 int __pthread_mutex_lock (pthread_mutex_t *);
 297 int __pthread_mutex_trylock (pthread_mutex_t *);
 298 int __pthread_mutex_unlock (pthread_mutex_t *);
 299 int __pthread_mutex_destroy (pthread_mutex_t *);
 300
 301 /* Semaphores */
 302 int __sem_init (sem_t * sem, int pshared, unsigned int value);
 303 int __sem_destroy (sem_t * sem);
 304 int __sem_wait (sem_t * sem);
 305 int __sem_trywait (sem_t * sem);
 306 int __sem_post (sem_t * sem);
 307
 308 };
 309
 310 #endif                          // MT_SAFE
 311
 312 #endif                          // _CYGNUS_THREADS_