scheduler/pthread.c

   1 /*
   2  * pthread emulation for re-entrant libcs
   3  *
   4  * We can't use pthreads directly, so why not let libcs
   5  * that wants pthreads use Wine's own threading instead...
   6  *
   7  * Copyright 1999 Ove Kåven
   8  */
   9
  10 #include "config.h"
  11
  12 #include <errno.h>
  13 #include <stdlib.h>
  14 #include <unistd.h>
  15
  16 #include "winbase.h"
  17 #include "heap.h"
  18 #include "thread.h"
  19
  20 /* Currently this probably works only for glibc2,
  21  * which checks for the presence of double-underscore-prepended
  22  * pthread primitives, and use them if available.
  23  * If they are not available, the libc defaults to
  24  * non-threadsafe operation (not good). */
  25
  26 #if defined(__GLIBC__)
  27 #include <pthread.h>
  28
  29 #ifdef NEED_UNDERSCORE_PREFIX
  30 # define PREFIX "_"
  31 #else
  32 # define PREFIX
  33 #endif
  34
  35 /* adapt as necessary (a construct like this is used in glibc sources) */
  36 #define strong_alias(orig, alias) \
  37  asm(".globl " PREFIX #alias "\n\t.set " PREFIX #alias "," PREFIX #orig)
  38
  39 /* NOTE: This is a truly extremely incredibly ugly hack!
  40  * But it does seem to work... */
  41
  42 /* assume that pthread_mutex_t has room for at least one pointer,
  43  * and hope that the users of pthread_mutex_t considers it opaque
  44  * (never checks what's in it) */
  45 typedef struct {
  46   CRITICAL_SECTION *critsect;
  47 } *wine_mutex;
  48
  49 typedef struct _wine_cleanup {
  50   void (*routine)(void *);
  51   void *arg;
  52 } *wine_cleanup;
  53
  54 typedef const void *key_data;
  55
  56 #define FIRST_KEY 0
  57 #define MAX_KEYS 16 /* libc6 doesn't use that many, but... */
  58
  59 static CRITICAL_SECTION init_sect = CRITICAL_SECTION_INIT;
  60
  61 #define P_OUTPUT(stuff) write(2,stuff,strlen(stuff))
  62
  63 void __pthread_initialize(void)
  64 {
  65 }
  66
  67 int __pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
  68 {
  69   static pthread_once_t the_once = PTHREAD_ONCE_INIT;
  70
  71   EnterCriticalSection(&init_sect);
  72   if (!memcmp(once_control,&the_once,sizeof(the_once))) {
  73     (*init_routine)();
  74     (*(int *)once_control)++;
  75   }
  76   LeaveCriticalSection(&init_sect);
  77   return 0;
  78 }
  79 strong_alias(__pthread_once, pthread_once);
  80
  81 int __pthread_mutex_init(pthread_mutex_t *mutex,
  82                         const pthread_mutexattr_t *mutexattr)
  83 {
  84   /* glibc has a tendency to initialize mutexes very often, even
  85      in situations where they are not really used later on.
  86
  87      As for us, initializing a mutex is very expensive, we postpone
  88      the real initialization until the time the mutex is first used. */
  89
  90   ((wine_mutex)mutex)->critsect = NULL;
  91   return 0;
  92 }
  93 strong_alias(__pthread_mutex_init, pthread_mutex_init);
  94
  95 static void mutex_real_init( pthread_mutex_t *mutex )
  96 {
  97   EnterCriticalSection(&init_sect);
  98
  99   if (!((wine_mutex)mutex)->critsect) {
 100     ((wine_mutex)mutex)->critsect = HeapAlloc(SystemHeap, 0, sizeof(CRITICAL_SECTION));
 101     InitializeCriticalSection(((wine_mutex)mutex)->critsect);
 102   }
 103
 104   LeaveCriticalSection(&init_sect);
 105 }
 106
 107 int __pthread_mutex_lock(pthread_mutex_t *mutex)
 108 {
 109   if (!SystemHeap) return 0;
 110   if (!((wine_mutex)mutex)->critsect)
 111     mutex_real_init( mutex );
 112
 113   EnterCriticalSection(((wine_mutex)mutex)->critsect);
 114   return 0;
 115 }
 116 strong_alias(__pthread_mutex_lock, pthread_mutex_lock);
 117
 118 int __pthread_mutex_trylock(pthread_mutex_t *mutex)
 119 {
 120   if (!SystemHeap) return 0;
 121   if (!((wine_mutex)mutex)->critsect)
 122     mutex_real_init( mutex );
 123
 124   if (!TryEnterCriticalSection(((wine_mutex)mutex)->critsect)) {
 125     errno = EBUSY;
 126     return -1;
 127   }
 128   return 0;
 129 }
 130 strong_alias(__pthread_mutex_trylock, pthread_mutex_trylock);
 131
 132 int __pthread_mutex_unlock(pthread_mutex_t *mutex)
 133 {
 134   if (!((wine_mutex)mutex)->critsect) return 0;
 135   LeaveCriticalSection(((wine_mutex)mutex)->critsect);
 136   return 0;
 137 }
 138 strong_alias(__pthread_mutex_unlock, pthread_mutex_unlock);
 139
 140 int __pthread_mutex_destroy(pthread_mutex_t *mutex)
 141 {
 142   if (!((wine_mutex)mutex)->critsect) return 0;
 143   if (((wine_mutex)mutex)->critsect->RecursionCount) {
 144 #if 0 /* there seems to be a bug in libc6 that makes this a bad idea */
 145     return EBUSY;
 146 #else
 147     while (((wine_mutex)mutex)->critsect->RecursionCount)
 148       LeaveCriticalSection(((wine_mutex)mutex)->critsect);
 149 #endif
 150   }
 151   DeleteCriticalSection(((wine_mutex)mutex)->critsect);
 152   HeapFree(SystemHeap, 0, ((wine_mutex)mutex)->critsect);
 153   return 0;
 154 }
 155 strong_alias(__pthread_mutex_destroy, pthread_mutex_destroy);
 156
 157 int __pthread_atfork(void (*prepare)(void),
 158                      void (*parent)(void),
 159                      void (*child)(void))
 160 {
 161   /* are we going to fork? nah */
 162   return 0;
 163 }
 164 strong_alias(__pthread_atfork, pthread_atfork);
 165
 166 int __pthread_mutexattr_init(pthread_mutexattr_t *attr)
 167 {
 168   return 0;
 169 }
 170 strong_alias(__pthread_mutexattr_init, pthread_mutexattr_init);
 171
 172 int __pthread_mutexattr_destroy(pthread_mutexattr_t *attr)
 173 {
 174   return 0;
 175 }
 176 strong_alias(__pthread_mutexattr_destroy, pthread_mutexattr_destroy);
 177
 178 int __pthread_mutexattr_setkind_np(pthread_mutexattr_t *attr, int kind)
 179 {
 180   return 0;
 181 }
 182 strong_alias(__pthread_mutexattr_setkind_np, pthread_mutexattr_setkind_np);
 183
 184 int __pthread_mutexattr_getkind_np(pthread_mutexattr_t *attr, int *kind)
 185 {
 186   *kind = PTHREAD_MUTEX_RECURSIVE_NP;
 187   return 0;
 188 }
 189 strong_alias(__pthread_mutexattr_getkind_np, pthread_mutexattr_getkind_np);
 190
 191 int __pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind)
 192 {
 193   return 0;
 194 }
 195 strong_alias(__pthread_mutexattr_settype, pthread_mutexattr_settype);
 196
 197 int __pthread_mutexattr_gettype(pthread_mutexattr_t *attr, int *kind)
 198 {
 199   *kind = PTHREAD_MUTEX_RECURSIVE_NP;
 200   return 0;
 201 }
 202 strong_alias(__pthread_mutexattr_gettype, pthread_mutexattr_gettype);
 203
 204 int __pthread_key_create(pthread_key_t *key, void (*destr_function)(void *))
 205 {
 206   static pthread_key_t keycnt = FIRST_KEY;
 207   EnterCriticalSection(&init_sect);
 208   *key = keycnt++;
 209   LeaveCriticalSection(&init_sect);
 210   return 0;
 211 }
 212 strong_alias(__pthread_key_create, pthread_key_create);
 213
 214 int __pthread_key_delete(pthread_key_t key)
 215 {
 216   return 0;
 217 }
 218 strong_alias(__pthread_key_delete, pthread_key_delete);
 219
 220 int __pthread_setspecific(pthread_key_t key, const void *pointer)
 221 {
 222   TEB *teb = NtCurrentTeb();
 223   if (!teb->pthread_data) {
 224     teb->pthread_data = calloc(MAX_KEYS,sizeof(key_data));
 225   }
 226   ((key_data*)(teb->pthread_data))[key] = pointer;
 227   return 0;
 228 }
 229 strong_alias(__pthread_setspecific, pthread_setspecific);
 230
 231 void *__pthread_getspecific(pthread_key_t key)
 232 {
 233   TEB *teb = NtCurrentTeb();
 234   if (!teb) return NULL;
 235   if (!teb->pthread_data) return NULL;
 236   return (void *)(((key_data*)(teb->pthread_data))[key]);
 237 }
 238 strong_alias(__pthread_getspecific, pthread_getspecific);
 239
 240 void _pthread_cleanup_push(struct _pthread_cleanup_buffer *buffer, void (*routine)(void *), void *arg)
 241 {
 242   ((wine_cleanup)buffer)->routine = routine;
 243   ((wine_cleanup)buffer)->arg = arg;
 244 }
 245
 246 void _pthread_cleanup_pop(struct _pthread_cleanup_buffer *buffer, int execute)
 247 {
 248   if (execute) (*(((wine_cleanup)buffer)->routine))(((wine_cleanup)buffer)->arg);
 249 }
 250
 251 void _pthread_cleanup_push_defer(struct _pthread_cleanup_buffer *buffer, void (*routine)(void *), void *arg)
 252 {
 253   _pthread_cleanup_push(buffer, routine, arg);
 254 }
 255
 256 void _pthread_cleanup_pop_restore(struct _pthread_cleanup_buffer *buffer, int execute)
 257 {
 258   _pthread_cleanup_pop(buffer, execute);
 259 }
 260
 261 pthread_t pthread_self(void)
 262 {
 263   return (pthread_t)GetCurrentThreadId();
 264 }
 265
 266 int pthread_equal(pthread_t thread1, pthread_t thread2)
 267 {
 268   return (DWORD)thread1 == (DWORD)thread2;
 269 }
 270
 271 int pthread_setcanceltype(int type, int *oldtype)
 272 {
 273   if (oldtype) *oldtype = PTHREAD_CANCEL_ASYNCHRONOUS;
 274   return 0;
 275 }
 276
 277 #endif /* __GLIBC__ */