Mercurial

comparison third_party/libuv/src/win/poll.c @ 160:948de3f54cea

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[ThirdParty] Added libuv
author June Park <parkjune1995@gmail.com>
date Wed, 14 Jan 2026 19:39:52 -0800
parents
children
comparison
equal deleted inserted replaced
159:05cf9467a1c3 160:948de3f54cea
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2 *
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to
5 * deal in the Software without restriction, including without limitation the
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
7 * sell copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
9 *
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
12 *
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
19 * IN THE SOFTWARE.
20 */
21
22 #include <assert.h>
23 #include <io.h>
24
25 #include "uv.h"
26 #include "internal.h"
27 #include "handle-inl.h"
28 #include "req-inl.h"
29
30
31 static const GUID uv_msafd_provider_ids[UV_MSAFD_PROVIDER_COUNT] = {
32 {0xe70f1aa0, 0xab8b, 0x11cf,
33 {0x8c, 0xa3, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}},
34 {0xf9eab0c0, 0x26d4, 0x11d0,
35 {0xbb, 0xbf, 0x00, 0xaa, 0x00, 0x6c, 0x34, 0xe4}},
36 {0x9fc48064, 0x7298, 0x43e4,
37 {0xb7, 0xbd, 0x18, 0x1f, 0x20, 0x89, 0x79, 0x2a}},
38 {0xa00943d9, 0x9c2e, 0x4633,
39 {0x9b, 0x59, 0x00, 0x57, 0xa3, 0x16, 0x09, 0x94}}
40 };
41
42 typedef struct uv_single_fd_set_s {
43 unsigned int fd_count;
44 SOCKET fd_array[1];
45 } uv_single_fd_set_t;
46
47
48 static OVERLAPPED overlapped_dummy_;
49 static uv_once_t overlapped_dummy_init_guard_ = UV_ONCE_INIT;
50
51 static AFD_POLL_INFO afd_poll_info_dummy_;
52
53
54 static void uv__init_overlapped_dummy(void) {
55 HANDLE event;
56
57 event = CreateEvent(NULL, TRUE, TRUE, NULL);
58 if (event == NULL)
59 uv_fatal_error(GetLastError(), "CreateEvent");
60
61 memset(&overlapped_dummy_, 0, sizeof overlapped_dummy_);
62 overlapped_dummy_.hEvent = (HANDLE) ((uintptr_t) event | 1);
63 }
64
65
66 static OVERLAPPED* uv__get_overlapped_dummy(void) {
67 uv_once(&overlapped_dummy_init_guard_, uv__init_overlapped_dummy);
68 return &overlapped_dummy_;
69 }
70
71
72 static AFD_POLL_INFO* uv__get_afd_poll_info_dummy(void) {
73 return &afd_poll_info_dummy_;
74 }
75
76
77 static void uv__fast_poll_submit_poll_req(uv_loop_t* loop, uv_poll_t* handle) {
78 uv_req_t* req;
79 AFD_POLL_INFO* afd_poll_info;
80 int result;
81
82 /* Find a yet unsubmitted req to submit. */
83 if (handle->submitted_events_1 == 0) {
84 req = &handle->poll_req_1;
85 afd_poll_info = &handle->afd_poll_info_1;
86 handle->submitted_events_1 = handle->events;
87 handle->mask_events_1 = 0;
88 handle->mask_events_2 = handle->events;
89 } else if (handle->submitted_events_2 == 0) {
90 req = &handle->poll_req_2;
91 afd_poll_info = &handle->afd_poll_info_2;
92 handle->submitted_events_2 = handle->events;
93 handle->mask_events_1 = handle->events;
94 handle->mask_events_2 = 0;
95 } else {
96 /* Just wait until there's an unsubmitted req. This will happen almost
97 * immediately as one of the 2 outstanding requests is about to return.
98 * When this happens, uv__fast_poll_process_poll_req will be called, and
99 * the pending events, if needed, will be processed in a subsequent
100 * request. */
101 return;
102 }
103
104 /* Setting Exclusive to TRUE makes the other poll request return if there is
105 * any. */
106 afd_poll_info->Exclusive = TRUE;
107 afd_poll_info->NumberOfHandles = 1;
108 afd_poll_info->Timeout.QuadPart = INT64_MAX;
109 afd_poll_info->Handles[0].Handle = (HANDLE) handle->socket;
110 afd_poll_info->Handles[0].Status = 0;
111 afd_poll_info->Handles[0].Events = 0;
112
113 if (handle->events & UV_READABLE) {
114 afd_poll_info->Handles[0].Events |= AFD_POLL_RECEIVE |
115 AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | AFD_POLL_ABORT;
116 } else {
117 if (handle->events & UV_DISCONNECT) {
118 afd_poll_info->Handles[0].Events |= AFD_POLL_DISCONNECT;
119 }
120 }
121 if (handle->events & UV_WRITABLE) {
122 afd_poll_info->Handles[0].Events |= AFD_POLL_SEND | AFD_POLL_CONNECT_FAIL;
123 }
124
125 memset(&req->u.io.overlapped, 0, sizeof req->u.io.overlapped);
126
127 result = uv__msafd_poll((SOCKET) handle->peer_socket,
128 afd_poll_info,
129 afd_poll_info,
130 &req->u.io.overlapped);
131 if (result != 0 && WSAGetLastError() != WSA_IO_PENDING) {
132 /* Queue this req, reporting an error. */
133 SET_REQ_ERROR(req, WSAGetLastError());
134 uv__insert_pending_req(loop, req);
135 }
136 }
137
138
139 static void uv__fast_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
140 uv_req_t* req) {
141 unsigned char mask_events;
142 AFD_POLL_INFO* afd_poll_info;
143
144 if (req == &handle->poll_req_1) {
145 afd_poll_info = &handle->afd_poll_info_1;
146 handle->submitted_events_1 = 0;
147 mask_events = handle->mask_events_1;
148 } else if (req == &handle->poll_req_2) {
149 afd_poll_info = &handle->afd_poll_info_2;
150 handle->submitted_events_2 = 0;
151 mask_events = handle->mask_events_2;
152 } else {
153 assert(0);
154 return;
155 }
156
157 /* Report an error unless the select was just interrupted. */
158 if (!REQ_SUCCESS(req)) {
159 DWORD error = GET_REQ_SOCK_ERROR(req);
160 if (error != WSAEINTR && handle->events != 0) {
161 handle->events = 0; /* Stop the watcher */
162 handle->poll_cb(handle, uv_translate_sys_error(error), 0);
163 }
164
165 } else if (afd_poll_info->NumberOfHandles >= 1) {
166 unsigned char events = 0;
167
168 if ((afd_poll_info->Handles[0].Events & (AFD_POLL_RECEIVE |
169 AFD_POLL_DISCONNECT | AFD_POLL_ACCEPT | AFD_POLL_ABORT)) != 0) {
170 events |= UV_READABLE;
171 if ((afd_poll_info->Handles[0].Events & AFD_POLL_DISCONNECT) != 0) {
172 events |= UV_DISCONNECT;
173 }
174 }
175 if ((afd_poll_info->Handles[0].Events & (AFD_POLL_SEND |
176 AFD_POLL_CONNECT_FAIL)) != 0) {
177 events |= UV_WRITABLE;
178 }
179
180 events &= handle->events & ~mask_events;
181
182 if (afd_poll_info->Handles[0].Events & AFD_POLL_LOCAL_CLOSE) {
183 /* Stop polling. */
184 handle->events = 0;
185 if (uv__is_active(handle))
186 uv__handle_stop(handle);
187 }
188
189 if (events != 0) {
190 handle->poll_cb(handle, 0, events);
191 }
192 }
193
194 if ((handle->events & ~(handle->submitted_events_1 |
195 handle->submitted_events_2)) != 0) {
196 uv__fast_poll_submit_poll_req(loop, handle);
197 } else if ((handle->flags & UV_HANDLE_CLOSING) &&
198 handle->submitted_events_1 == 0 &&
199 handle->submitted_events_2 == 0) {
200 uv__want_endgame(loop, (uv_handle_t*) handle);
201 }
202 }
203
204
205 static SOCKET uv__fast_poll_create_peer_socket(HANDLE iocp,
206 WSAPROTOCOL_INFOW* protocol_info) {
207 SOCKET sock = 0;
208
209 sock = WSASocketW(protocol_info->iAddressFamily,
210 protocol_info->iSocketType,
211 protocol_info->iProtocol,
212 protocol_info,
213 0,
214 WSA_FLAG_OVERLAPPED);
215 if (sock == INVALID_SOCKET) {
216 return INVALID_SOCKET;
217 }
218
219 if (!SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0)) {
220 goto error;
221 };
222
223 if (CreateIoCompletionPort((HANDLE) sock,
224 iocp,
225 (ULONG_PTR) sock,
226 0) == NULL) {
227 goto error;
228 }
229
230 return sock;
231
232 error:
233 closesocket(sock);
234 return INVALID_SOCKET;
235 }
236
237
238 static SOCKET uv__fast_poll_get_peer_socket(uv_loop_t* loop,
239 WSAPROTOCOL_INFOW* protocol_info) {
240 int index, i;
241 SOCKET peer_socket;
242
243 index = -1;
244 for (i = 0; (size_t) i < ARRAY_SIZE(uv_msafd_provider_ids); i++) {
245 if (memcmp((void*) &protocol_info->ProviderId,
246 (void*) &uv_msafd_provider_ids[i],
247 sizeof protocol_info->ProviderId) == 0) {
248 index = i;
249 }
250 }
251
252 /* Check if the protocol uses an msafd socket. */
253 if (index < 0) {
254 return INVALID_SOCKET;
255 }
256
257 /* If we didn't (try) to create a peer socket yet, try to make one. Don't try
258 * again if the peer socket creation failed earlier for the same protocol. */
259 peer_socket = loop->poll_peer_sockets[index];
260 if (peer_socket == 0) {
261 peer_socket = uv__fast_poll_create_peer_socket(loop->iocp, protocol_info);
262 loop->poll_peer_sockets[index] = peer_socket;
263 }
264
265 return peer_socket;
266 }
267
268
269 static DWORD WINAPI uv__slow_poll_thread_proc(void* arg) {
270 uv_req_t* req = (uv_req_t*) arg;
271 uv_poll_t* handle = (uv_poll_t*) req->data;
272 unsigned char reported_events;
273 int r;
274 uv_single_fd_set_t rfds, wfds, efds;
275 struct timeval timeout;
276
277 assert(handle->type == UV_POLL);
278 assert(req->type == UV_POLL_REQ);
279
280 if (handle->events & UV_READABLE) {
281 rfds.fd_count = 1;
282 rfds.fd_array[0] = handle->socket;
283 } else {
284 rfds.fd_count = 0;
285 }
286
287 if (handle->events & UV_WRITABLE) {
288 wfds.fd_count = 1;
289 wfds.fd_array[0] = handle->socket;
290 efds.fd_count = 1;
291 efds.fd_array[0] = handle->socket;
292 } else {
293 wfds.fd_count = 0;
294 efds.fd_count = 0;
295 }
296
297 /* Make the select() time out after 3 minutes. If select() hangs because the
298 * user closed the socket, we will at least not hang indefinitely. */
299 timeout.tv_sec = 3 * 60;
300 timeout.tv_usec = 0;
301
302 r = select(1, (fd_set*) &rfds, (fd_set*) &wfds, (fd_set*) &efds, &timeout);
303 if (r == SOCKET_ERROR) {
304 /* Queue this req, reporting an error. */
305 SET_REQ_ERROR(&handle->poll_req_1, WSAGetLastError());
306 POST_COMPLETION_FOR_REQ(handle->loop, req);
307 return 0;
308 }
309
310 reported_events = 0;
311
312 if (r > 0) {
313 if (rfds.fd_count > 0) {
314 assert(rfds.fd_count == 1);
315 assert(rfds.fd_array[0] == handle->socket);
316 reported_events |= UV_READABLE;
317 }
318
319 if (wfds.fd_count > 0) {
320 assert(wfds.fd_count == 1);
321 assert(wfds.fd_array[0] == handle->socket);
322 reported_events |= UV_WRITABLE;
323 } else if (efds.fd_count > 0) {
324 assert(efds.fd_count == 1);
325 assert(efds.fd_array[0] == handle->socket);
326 reported_events |= UV_WRITABLE;
327 }
328 }
329
330 SET_REQ_SUCCESS(req);
331 req->u.io.overlapped.InternalHigh = (DWORD) reported_events;
332 POST_COMPLETION_FOR_REQ(handle->loop, req);
333
334 return 0;
335 }
336
337
338 static void uv__slow_poll_submit_poll_req(uv_loop_t* loop, uv_poll_t* handle) {
339 uv_req_t* req;
340
341 /* Find a yet unsubmitted req to submit. */
342 if (handle->submitted_events_1 == 0) {
343 req = &handle->poll_req_1;
344 handle->submitted_events_1 = handle->events;
345 handle->mask_events_1 = 0;
346 handle->mask_events_2 = handle->events;
347 } else if (handle->submitted_events_2 == 0) {
348 req = &handle->poll_req_2;
349 handle->submitted_events_2 = handle->events;
350 handle->mask_events_1 = handle->events;
351 handle->mask_events_2 = 0;
352 } else {
353 assert(0);
354 return;
355 }
356
357 if (!QueueUserWorkItem(uv__slow_poll_thread_proc,
358 (void*) req,
359 WT_EXECUTELONGFUNCTION)) {
360 /* Make this req pending, reporting an error. */
361 SET_REQ_ERROR(req, GetLastError());
362 uv__insert_pending_req(loop, req);
363 }
364 }
365
366
367
368 static void uv__slow_poll_process_poll_req(uv_loop_t* loop, uv_poll_t* handle,
369 uv_req_t* req) {
370 unsigned char mask_events;
371 int err;
372
373 if (req == &handle->poll_req_1) {
374 handle->submitted_events_1 = 0;
375 mask_events = handle->mask_events_1;
376 } else if (req == &handle->poll_req_2) {
377 handle->submitted_events_2 = 0;
378 mask_events = handle->mask_events_2;
379 } else {
380 assert(0);
381 return;
382 }
383
384 if (!REQ_SUCCESS(req)) {
385 /* Error. */
386 if (handle->events != 0) {
387 err = GET_REQ_ERROR(req);
388 handle->events = 0; /* Stop the watcher */
389 handle->poll_cb(handle, uv_translate_sys_error(err), 0);
390 }
391 } else {
392 /* Got some events. */
393 int events = req->u.io.overlapped.InternalHigh & handle->events & ~mask_events;
394 if (events != 0) {
395 handle->poll_cb(handle, 0, events);
396 }
397 }
398
399 if ((handle->events & ~(handle->submitted_events_1 |
400 handle->submitted_events_2)) != 0) {
401 uv__slow_poll_submit_poll_req(loop, handle);
402 } else if ((handle->flags & UV_HANDLE_CLOSING) &&
403 handle->submitted_events_1 == 0 &&
404 handle->submitted_events_2 == 0) {
405 uv__want_endgame(loop, (uv_handle_t*) handle);
406 }
407 }
408
409
410 int uv_poll_init(uv_loop_t* loop, uv_poll_t* handle, int fd) {
411 return uv_poll_init_socket(loop, handle, (SOCKET) uv__get_osfhandle(fd));
412 }
413
414
415 int uv_poll_init_socket(uv_loop_t* loop, uv_poll_t* handle,
416 uv_os_sock_t socket) {
417 WSAPROTOCOL_INFOW protocol_info;
418 int len;
419 SOCKET peer_socket, base_socket;
420 DWORD bytes;
421 DWORD yes = 1;
422
423 /* Set the socket to nonblocking mode */
424 if (ioctlsocket(socket, FIONBIO, &yes) == SOCKET_ERROR)
425 return uv_translate_sys_error(WSAGetLastError());
426
427 /* Try to obtain a base handle for the socket. This increases this chances that
428 * we find an AFD handle and are able to use the fast poll mechanism.
429 */
430 #ifndef NDEBUG
431 base_socket = INVALID_SOCKET;
432 #endif
433
434 if (WSAIoctl(socket,
435 SIO_BASE_HANDLE,
436 NULL,
437 0,
438 &base_socket,
439 sizeof base_socket,
440 &bytes,
441 NULL,
442 NULL) == 0) {
443 assert(base_socket != 0 && base_socket != INVALID_SOCKET);
444 socket = base_socket;
445 }
446
447 uv__handle_init(loop, (uv_handle_t*) handle, UV_POLL);
448 handle->socket = socket;
449 handle->events = 0;
450
451 /* Obtain protocol information about the socket. */
452 len = sizeof protocol_info;
453 if (getsockopt(socket,
454 SOL_SOCKET,
455 SO_PROTOCOL_INFOW,
456 (char*) &protocol_info,
457 &len) != 0) {
458 return uv_translate_sys_error(WSAGetLastError());
459 }
460
461 /* Get the peer socket that is needed to enable fast poll. If the returned
462 * value is NULL, the protocol is not implemented by MSAFD and we'll have to
463 * use slow mode. */
464 peer_socket = uv__fast_poll_get_peer_socket(loop, &protocol_info);
465
466 if (peer_socket != INVALID_SOCKET) {
467 /* Initialize fast poll specific fields. */
468 handle->peer_socket = peer_socket;
469 } else {
470 /* Initialize slow poll specific fields. */
471 handle->flags |= UV_HANDLE_POLL_SLOW;
472 }
473
474 /* Initialize 2 poll reqs. */
475 handle->submitted_events_1 = 0;
476 UV_REQ_INIT(&handle->poll_req_1, UV_POLL_REQ);
477 handle->poll_req_1.data = handle;
478
479 handle->submitted_events_2 = 0;
480 UV_REQ_INIT(&handle->poll_req_2, UV_POLL_REQ);
481 handle->poll_req_2.data = handle;
482
483 return 0;
484 }
485
486
487 static int uv__poll_set(uv_poll_t* handle, int events, uv_poll_cb cb) {
488 int submitted_events;
489
490 assert(handle->type == UV_POLL);
491 assert(!(handle->flags & UV_HANDLE_CLOSING));
492 assert((events & ~(UV_READABLE | UV_WRITABLE | UV_DISCONNECT |
493 UV_PRIORITIZED)) == 0);
494
495 handle->events = events;
496 handle->poll_cb = cb;
497
498 if (handle->events == 0) {
499 uv__handle_stop(handle);
500 return 0;
501 }
502
503 uv__handle_start(handle);
504 submitted_events = handle->submitted_events_1 | handle->submitted_events_2;
505
506 if (handle->events & ~submitted_events) {
507 if (handle->flags & UV_HANDLE_POLL_SLOW) {
508 uv__slow_poll_submit_poll_req(handle->loop, handle);
509 } else {
510 uv__fast_poll_submit_poll_req(handle->loop, handle);
511 }
512 }
513
514 return 0;
515 }
516
517
518 int uv_poll_start(uv_poll_t* handle, int events, uv_poll_cb cb) {
519 return uv__poll_set(handle, events, cb);
520 }
521
522
523 int uv_poll_stop(uv_poll_t* handle) {
524 return uv__poll_set(handle, 0, handle->poll_cb);
525 }
526
527
528 void uv__process_poll_req(uv_loop_t* loop, uv_poll_t* handle, uv_req_t* req) {
529 if (!(handle->flags & UV_HANDLE_POLL_SLOW)) {
530 uv__fast_poll_process_poll_req(loop, handle, req);
531 } else {
532 uv__slow_poll_process_poll_req(loop, handle, req);
533 }
534 }
535
536
537 int uv__poll_close(uv_loop_t* loop, uv_poll_t* handle) {
538 AFD_POLL_INFO afd_poll_info;
539 DWORD error;
540 int result;
541
542 handle->events = 0;
543 uv__handle_closing(handle);
544
545 if (handle->submitted_events_1 == 0 &&
546 handle->submitted_events_2 == 0) {
547 uv__want_endgame(loop, (uv_handle_t*) handle);
548 return 0;
549 }
550
551 if (handle->flags & UV_HANDLE_POLL_SLOW)
552 return 0;
553
554 /* Cancel outstanding poll requests by executing another, unique poll
555 * request that forces the outstanding ones to return. */
556 afd_poll_info.Exclusive = TRUE;
557 afd_poll_info.NumberOfHandles = 1;
558 afd_poll_info.Timeout.QuadPart = INT64_MAX;
559 afd_poll_info.Handles[0].Handle = (HANDLE) handle->socket;
560 afd_poll_info.Handles[0].Status = 0;
561 afd_poll_info.Handles[0].Events = AFD_POLL_ALL;
562
563 result = uv__msafd_poll(handle->socket,
564 &afd_poll_info,
565 uv__get_afd_poll_info_dummy(),
566 uv__get_overlapped_dummy());
567
568 if (result == SOCKET_ERROR) {
569 error = WSAGetLastError();
570 if (error != WSA_IO_PENDING)
571 return uv_translate_sys_error(error);
572 }
573
574 return 0;
575 }
576
577
578 void uv__poll_endgame(uv_loop_t* loop, uv_poll_t* handle) {
579 assert(handle->flags & UV_HANDLE_CLOSING);
580 assert(!(handle->flags & UV_HANDLE_CLOSED));
581
582 assert(handle->submitted_events_1 == 0);
583 assert(handle->submitted_events_2 == 0);
584
585 uv__handle_close(handle);
586 }