contrib/ntp/lib/isc/win32/condition.c

   1 /*
   2  * Copyright (C) 2004, 2006, 2007  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1998-2001  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: condition.c,v 1.23 2007/06/18 23:47:49 tbox Exp $ */
  19
  20 #include <config.h>
  21
  22 #include <isc/condition.h>
  23 #include <isc/assertions.h>
  24 #include <isc/util.h>
  25 #include <isc/thread.h>
  26 #include <isc/time.h>
  27
  28 #define LSIGNAL         0
  29 #define LBROADCAST      1
  30
  31 isc_result_t
  32 isc_condition_init(isc_condition_t *cond) {
  33         HANDLE h;
  34
  35         REQUIRE(cond != NULL);
  36
  37         cond->waiters = 0;
  38         /*
  39          * This handle is shared across all threads
  40          */
  41         h = CreateEvent(NULL, FALSE, FALSE, NULL);
  42         if (h == NULL) {
  43                 /* XXX */
  44                 return (ISC_R_UNEXPECTED);
  45         }
  46         cond->events[LSIGNAL] = h;
  47
  48         /*
  49          * The threadlist will hold the actual events needed
  50          * for the wait condition
  51          */
  52         ISC_LIST_INIT(cond->threadlist);
  53
  54         return (ISC_R_SUCCESS);
  55 }
  56
  57 /*
  58  * Add the thread to the threadlist along with the required events
  59  */
  60 static isc_result_t
  61 register_thread(unsigned long thrd, isc_condition_t *gblcond,
  62                 isc_condition_thread_t **localcond)
  63 {
  64         HANDLE hc;
  65         isc_condition_thread_t *newthread;
  66
  67         REQUIRE(localcond != NULL && *localcond == NULL);
  68
  69         newthread = malloc(sizeof(isc_condition_thread_t));
  70         if (newthread == NULL)
  71                 return (ISC_R_NOMEMORY);
  72
  73         /*
  74          * Create the thread-specific handle
  75          */
  76         hc = CreateEvent(NULL, FALSE, FALSE, NULL);
  77         if (hc == NULL) {
  78                 free(newthread);
  79                 return (ISC_R_UNEXPECTED);
  80         }
  81
  82         /*
  83          * Add the thread ID and handles to list of threads for broadcast
  84          */
  85         newthread->handle[LSIGNAL] = gblcond->events[LSIGNAL];
  86         newthread->handle[LBROADCAST] = hc;
  87         newthread->th = thrd;
  88
  89         /*
  90          * The thread is holding the manager lock so this is safe
  91          */
  92         ISC_LIST_APPEND(gblcond->threadlist, newthread, link);
  93         *localcond = newthread;
  94         return (ISC_R_SUCCESS);
  95 }
  96
  97 static isc_result_t
  98 find_thread_condition(unsigned long thrd, isc_condition_t *cond,
  99                       isc_condition_thread_t **threadcondp)
 100 {
 101         isc_condition_thread_t *threadcond;
 102
 103         REQUIRE(threadcondp != NULL && *threadcondp == NULL);
 104
 105         /*
 106          * Look for the thread ID.
 107          */
 108         for (threadcond = ISC_LIST_HEAD(cond->threadlist);
 109              threadcond != NULL;
 110              threadcond = ISC_LIST_NEXT(threadcond, link)) {
 111
 112                 if (threadcond->th == thrd) {
 113                         *threadcondp = threadcond;
 114                         return (ISC_R_SUCCESS);
 115                 }
 116         }
 117
 118         /*
 119          * Not found, so add it.
 120          */
 121         return (register_thread(thrd, cond, threadcondp));
 122 }
 123
 124 isc_result_t
 125 isc_condition_signal(isc_condition_t *cond) {
 126
 127         /*
 128          * Unlike pthreads, the caller MUST hold the lock associated with
 129          * the condition variable when calling us.
 130          */
 131         REQUIRE(cond != NULL);
 132
 133         if (!SetEvent(cond->events[LSIGNAL])) {
 134                 /* XXX */
 135                 return (ISC_R_UNEXPECTED);
 136         }
 137
 138         return (ISC_R_SUCCESS);
 139 }
 140
 141 isc_result_t
 142 isc_condition_broadcast(isc_condition_t *cond) {
 143
 144         isc_condition_thread_t *threadcond;
 145         isc_boolean_t failed = ISC_FALSE;
 146
 147         /*
 148          * Unlike pthreads, the caller MUST hold the lock associated with
 149          * the condition variable when calling us.
 150          */
 151         REQUIRE(cond != NULL);
 152
 153         /*
 154          * Notify every thread registered for this
 155          */
 156         for (threadcond = ISC_LIST_HEAD(cond->threadlist);
 157              threadcond != NULL;
 158              threadcond = ISC_LIST_NEXT(threadcond, link)) {
 159
 160                 if (!SetEvent(threadcond->handle[LBROADCAST]))
 161                         failed = ISC_TRUE;
 162         }
 163
 164         if (failed)
 165                 return (ISC_R_UNEXPECTED);
 166
 167         return (ISC_R_SUCCESS);
 168 }
 169
 170 isc_result_t
 171 isc_condition_destroy(isc_condition_t *cond) {
 172
 173         isc_condition_thread_t *next, *threadcond;
 174
 175         REQUIRE(cond != NULL);
 176         REQUIRE(cond->waiters == 0);
 177
 178         (void)CloseHandle(cond->events[LSIGNAL]);
 179
 180         /*
 181          * Delete the threadlist
 182          */
 183         threadcond = ISC_LIST_HEAD(cond->threadlist);
 184
 185         while (threadcond != NULL) {
 186                 next = ISC_LIST_NEXT(threadcond, link);
 187                 DEQUEUE(cond->threadlist, threadcond, link);
 188                 (void) CloseHandle(threadcond->handle[LBROADCAST]);
 189                 free(threadcond);
 190                 threadcond = next;
 191         }
 192
 193         return (ISC_R_SUCCESS);
 194 }
 195
 196 /*
 197  * This is always called when the mutex (lock) is held, but because
 198  * we are waiting we need to release it and reacquire it as soon as the wait
 199  * is over. This allows other threads to make use of the object guarded
 200  * by the mutex but it should never try to delete it as long as the
 201  * number of waiters > 0. Always reacquire the mutex regardless of the
 202  * result of the wait. Note that EnterCriticalSection will wait to acquire
 203  * the mutex.
 204  */
 205 static isc_result_t
 206 wait(isc_condition_t *cond, isc_mutex_t *mutex, DWORD milliseconds) {
 207         DWORD result;
 208         isc_result_t tresult;
 209         isc_condition_thread_t *threadcond = NULL;
 210
 211         /*
 212          * Get the thread events needed for the wait
 213          */
 214         tresult = find_thread_condition(isc_thread_self(), cond, &threadcond);
 215         if (tresult !=  ISC_R_SUCCESS)
 216                 return (tresult);
 217
 218         cond->waiters++;
 219         LeaveCriticalSection(mutex);
 220         result = WaitForMultipleObjects(2, threadcond->handle, FALSE,
 221                                         milliseconds);
 222         EnterCriticalSection(mutex);
 223         cond->waiters--;
 224         if (result == WAIT_FAILED) {
 225                 /* XXX */
 226                 return (ISC_R_UNEXPECTED);
 227         }
 228         if (result == WAIT_TIMEOUT)
 229                 return (ISC_R_TIMEDOUT);
 230
 231         return (ISC_R_SUCCESS);
 232 }
 233
 234 isc_result_t
 235 isc_condition_wait(isc_condition_t *cond, isc_mutex_t *mutex) {
 236         return (wait(cond, mutex, INFINITE));
 237 }
 238
 239 isc_result_t
 240 isc_condition_waituntil(isc_condition_t *cond, isc_mutex_t *mutex,
 241                         isc_time_t *t) {
 242         DWORD milliseconds;
 243         isc_uint64_t microseconds;
 244         isc_time_t now;
 245
 246         if (isc_time_now(&now) != ISC_R_SUCCESS) {
 247                 /* XXX */
 248                 return (ISC_R_UNEXPECTED);
 249         }
 250
 251         microseconds = isc_time_microdiff(t, &now);
 252         if (microseconds > 0xFFFFFFFFi64 * 1000)
 253                 milliseconds = 0xFFFFFFFF;
 254         else
 255                 milliseconds = (DWORD)(microseconds / 1000);
 256
 257         return (wait(cond, mutex, milliseconds));
 258 }