1 /*
2 * Copyright 2009-2012 Niels Provos and Nick Mathewson
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * 3. The name of the author may not be used to endorse or promote products
13 * derived from this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26 #include "event2/event-config.h"
27 #include "evconfig-private.h"
28
29 #ifdef _WIN32
30 #ifndef _WIN32_WINNT
31 /* Minimum required for InitializeCriticalSectionAndSpinCount */
32 #define _WIN32_WINNT 0x0403
33 #endif
34 #include <winsock2.h>
35 #define WIN32_LEAN_AND_MEAN
36 #include <windows.h>
37 #undef WIN32_LEAN_AND_MEAN
38 #include <sys/locking.h>
39 #endif
40
41 struct event_base;
42 #include "event2/thread.h"
43
44 #include "mm-internal.h"
45 #include "evthread-internal.h"
46 #include "time-internal.h"
47
48 #define SPIN_COUNT 2000
49
50 static void *
evthread_win32_lock_create(unsigned locktype)51 evthread_win32_lock_create(unsigned locktype)
52 {
53 CRITICAL_SECTION *lock = mm_malloc(sizeof(CRITICAL_SECTION));
54 if (!lock)
55 return NULL;
56 if (InitializeCriticalSectionAndSpinCount(lock, SPIN_COUNT) == 0) {
57 mm_free(lock);
58 return NULL;
59 }
60 return lock;
61 }
62
63 static void
evthread_win32_lock_free(void * lock_,unsigned locktype)64 evthread_win32_lock_free(void *lock_, unsigned locktype)
65 {
66 CRITICAL_SECTION *lock = lock_;
67 DeleteCriticalSection(lock);
68 mm_free(lock);
69 }
70
71 static int
evthread_win32_lock(unsigned mode,void * lock_)72 evthread_win32_lock(unsigned mode, void *lock_)
73 {
74 CRITICAL_SECTION *lock = lock_;
75 if ((mode & EVTHREAD_TRY)) {
76 return ! TryEnterCriticalSection(lock);
77 } else {
78 EnterCriticalSection(lock);
79 return 0;
80 }
81 }
82
83 static int
evthread_win32_unlock(unsigned mode,void * lock_)84 evthread_win32_unlock(unsigned mode, void *lock_)
85 {
86 CRITICAL_SECTION *lock = lock_;
87 LeaveCriticalSection(lock);
88 return 0;
89 }
90
91 static unsigned long
evthread_win32_get_id(void)92 evthread_win32_get_id(void)
93 {
94 return (unsigned long) GetCurrentThreadId();
95 }
96
97 #ifdef WIN32_HAVE_CONDITION_VARIABLES
98 static void WINAPI (*InitializeConditionVariable_fn)(PCONDITION_VARIABLE)
99 = NULL;
100 static BOOL WINAPI (*SleepConditionVariableCS_fn)(
101 PCONDITION_VARIABLE, PCRITICAL_SECTION, DWORD) = NULL;
102 static void WINAPI (*WakeAllConditionVariable_fn)(PCONDITION_VARIABLE) = NULL;
103 static void WINAPI (*WakeConditionVariable_fn)(PCONDITION_VARIABLE) = NULL;
104
105 static int
evthread_win32_condvar_init(void)106 evthread_win32_condvar_init(void)
107 {
108 HANDLE lib;
109
110 lib = GetModuleHandle(TEXT("kernel32.dll"));
111 if (lib == NULL)
112 return 0;
113
114 #define LOAD(name) \
115 name##_fn = GetProcAddress(lib, #name)
116 LOAD(InitializeConditionVariable);
117 LOAD(SleepConditionVariableCS);
118 LOAD(WakeAllConditionVariable);
119 LOAD(WakeConditionVariable);
120
121 return InitializeConditionVariable_fn && SleepConditionVariableCS_fn &&
122 WakeAllConditionVariable_fn && WakeConditionVariable_fn;
123 }
124
125 /* XXXX Even if we can build this, we don't necessarily want to: the functions
126 * in question didn't exist before Vista, so we'd better LoadProc them. */
127 static void *
evthread_win32_condvar_alloc(unsigned condflags)128 evthread_win32_condvar_alloc(unsigned condflags)
129 {
130 CONDITION_VARIABLE *cond = mm_malloc(sizeof(CONDITION_VARIABLE));
131 if (!cond)
132 return NULL;
133 InitializeConditionVariable_fn(cond);
134 return cond;
135 }
136
137 static void
evthread_win32_condvar_free(void * cond_)138 evthread_win32_condvar_free(void *cond_)
139 {
140 CONDITION_VARIABLE *cond = cond_;
141 /* There doesn't _seem_ to be a cleaup fn here... */
142 mm_free(cond);
143 }
144
145 static int
evthread_win32_condvar_signal(void * cond,int broadcast)146 evthread_win32_condvar_signal(void *cond, int broadcast)
147 {
148 CONDITION_VARIABLE *cond = cond_;
149 if (broadcast)
150 WakeAllConditionVariable_fn(cond);
151 else
152 WakeConditionVariable_fn(cond);
153 return 0;
154 }
155
156 static int
evthread_win32_condvar_wait(void * cond_,void * lock_,const struct timeval * tv)157 evthread_win32_condvar_wait(void *cond_, void *lock_, const struct timeval *tv)
158 {
159 CONDITION_VARIABLE *cond = cond_;
160 CRITICAL_SECTION *lock = lock_;
161 DWORD ms, err;
162 BOOL result;
163
164 if (tv)
165 ms = evutil_tv_to_msec_(tv);
166 else
167 ms = INFINITE;
168 result = SleepConditionVariableCS_fn(cond, lock, ms);
169 if (result) {
170 if (GetLastError() == WAIT_TIMEOUT)
171 return 1;
172 else
173 return -1;
174 } else {
175 return 0;
176 }
177 }
178 #endif
179
180 struct evthread_win32_cond {
181 HANDLE event;
182
183 CRITICAL_SECTION lock;
184 int n_waiting;
185 int n_to_wake;
186 int generation;
187 };
188
189 static void *
evthread_win32_cond_alloc(unsigned flags)190 evthread_win32_cond_alloc(unsigned flags)
191 {
192 struct evthread_win32_cond *cond;
193 if (!(cond = mm_malloc(sizeof(struct evthread_win32_cond))))
194 return NULL;
195 if (InitializeCriticalSectionAndSpinCount(&cond->lock, SPIN_COUNT)==0) {
196 mm_free(cond);
197 return NULL;
198 }
199 if ((cond->event = CreateEvent(NULL,TRUE,FALSE,NULL)) == NULL) {
200 DeleteCriticalSection(&cond->lock);
201 mm_free(cond);
202 return NULL;
203 }
204 cond->n_waiting = cond->n_to_wake = cond->generation = 0;
205 return cond;
206 }
207
208 static void
evthread_win32_cond_free(void * cond_)209 evthread_win32_cond_free(void *cond_)
210 {
211 struct evthread_win32_cond *cond = cond_;
212 DeleteCriticalSection(&cond->lock);
213 CloseHandle(cond->event);
214 mm_free(cond);
215 }
216
217 static int
evthread_win32_cond_signal(void * cond_,int broadcast)218 evthread_win32_cond_signal(void *cond_, int broadcast)
219 {
220 struct evthread_win32_cond *cond = cond_;
221 EnterCriticalSection(&cond->lock);
222 if (broadcast)
223 cond->n_to_wake = cond->n_waiting;
224 else
225 ++cond->n_to_wake;
226 cond->generation++;
227 SetEvent(cond->event);
228 LeaveCriticalSection(&cond->lock);
229 return 0;
230 }
231
232 static int
evthread_win32_cond_wait(void * cond_,void * lock_,const struct timeval * tv)233 evthread_win32_cond_wait(void *cond_, void *lock_, const struct timeval *tv)
234 {
235 struct evthread_win32_cond *cond = cond_;
236 CRITICAL_SECTION *lock = lock_;
237 int generation_at_start;
238 int waiting = 1;
239 int result = -1;
240 DWORD ms = INFINITE, ms_orig = INFINITE, startTime, endTime;
241 if (tv)
242 ms_orig = ms = evutil_tv_to_msec_(tv);
243
244 EnterCriticalSection(&cond->lock);
245 ++cond->n_waiting;
246 generation_at_start = cond->generation;
247 LeaveCriticalSection(&cond->lock);
248
249 LeaveCriticalSection(lock);
250
251 startTime = GetTickCount();
252 do {
253 DWORD res;
254 res = WaitForSingleObject(cond->event, ms);
255 EnterCriticalSection(&cond->lock);
256 if (cond->n_to_wake &&
257 cond->generation != generation_at_start) {
258 --cond->n_to_wake;
259 --cond->n_waiting;
260 result = 0;
261 waiting = 0;
262 goto out;
263 } else if (res != WAIT_OBJECT_0) {
264 result = (res==WAIT_TIMEOUT) ? 1 : -1;
265 --cond->n_waiting;
266 waiting = 0;
267 goto out;
268 } else if (ms != INFINITE) {
269 endTime = GetTickCount();
270 if (startTime + ms_orig <= endTime) {
271 result = 1; /* Timeout */
272 --cond->n_waiting;
273 waiting = 0;
274 goto out;
275 } else {
276 ms = startTime + ms_orig - endTime;
277 }
278 }
279 /* If we make it here, we are still waiting. */
280 if (cond->n_to_wake == 0) {
281 /* There is nobody else who should wake up; reset
282 * the event. */
283 ResetEvent(cond->event);
284 }
285 out:
286 LeaveCriticalSection(&cond->lock);
287 } while (waiting);
288
289 EnterCriticalSection(lock);
290
291 EnterCriticalSection(&cond->lock);
292 if (!cond->n_waiting)
293 ResetEvent(cond->event);
294 LeaveCriticalSection(&cond->lock);
295
296 return result;
297 }
298
299 int
evthread_use_windows_threads(void)300 evthread_use_windows_threads(void)
301 {
302 struct evthread_lock_callbacks cbs = {
303 EVTHREAD_LOCK_API_VERSION,
304 EVTHREAD_LOCKTYPE_RECURSIVE,
305 evthread_win32_lock_create,
306 evthread_win32_lock_free,
307 evthread_win32_lock,
308 evthread_win32_unlock
309 };
310
311
312 struct evthread_condition_callbacks cond_cbs = {
313 EVTHREAD_CONDITION_API_VERSION,
314 evthread_win32_cond_alloc,
315 evthread_win32_cond_free,
316 evthread_win32_cond_signal,
317 evthread_win32_cond_wait
318 };
319 #ifdef WIN32_HAVE_CONDITION_VARIABLES
320 struct evthread_condition_callbacks condvar_cbs = {
321 EVTHREAD_CONDITION_API_VERSION,
322 evthread_win32_condvar_alloc,
323 evthread_win32_condvar_free,
324 evthread_win32_condvar_signal,
325 evthread_win32_condvar_wait
326 };
327 #endif
328
329 evthread_set_lock_callbacks(&cbs);
330 evthread_set_id_callback(evthread_win32_get_id);
331 #ifdef WIN32_HAVE_CONDITION_VARIABLES
332 if (evthread_win32_condvar_init()) {
333 evthread_set_condition_callbacks(&condvar_cbs);
334 return 0;
335 }
336 #endif
337 evthread_set_condition_callbacks(&cond_cbs);
338
339 return 0;
340 }
341
342