lib/silcutil/win32/silcwin32thread.c

   1 /*
   2
   3   silcwin32thread.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2001 - 2006 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19 /* $Id$ */
  20
  21 #include "silc.h"
  22
  23 /**************************** SILC Thread API *******************************/
  24
  25 #ifdef SILC_THREADS
  26
  27 /* Thread structure for WIN32 */
  28 typedef struct {
  29   HANDLE thread;
  30   SilcThreadStart start_func;
  31   void *context;
  32   SilcBool waitable;
  33 } *SilcWin32Thread;
  34
  35 static DWORD silc_thread_tls;
  36
  37 /* Actual routine that is called by WIN32 when the thread is created.
  38    We will call the start_func from here. When this returns the thread
  39    is destroyed. */
  40
  41 unsigned __stdcall silc_thread_win32_start(void *context)
  42 {
  43   SilcWin32Thread thread = (SilcWin32Thread)context;
  44
  45   TlsSetValue(silc_thread_tls, context);
  46   silc_thread_exit(thread->start_func(thread->context));
  47
  48   return 0;
  49 }
  50 #endif
  51
  52 SilcThread silc_thread_create(SilcThreadStart start_func, void *context,
  53                               SilcBool waitable)
  54 {
  55 #ifdef SILC_THREADS
  56   SilcWin32Thread thread;
  57   unsigned id;
  58
  59   SILC_LOG_DEBUG(("Creating new thread"));
  60
  61   thread = silc_calloc(1, sizeof(*thread));
  62   thread->start_func = start_func;
  63   thread->context = context;
  64   thread->waitable = waitable;
  65   thread->thread =
  66     CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)silc_thread_win32_start,
  67                  (void *)thread, 0, &id);
  68
  69   if (!thread->thread) {
  70     SILC_LOG_ERROR(("Could not create new thread"));
  71     silc_free(thread);
  72     return NULL;
  73   }
  74
  75   return (SilcThread)thread;
  76 #else
  77   /* Call thread callback immediately */
  78   (*start_func)(context);
  79   return NULL;
  80 #endif
  81 }
  82
  83 void silc_thread_exit(void *exit_value)
  84 {
  85 #ifdef SILC_THREADS
  86   SilcWin32Thread thread = TlsGetValue(silc_thread_tls);
  87
  88   if (thread) {
  89     /* If the thread is waitable the memory is freed only in silc_thread_wait
  90        by another thread. If not waitable, free it now. */
  91     if (!thread->waitable) {
  92       TerminateThread(thread->thread, 0);
  93       silc_free(thread);
  94     }
  95
  96     TlsSetValue(silc_thread_tls, NULL);
  97   }
  98   ExitThread(0);
  99 #endif
 100 }
 101
 102 SilcThread silc_thread_self(void)
 103 {
 104 #ifdef SILC_THREADS
 105   SilcWin32Thread self = TlsGetValue(silc_thread_tls);
 106
 107   if (!self) {
 108     /* This should only happen for the main thread! */
 109     HANDLE handle = GetCurrentThread ();
 110     HANDLE process = GetCurrentProcess ();
 111     self = silc_calloc(1, sizeof(*self));
 112     DuplicateHandle(process, handle, process,
 113                     &self->thread, 0, FALSE,
 114                     DUPLICATE_SAME_ACCESS);
 115     TlsSetValue(silc_thread_tls, self);
 116   }
 117
 118   return (SilcThread)self;
 119         #else
 120   return NULL;
 121 #endif
 122 }
 123
 124 SilcBool silc_thread_wait(SilcThread thread, void **exit_value)
 125 {
 126 #ifdef SILC_THREADS
 127   SilcWin32Thread self = (SilcWin32Thread)thread;
 128
 129   SILC_LOG_DEBUG(("Waiting for thread %p", self));
 130
 131   if (!self->waitable)
 132     return FALSE;
 133
 134   /* The thread is waitable thus we will free all memory after the
 135      WaitForSingleObject returns, the thread is destroyed after that. */
 136   if (WaitForSingleObject(self->thread, 2500) == WAIT_TIMEOUT)
 137     TerminateThread(self->thread, 0);
 138
 139   silc_free(self);
 140   if (exit_value)
 141     *exit_value = NULL;
 142
 143   return TRUE;
 144 #else
 145   return FALSE;
 146 #endif
 147 }
 148
 149
 150 /***************************** SILC Mutex API *******************************/
 151
 152 /* SILC Mutex structure */
 153 struct SilcMutexStruct {
 154 #ifdef SILC_THREADS
 155   CRITICAL_SECTION mutex;
 156 #endif /* SILC_THREADS */
 157   unsigned int locked : 1;
 158 };
 159
 160 SilcBool silc_mutex_alloc(SilcMutex *mutex)
 161 {
 162 #ifdef SILC_THREADS
 163   *mutex = silc_calloc(1, sizeof(**mutex));
 164   if (!(*mutex))
 165     return FALSE;
 166   InitializeCriticalSection(&((*mutex)->mutex));
 167   return TRUE;
 168 #else
 169   return FALSE;
 170 #endif /* SILC_THREADS */
 171 }
 172
 173 void silc_mutex_free(SilcMutex mutex)
 174 {
 175 #ifdef SILC_THREADS
 176   if (mutex) {
 177     DeleteCriticalSection(&mutex->mutex);
 178     silc_free(mutex);
 179   }
 180 #endif /* SILC_THREADS */
 181 }
 182
 183 void silc_mutex_lock(SilcMutex mutex)
 184 {
 185 #ifdef SILC_THREADS
 186   if (mutex) {
 187     EnterCriticalSection(&mutex->mutex);
 188     SILC_ASSERT(mutex->locked == FALSE);
 189     mutex->locked = TRUE;
 190   }
 191 #endif /* SILC_THREADS */
 192 }
 193
 194 void silc_mutex_unlock(SilcMutex mutex)
 195 {
 196 #ifdef SILC_THREADS
 197   if (mutex) {
 198     SILC_ASSERT(mutex->locked == TRUE);
 199     mutex->locked = FALSE;
 200     LeaveCriticalSection(&mutex->mutex);
 201   }
 202 #endif /* SILC_THREADS */
 203 }
 204
 205 void silc_mutex_assert_locked(SilcMutex mutex)
 206 {
 207 #ifdef SILC_THREADS
 208   if (mutex)
 209     SILC_ASSERT(mutex->locked);
 210 #endif /* SILC_THREADS */
 211 }
 212
 213
 214 /**************************** SILC Cond API ******************************/
 215
 216 /* SILC Conditional Variable context */
 217 struct SilcCondStruct {
 218 #ifdef SILC_THREADS
 219   HANDLE event;
 220 #endif /* SILC_THREADS*/
 221   unsigned int waiters : 23;
 222   unsigned int signal  : 1;
 223 };
 224
 225 SilcBool silc_cond_alloc(SilcCond *cond)
 226 {
 227 #ifdef SILC_THREADS
 228   *cond = silc_calloc(1, sizeof(**cond));
 229   if (*cond == NULL)
 230     return FALSE;
 231   (*cond)->event = CreateEvent(NULL, TRUE, FALSE, NULL);
 232   return TRUE;
 233 #else
 234   return FALSE;
 235 #endif /* SILC_THREADS*/
 236 }
 237
 238 void silc_cond_free(SilcCond cond)
 239 {
 240 #ifdef SILC_THREADS
 241   CloseHandle(cond->event);
 242   silc_free(cond);
 243 #endif /* SILC_THREADS*/
 244 }
 245
 246 void silc_cond_signal(SilcCond cond)
 247 {
 248 #ifdef SILC_THREADS
 249   cond->signal = TRUE;
 250   SetEvent(cond->event);
 251 #endif /* SILC_THREADS*/
 252 }
 253
 254 void silc_cond_broadcast(SilcCond cond)
 255 {
 256 #ifdef SILC_THREADS
 257   cond->signal = TRUE;
 258   SetEvent(cond->event);
 259 #endif /* SILC_THREADS*/
 260 }
 261
 262 void silc_cond_wait(SilcCond cond, SilcMutex mutex)
 263 {
 264 #ifdef SILC_THREADS
 265   silc_cond_timedwait(cond, mutex, NULL);
 266 #endif /* SILC_THREADS*/
 267 }
 268
 269 SilcBool silc_cond_timedwait(SilcCond cond, SilcMutex mutex,
 270                              int timeout)
 271 {
 272 #ifdef SILC_THREADS
 273   DWORD ret, t = INFINITE;
 274
 275   if (timeout)
 276     t = timeout;
 277
 278   while (TRUE) {
 279     cond->waiters++;
 280     silc_mutex_unlock(mutex);
 281
 282     ret = WaitForSingleObject(cond->event, t);
 283
 284     silc_mutex_lock(mutex);
 285     cond->waiters--;
 286
 287     if (ret != WAIT_OBJECT_0)
 288       return FALSE;
 289
 290     if (cond->signal) {
 291       cond->signal = FALSE;
 292       ResetEvent(cond->event);
 293       break;
 294     }
 295   }
 296 #endif /* SILC_THREADS*/
 297 }