Annotation of embedaddon/ntp/lib/isc/win32/condition.c, revision 1.1.1.1
1.1 misho 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to condition.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc / win32