dbus/dbus-sysdeps-thread-win.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-sysdeps-pthread.c Implements threads using Windows threads (internal to libdbus)
   3  *
   4  * Copyright (C) 2006  Red Hat, Inc.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  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  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #include <config.h>
  25 #include "dbus-internals.h"
  26 #include "dbus-sysdeps.h"
  27 #include "dbus-sysdeps-win.h"
  28 #include "dbus-threads.h"
  29 #include "dbus-list.h"
  30
  31 #include <windows.h>
  32
  33 struct DBusCondVar {
  34   DBusList *list;        /**< list thread-local-stored events waiting on the cond variable */
  35   CRITICAL_SECTION lock; /**< lock protecting the list */
  36 };
  37
  38 static DWORD dbus_cond_event_tls = TLS_OUT_OF_INDEXES;
  39
  40
  41 static HMODULE dbus_dll_hmodule;
  42
  43 void *
  44 _dbus_win_get_dll_hmodule (void)
  45 {
  46   return dbus_dll_hmodule;
  47 }
  48
  49 #ifdef DBUS_WINCE
  50 #define hinst_t HANDLE
  51 #else
  52 #define hinst_t HINSTANCE
  53 #endif
  54
  55 BOOL WINAPI DllMain (hinst_t, DWORD, LPVOID);
  56
  57 /* We need this to free the TLS events on thread exit */
  58 BOOL WINAPI
  59 DllMain (hinst_t hinstDLL,
  60          DWORD     fdwReason,
  61          LPVOID    lpvReserved)
  62 {
  63   HANDLE event;
  64   switch (fdwReason)
  65     {
  66     case DLL_PROCESS_ATTACH:
  67       dbus_dll_hmodule = hinstDLL;
  68       break;
  69     case DLL_THREAD_DETACH:
  70       if (dbus_cond_event_tls != TLS_OUT_OF_INDEXES)
  71         {
  72           event = TlsGetValue(dbus_cond_event_tls);
  73           CloseHandle (event);
  74           TlsSetValue(dbus_cond_event_tls, NULL);
  75         }
  76       break;
  77     case DLL_PROCESS_DETACH:
  78       if (dbus_cond_event_tls != TLS_OUT_OF_INDEXES)
  79         {
  80           event = TlsGetValue(dbus_cond_event_tls);
  81           CloseHandle (event);
  82           TlsSetValue(dbus_cond_event_tls, NULL);
  83
  84           TlsFree(dbus_cond_event_tls);
  85         }
  86       break;
  87     default:
  88       break;
  89     }
  90   return TRUE;
  91 }
  92
  93 static DBusMutex*
  94 _dbus_windows_mutex_new (void)
  95 {
  96   HANDLE handle;
  97   handle = CreateMutex (NULL, FALSE, NULL);
  98   return (DBusMutex *) handle;
  99 }
 100
 101 static void
 102 _dbus_windows_mutex_free (DBusMutex *mutex)
 103 {
 104   CloseHandle ((HANDLE *) mutex);
 105 }
 106
 107 static dbus_bool_t
 108 _dbus_windows_mutex_lock (DBusMutex *mutex)
 109 {
 110   return WaitForSingleObject ((HANDLE *) mutex, INFINITE) != WAIT_FAILED;
 111 }
 112
 113 static dbus_bool_t
 114 _dbus_windows_mutex_unlock (DBusMutex *mutex)
 115 {
 116   return ReleaseMutex ((HANDLE *) mutex) != 0;
 117 }
 118
 119 static DBusCondVar *
 120 _dbus_windows_condvar_new (void)
 121 {
 122   DBusCondVar *cond;
 123
 124   cond = dbus_new (DBusCondVar, 1);
 125   if (cond == NULL)
 126     return NULL;
 127
 128   cond->list = NULL;
 129
 130   InitializeCriticalSection (&cond->lock);
 131   return (DBusCondVar *) cond;
 132 }
 133
 134 static void
 135 _dbus_windows_condvar_free (DBusCondVar *cond)
 136 {
 137   DeleteCriticalSection (&cond->lock);
 138   _dbus_list_clear (&cond->list);
 139   dbus_free (cond);
 140 }
 141
 142 static dbus_bool_t
 143 _dbus_condvar_wait_win32 (DBusCondVar *cond,
 144                           DBusMutex *mutex,
 145                           int milliseconds)
 146 {
 147   DWORD retval;
 148   dbus_bool_t ret;
 149   HANDLE event = TlsGetValue (dbus_cond_event_tls);
 150
 151   if (!event)
 152     {
 153       event = CreateEvent (0, FALSE, FALSE, NULL);
 154       if (event == 0)
 155         return FALSE;
 156       TlsSetValue (dbus_cond_event_tls, event);
 157     }
 158
 159   EnterCriticalSection (&cond->lock);
 160
 161   /* The event must not be signaled. Check this */
 162   _dbus_assert (WaitForSingleObject (event, 0) == WAIT_TIMEOUT);
 163
 164   ret = _dbus_list_append (&cond->list, event);
 165
 166   LeaveCriticalSection (&cond->lock);
 167
 168   if (!ret)
 169     return FALSE; /* Prepend failed */
 170
 171   _dbus_mutex_unlock (mutex);
 172   retval = WaitForSingleObject (event, milliseconds);
 173   _dbus_mutex_lock (mutex);
 174
 175   if (retval == WAIT_TIMEOUT)
 176     {
 177       EnterCriticalSection (&cond->lock);
 178       _dbus_list_remove (&cond->list, event);
 179
 180       /* In the meantime we could have been signaled, so we must again
 181        * wait for the signal, this time with no timeout, to reset
 182        * it. retval is set again to honour the late arrival of the
 183        * signal */
 184       retval = WaitForSingleObject (event, 0);
 185
 186       LeaveCriticalSection (&cond->lock);
 187     }
 188
 189 #ifndef DBUS_DISABLE_ASSERT
 190   EnterCriticalSection (&cond->lock);
 191
 192   /* Now event must not be inside the array, check this */
 193   _dbus_assert (_dbus_list_remove (&cond->list, event) == FALSE);
 194
 195   LeaveCriticalSection (&cond->lock);
 196 #endif /* !G_DISABLE_ASSERT */
 197
 198   return retval != WAIT_TIMEOUT;
 199 }
 200
 201 static void
 202 _dbus_windows_condvar_wait (DBusCondVar *cond,
 203                             DBusMutex   *mutex)
 204 {
 205   _dbus_condvar_wait_win32 (cond, mutex, INFINITE);
 206 }
 207
 208 static dbus_bool_t
 209 _dbus_windows_condvar_wait_timeout (DBusCondVar               *cond,
 210                                      DBusMutex                 *mutex,
 211                                      int                        timeout_milliseconds)
 212 {
 213   return _dbus_condvar_wait_win32 (cond, mutex, timeout_milliseconds);
 214 }
 215
 216 static void
 217 _dbus_windows_condvar_wake_one (DBusCondVar *cond)
 218 {
 219   EnterCriticalSection (&cond->lock);
 220
 221   if (cond->list != NULL)
 222     SetEvent (_dbus_list_pop_first (&cond->list));
 223
 224   LeaveCriticalSection (&cond->lock);
 225 }
 226
 227 static void
 228 _dbus_windows_condvar_wake_all (DBusCondVar *cond)
 229 {
 230   EnterCriticalSection (&cond->lock);
 231
 232   while (cond->list != NULL)
 233     SetEvent (_dbus_list_pop_first (&cond->list));
 234
 235   LeaveCriticalSection (&cond->lock);
 236 }
 237
 238 static const DBusThreadFunctions windows_functions =
 239 {
 240   DBUS_THREAD_FUNCTIONS_MUTEX_NEW_MASK |
 241   DBUS_THREAD_FUNCTIONS_MUTEX_FREE_MASK |
 242   DBUS_THREAD_FUNCTIONS_MUTEX_LOCK_MASK |
 243   DBUS_THREAD_FUNCTIONS_MUTEX_UNLOCK_MASK |
 244   DBUS_THREAD_FUNCTIONS_CONDVAR_NEW_MASK |
 245   DBUS_THREAD_FUNCTIONS_CONDVAR_FREE_MASK |
 246   DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_MASK |
 247   DBUS_THREAD_FUNCTIONS_CONDVAR_WAIT_TIMEOUT_MASK |
 248   DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ONE_MASK|
 249   DBUS_THREAD_FUNCTIONS_CONDVAR_WAKE_ALL_MASK,
 250   _dbus_windows_mutex_new,
 251   _dbus_windows_mutex_free,
 252   _dbus_windows_mutex_lock,
 253   _dbus_windows_mutex_unlock,
 254   _dbus_windows_condvar_new,
 255   _dbus_windows_condvar_free,
 256   _dbus_windows_condvar_wait,
 257   _dbus_windows_condvar_wait_timeout,
 258   _dbus_windows_condvar_wake_one,
 259   _dbus_windows_condvar_wake_all
 260 };
 261
 262 dbus_bool_t
 263 _dbus_threads_init_platform_specific (void)
 264 {
 265   /* We reuse this over several generations, because we can't
 266    * free the events once they are in use
 267    */
 268   if (dbus_cond_event_tls == TLS_OUT_OF_INDEXES)
 269     {
 270       dbus_cond_event_tls = TlsAlloc ();
 271       if (dbus_cond_event_tls == TLS_OUT_OF_INDEXES)
 272         return FALSE;
 273     }
 274
 275   return dbus_threads_init (&windows_functions);
 276 }
 277