2 * Copyright (c) 2009-2010 Niels Provos, Nick Mathewson
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
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.
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.
33 #include "event2/util.h"
34 #include "util-internal.h"
35 #include "iocp-internal.h"
36 #include "log-internal.h"
37 #include "mm-internal.h"
38 #include "event-internal.h"
39 #include "evthread-internal.h"
41 #define NOTIFICATION_KEY ((ULONG_PTR)-1)
44 event_overlapped_init(struct event_overlapped *o, iocp_callback cb)
46 memset(o, 0, sizeof(struct event_overlapped));
51 handle_entry(OVERLAPPED *o, ULONG_PTR completion_key, DWORD nBytes, int ok)
53 struct event_overlapped *eo =
54 EVUTIL_UPCAST(o, struct event_overlapped, overlapped);
55 eo->cb(eo, completion_key, nBytes, ok);
61 struct event_iocp_port *port = _port;
63 HANDLE p = port->port;
69 OVERLAPPED *overlapped=NULL;
72 int ok = GetQueuedCompletionStatus(p, &bytes, &key,
74 EnterCriticalSection(&port->lock);
76 if (--port->n_live_threads == 0)
77 ReleaseSemaphore(port->shutdownSemaphore, 1,
79 LeaveCriticalSection(&port->lock);
82 LeaveCriticalSection(&port->lock);
84 if (key != NOTIFICATION_KEY && overlapped)
85 handle_entry(overlapped, key, bytes, ok);
89 event_warnx("GetQueuedCompletionStatus exited with no event.");
90 EnterCriticalSection(&port->lock);
91 if (--port->n_live_threads == 0)
92 ReleaseSemaphore(port->shutdownSemaphore, 1, NULL);
93 LeaveCriticalSection(&port->lock);
97 event_iocp_port_associate(struct event_iocp_port *port, evutil_socket_t fd,
101 h = CreateIoCompletionPort((HANDLE)fd, port->port, key, port->n_threads);
108 get_extension_function(SOCKET s, const GUID *which_fn)
112 WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER,
113 (GUID*)which_fn, sizeof(*which_fn),
117 /* No need to detect errors here: if ptr is set, then we have a good
118 function pointer. Otherwise, we should behave as if we had no
124 /* Mingw doesn't have these in its mswsock.h. The values are copied from
125 wine.h. Perhaps if we copy them exactly, the cargo will come again.
127 #ifndef WSAID_ACCEPTEX
128 #define WSAID_ACCEPTEX \
129 {0xb5367df1,0xcbac,0x11cf,{0x95,0xca,0x00,0x80,0x5f,0x48,0xa1,0x92}}
131 #ifndef WSAID_CONNECTEX
132 #define WSAID_CONNECTEX \
133 {0x25a207b9,0xddf3,0x4660,{0x8e,0xe9,0x76,0xe5,0x8c,0x74,0x06,0x3e}}
135 #ifndef WSAID_GETACCEPTEXSOCKADDRS
136 #define WSAID_GETACCEPTEXSOCKADDRS \
137 {0xb5367df2,0xcbac,0x11cf,{0x95,0xca,0x00,0x80,0x5f,0x48,0xa1,0x92}}
141 init_extension_functions(struct win32_extension_fns *ext)
143 const GUID acceptex = WSAID_ACCEPTEX;
144 const GUID connectex = WSAID_CONNECTEX;
145 const GUID getacceptexsockaddrs = WSAID_GETACCEPTEXSOCKADDRS;
146 SOCKET s = socket(AF_INET, SOCK_STREAM, 0);
147 if (s == INVALID_SOCKET)
149 ext->AcceptEx = get_extension_function(s, &acceptex);
150 ext->ConnectEx = get_extension_function(s, &connectex);
151 ext->GetAcceptExSockaddrs = get_extension_function(s,
152 &getacceptexsockaddrs);
156 static struct win32_extension_fns the_extension_fns;
157 static int extension_fns_initialized = 0;
159 const struct win32_extension_fns *
160 event_get_win32_extension_fns(void)
162 return &the_extension_fns;
165 #define N_CPUS_DEFAULT 2
167 struct event_iocp_port *
168 event_iocp_port_launch(int n_cpus)
170 struct event_iocp_port *port;
173 if (!extension_fns_initialized)
174 init_extension_functions(&the_extension_fns);
176 if (!(port = mm_calloc(1, sizeof(struct event_iocp_port))))
180 n_cpus = N_CPUS_DEFAULT;
181 port->n_threads = n_cpus * 2;
182 port->threads = calloc(port->n_threads, sizeof(HANDLE));
186 port->port = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0,
192 port->shutdownSemaphore = CreateSemaphore(NULL, 0, 1, NULL);
193 if (!port->shutdownSemaphore)
196 for (i=0; i<port->n_threads; ++i) {
197 ev_uintptr_t th = _beginthread(loop, 0, port);
198 if (th == (ev_uintptr_t)-1)
200 port->threads[i] = (HANDLE)th;
201 ++port->n_live_threads;
204 InitializeCriticalSectionAndSpinCount(&port->lock, 1000);
209 CloseHandle(port->port);
211 mm_free(port->threads);
212 if (port->shutdownSemaphore)
213 CloseHandle(port->shutdownSemaphore);
219 _event_iocp_port_unlock_and_free(struct event_iocp_port *port)
221 DeleteCriticalSection(&port->lock);
222 CloseHandle(port->port);
223 CloseHandle(port->shutdownSemaphore);
224 mm_free(port->threads);
229 event_iocp_notify_all(struct event_iocp_port *port)
232 for (i=0; i<port->n_threads; ++i) {
233 r = PostQueuedCompletionStatus(port->port, 0, NOTIFICATION_KEY,
242 event_iocp_shutdown(struct event_iocp_port *port, long waitMsec)
247 EnterCriticalSection(&port->lock);
249 LeaveCriticalSection(&port->lock);
250 event_iocp_notify_all(port);
255 WaitForSingleObject(port->shutdownSemaphore, ms);
256 EnterCriticalSection(&port->lock);
257 n = port->n_live_threads;
258 LeaveCriticalSection(&port->lock);
260 _event_iocp_port_unlock_and_free(port);
268 event_iocp_activate_overlapped(
269 struct event_iocp_port *port, struct event_overlapped *o,
270 ev_uintptr_t key, ev_uint32_t n)
274 r = PostQueuedCompletionStatus(port->port, n, key, &o->overlapped);
275 return (r==0) ? -1 : 0;
278 struct event_iocp_port *
279 event_base_get_iocp(struct event_base *base)