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
isc_condition_init(isc_condition_t * cond)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
register_thread(unsigned long thrd,isc_condition_t * gblcond,isc_condition_thread_t ** localcond)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
find_thread_condition(unsigned long thrd,isc_condition_t * cond,isc_condition_thread_t ** threadcondp)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
isc_condition_signal(isc_condition_t * cond)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
isc_condition_broadcast(isc_condition_t * cond)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
isc_condition_destroy(isc_condition_t * cond)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
wait(isc_condition_t * cond,isc_mutex_t * mutex,DWORD milliseconds)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
isc_condition_wait(isc_condition_t * cond,isc_mutex_t * mutex)235 isc_condition_wait(isc_condition_t *cond, isc_mutex_t *mutex) {
236 return (wait(cond, mutex, INFINITE));
237 }
238
239 isc_result_t
isc_condition_waituntil(isc_condition_t * cond,isc_mutex_t * mutex,isc_time_t * 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 }
259