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