1/* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3 *
4 * gpoll.c: poll(2) abstraction
5 * Copyright 1998 Owen Taylor
6 * Copyright 2008 Red Hat, Inc.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22/*
23 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
24 * file for a list of people on the GLib Team. See the ChangeLog
25 * files for a list of changes. These files are distributed with
26 * GLib at ftp://ftp.gtk.org/pub/gtk/.
27 */
28
29/*
30 * MT safe
31 */
32
33#include "config.h"
34#include "glibconfig.h"
35#include "giochannel.h"
36
37/* Uncomment the next line (and the corresponding line in gmain.c) to
38 * enable debugging printouts if the environment variable
39 * G_MAIN_POLL_DEBUG is set to some value.
40 */
41/* #define G_MAIN_POLL_DEBUG */
42
43#ifdef _WIN32
44/* Always enable debugging printout on Windows, as it is more often
45 * needed there...
46 */
47#define G_MAIN_POLL_DEBUG
48#endif
49
50#include <sys/types.h>
51#include <time.h>
52#include <stdlib.h>
53#ifdef HAVE_SYS_TIME_H
54#include <sys/time.h>
55#endif /* HAVE_SYS_TIME_H */
56#ifdef HAVE_POLL
57# include <poll.h>
58
59/* The poll() emulation on OS/X doesn't handle fds=NULL, nfds=0,
60 * so we prefer our own poll emulation.
61 */
62#if defined(_POLL_EMUL_H_) || defined(BROKEN_POLL)
63#undef HAVE_POLL
64#endif
65
66#endif /* GLIB_HAVE_SYS_POLL_H */
67#ifdef G_OS_UNIX
68#include <unistd.h>
69#endif /* G_OS_UNIX */
70#include <errno.h>
71
72#ifdef G_OS_WIN32
73#define STRICT
74#include <windows.h>
75#include <process.h>
76#endif /* G_OS_WIN32 */
77
78#include "gpoll.h"
79
80#ifdef G_OS_WIN32
81#include "gprintf.h"
82#endif
83
84#ifdef G_MAIN_POLL_DEBUG
85extern gboolean _g_main_poll_debug;
86#endif
87
88#ifdef HAVE_POLL
89
90/**
91 * g_poll:
92 * @fds: file descriptors to poll
93 * @nfds: the number of file descriptors in @fds
94 * @timeout: amount of time to wait, in milliseconds, or -1 to wait forever
95 *
96 * Polls @fds, as with the poll() system call, but portably. (On
97 * systems that don't have poll(), it is emulated using select().)
98 * This is used internally by #GMainContext, but it can be called
99 * directly if you need to block until a file descriptor is ready, but
100 * don't want to run the full main loop.
101 *
102 * Each element of @fds is a #GPollFD describing a single file
103 * descriptor to poll. The @fd field indicates the file descriptor,
104 * and the @events field indicates the events to poll for. On return,
105 * the @revents fields will be filled with the events that actually
106 * occurred.
107 *
108 * On POSIX systems, the file descriptors in @fds can be any sort of
109 * file descriptor, but the situation is much more complicated on
110 * Windows. If you need to use g_poll() in code that has to run on
111 * Windows, the easiest solution is to construct all of your
112 * #GPollFDs with g_io_channel_win32_make_pollfd().
113 *
114 * Returns: the number of entries in @fds whose @revents fields
115 * were filled in, or 0 if the operation timed out, or -1 on error or
116 * if the call was interrupted.
117 *
118 * Since: 2.20
119 **/
120gint
121g_poll (GPollFD *fds,
122 guint nfds,
123 gint timeout)
124{
125 return poll (fds: (struct pollfd *)fds, nfds: nfds, timeout: timeout);
126}
127
128#else /* !HAVE_POLL */
129
130#ifdef G_OS_WIN32
131
132static int
133poll_rest (GPollFD *msg_fd,
134 GPollFD *stop_fd,
135 HANDLE *handles,
136 GPollFD *handle_to_fd[],
137 gint nhandles,
138 gint timeout_ms)
139{
140 DWORD ready;
141 GPollFD *f;
142 int recursed_result;
143
144 if (msg_fd != NULL)
145 {
146 /* Wait for either messages or handles
147 * -> Use MsgWaitForMultipleObjectsEx
148 */
149 if (_g_main_poll_debug)
150 g_print (" MsgWaitForMultipleObjectsEx(%d, %d)\n", nhandles, timeout_ms);
151
152 ready = MsgWaitForMultipleObjectsEx (nhandles, handles, timeout_ms,
153 QS_ALLINPUT, MWMO_ALERTABLE);
154
155 if (ready == WAIT_FAILED)
156 {
157 gchar *emsg = g_win32_error_message (GetLastError ());
158 g_warning ("MsgWaitForMultipleObjectsEx failed: %s", emsg);
159 g_free (emsg);
160 }
161 }
162 else if (nhandles == 0)
163 {
164 /* No handles to wait for, just the timeout */
165 if (timeout_ms == INFINITE)
166 ready = WAIT_FAILED;
167 else
168 {
169 /* Wait for the current process to die, more efficient than SleepEx(). */
170 WaitForSingleObjectEx (GetCurrentProcess (), timeout_ms, TRUE);
171 ready = WAIT_TIMEOUT;
172 }
173 }
174 else
175 {
176 /* Wait for just handles
177 * -> Use WaitForMultipleObjectsEx
178 */
179 if (_g_main_poll_debug)
180 g_print (" WaitForMultipleObjectsEx(%d, %d)\n", nhandles, timeout_ms);
181
182 ready = WaitForMultipleObjectsEx (nhandles, handles, FALSE, timeout_ms, TRUE);
183 if (ready == WAIT_FAILED)
184 {
185 gchar *emsg = g_win32_error_message (GetLastError ());
186 g_warning ("WaitForMultipleObjectsEx failed: %s", emsg);
187 g_free (emsg);
188 }
189 }
190
191 if (_g_main_poll_debug)
192 g_print (" wait returns %ld%s\n",
193 ready,
194 (ready == WAIT_FAILED ? " (WAIT_FAILED)" :
195 (ready == WAIT_TIMEOUT ? " (WAIT_TIMEOUT)" :
196 (msg_fd != NULL && ready == WAIT_OBJECT_0 + nhandles ? " (msg)" : ""))));
197
198 if (ready == WAIT_FAILED)
199 return -1;
200 else if (ready == WAIT_TIMEOUT ||
201 ready == WAIT_IO_COMPLETION)
202 return 0;
203 else if (msg_fd != NULL && ready == WAIT_OBJECT_0 + nhandles)
204 {
205 msg_fd->revents |= G_IO_IN;
206
207 /* If we have a timeout, or no handles to poll, be satisfied
208 * with just noticing we have messages waiting.
209 */
210 if (timeout_ms != 0 || nhandles == 0)
211 return 1;
212
213 /* If no timeout and handles to poll, recurse to poll them,
214 * too.
215 */
216 recursed_result = poll_rest (NULL, stop_fd, handles, handle_to_fd, nhandles, 0);
217 return (recursed_result == -1) ? -1 : 1 + recursed_result;
218 }
219 else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
220 {
221 int retval;
222
223 f = handle_to_fd[ready - WAIT_OBJECT_0];
224 f->revents = f->events;
225 if (_g_main_poll_debug)
226 g_print (" got event %p\n", (HANDLE) f->fd);
227
228 /* Do not count the stop_fd */
229 retval = (f != stop_fd) ? 1 : 0;
230
231 /* If no timeout and polling several handles, recurse to poll
232 * the rest of them.
233 */
234 if (timeout_ms == 0 && nhandles > 1)
235 {
236 /* Poll the handles with index > ready */
237 HANDLE *shorter_handles;
238 GPollFD **shorter_handle_to_fd;
239 gint shorter_nhandles;
240
241 shorter_handles = &handles[ready - WAIT_OBJECT_0 + 1];
242 shorter_handle_to_fd = &handle_to_fd[ready - WAIT_OBJECT_0 + 1];
243 shorter_nhandles = nhandles - (ready - WAIT_OBJECT_0 + 1);
244
245 recursed_result = poll_rest (NULL, stop_fd, shorter_handles, shorter_handle_to_fd, shorter_nhandles, 0);
246 return (recursed_result == -1) ? -1 : retval + recursed_result;
247 }
248 return retval;
249 }
250
251 return 0;
252}
253
254typedef struct
255{
256 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
257 GPollFD *handle_to_fd[MAXIMUM_WAIT_OBJECTS];
258 GPollFD *msg_fd;
259 GPollFD *stop_fd;
260 gint nhandles;
261 gint timeout_ms;
262} GWin32PollThreadData;
263
264static gint
265poll_single_thread (GWin32PollThreadData *data)
266{
267 int retval;
268
269 /* Polling for several things? */
270 if (data->nhandles > 1 || (data->nhandles > 0 && data->msg_fd != NULL))
271 {
272 /* First check if one or several of them are immediately
273 * available
274 */
275 retval = poll_rest (data->msg_fd, data->stop_fd, data->handles, data->handle_to_fd, data->nhandles, 0);
276
277 /* If not, and we have a significant timeout, poll again with
278 * timeout then. Note that this will return indication for only
279 * one event, or only for messages.
280 */
281 if (retval == 0 && (data->timeout_ms == INFINITE || data->timeout_ms > 0))
282 retval = poll_rest (data->msg_fd, data->stop_fd, data->handles, data->handle_to_fd, data->nhandles, data->timeout_ms);
283 }
284 else
285 {
286 /* Just polling for one thing, so no need to check first if
287 * available immediately
288 */
289 retval = poll_rest (data->msg_fd, data->stop_fd, data->handles, data->handle_to_fd, data->nhandles, data->timeout_ms);
290 }
291
292 return retval;
293}
294
295static void
296fill_poll_thread_data (GPollFD *fds,
297 guint nfds,
298 gint timeout_ms,
299 GPollFD *stop_fd,
300 GWin32PollThreadData *data)
301{
302 GPollFD *f;
303
304 data->timeout_ms = timeout_ms;
305
306 if (stop_fd != NULL)
307 {
308 if (_g_main_poll_debug)
309 g_print (" Stop FD: %p", (HANDLE) stop_fd->fd);
310
311 g_assert (data->nhandles < MAXIMUM_WAIT_OBJECTS);
312
313 data->stop_fd = stop_fd;
314 data->handle_to_fd[data->nhandles] = stop_fd;
315 data->handles[data->nhandles++] = (HANDLE) stop_fd->fd;
316 }
317
318 for (f = fds; f < &fds[nfds]; ++f)
319 {
320 if ((data->nhandles == MAXIMUM_WAIT_OBJECTS) ||
321 (data->msg_fd != NULL && (data->nhandles == MAXIMUM_WAIT_OBJECTS - 1)))
322 {
323 g_warning ("Too many handles to wait for!");
324 break;
325 }
326
327 if (f->fd == G_WIN32_MSG_HANDLE && (f->events & G_IO_IN))
328 {
329 if (_g_main_poll_debug && data->msg_fd == NULL)
330 g_print (" MSG");
331 data->msg_fd = f;
332 }
333 else if (f->fd > 0)
334 {
335 if (_g_main_poll_debug)
336 g_print (" %p", (HANDLE) f->fd);
337 data->handle_to_fd[data->nhandles] = f;
338 data->handles[data->nhandles++] = (HANDLE) f->fd;
339 }
340
341 f->revents = 0;
342 }
343}
344
345static guint __stdcall
346poll_thread_run (gpointer user_data)
347{
348 GWin32PollThreadData *data = user_data;
349
350 /* Docs say that it is safer to call _endthreadex by our own:
351 * https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/endthread-endthreadex
352 */
353 _endthreadex (poll_single_thread (data));
354
355 g_assert_not_reached ();
356
357 return 0;
358}
359
360/* One slot for a possible msg object or the stop event */
361#define MAXIMUM_WAIT_OBJECTS_PER_THREAD (MAXIMUM_WAIT_OBJECTS - 1)
362
363gint
364g_poll (GPollFD *fds,
365 guint nfds,
366 gint timeout)
367{
368 guint nthreads, threads_remain;
369 HANDLE thread_handles[MAXIMUM_WAIT_OBJECTS];
370 GWin32PollThreadData *threads_data;
371 GPollFD stop_event = { 0, };
372 GPollFD *f;
373 guint i, fds_idx = 0;
374 DWORD ready;
375 DWORD thread_retval;
376 int retval;
377 GPollFD *msg_fd = NULL;
378
379 if (timeout == -1)
380 timeout = INFINITE;
381
382 /* Simple case without extra threads */
383 if (nfds <= MAXIMUM_WAIT_OBJECTS)
384 {
385 GWin32PollThreadData data = { 0, };
386
387 if (_g_main_poll_debug)
388 g_print ("g_poll: waiting for");
389
390 fill_poll_thread_data (fds, nfds, timeout, NULL, &data);
391
392 if (_g_main_poll_debug)
393 g_print ("\n");
394
395 retval = poll_single_thread (&data);
396 if (retval == -1)
397 for (f = fds; f < &fds[nfds]; ++f)
398 f->revents = 0;
399
400 return retval;
401 }
402
403 if (_g_main_poll_debug)
404 g_print ("g_poll: polling with threads\n");
405
406 nthreads = nfds / MAXIMUM_WAIT_OBJECTS_PER_THREAD;
407 threads_remain = nfds % MAXIMUM_WAIT_OBJECTS_PER_THREAD;
408 if (threads_remain > 0)
409 nthreads++;
410
411 if (nthreads > MAXIMUM_WAIT_OBJECTS_PER_THREAD)
412 {
413 g_warning ("Too many handles to wait for in threads!");
414 nthreads = MAXIMUM_WAIT_OBJECTS_PER_THREAD;
415 }
416
417#if GLIB_SIZEOF_VOID_P == 8
418 stop_event.fd = (gint64)CreateEventW (NULL, TRUE, FALSE, NULL);
419#else
420 stop_event.fd = (gint)CreateEventW (NULL, TRUE, FALSE, NULL);
421#endif
422 stop_event.events = G_IO_IN;
423
424 threads_data = g_new0 (GWin32PollThreadData, nthreads);
425 for (i = 0; i < nthreads; i++)
426 {
427 guint thread_fds;
428 guint ignore;
429
430 if (i == (nthreads - 1) && threads_remain > 0)
431 thread_fds = threads_remain;
432 else
433 thread_fds = MAXIMUM_WAIT_OBJECTS_PER_THREAD;
434
435 fill_poll_thread_data (fds + fds_idx, thread_fds, timeout, &stop_event, &threads_data[i]);
436 fds_idx += thread_fds;
437
438 /* We must poll for messages from the same thread, so poll it along with the threads */
439 if (threads_data[i].msg_fd != NULL)
440 {
441 msg_fd = threads_data[i].msg_fd;
442 threads_data[i].msg_fd = NULL;
443 }
444
445 thread_handles[i] = (HANDLE) _beginthreadex (NULL, 0, poll_thread_run, &threads_data[i], 0, &ignore);
446 }
447
448 /* Wait for at least one thread to return */
449 if (msg_fd != NULL)
450 ready = MsgWaitForMultipleObjectsEx (nthreads, thread_handles, timeout,
451 QS_ALLINPUT, MWMO_ALERTABLE);
452 else
453 ready = WaitForMultipleObjects (nthreads, thread_handles, FALSE, timeout);
454
455 /* Signal the stop in case any of the threads did not stop yet */
456 if (!SetEvent ((HANDLE)stop_event.fd))
457 {
458 gchar *emsg = g_win32_error_message (GetLastError ());
459 g_warning ("gpoll: failed to signal the stop event: %s", emsg);
460 g_free (emsg);
461 }
462
463 /* Wait for the rest of the threads to finish */
464 WaitForMultipleObjects (nthreads, thread_handles, TRUE, INFINITE);
465
466 /* The return value of all the threads give us all the fds that changed state */
467 retval = 0;
468 if (msg_fd != NULL && ready == WAIT_OBJECT_0 + nthreads)
469 {
470 msg_fd->revents |= G_IO_IN;
471 retval = 1;
472 }
473
474 for (i = 0; i < nthreads; i++)
475 {
476 if (GetExitCodeThread (thread_handles[i], &thread_retval))
477 retval = retval == -1 ? -1 : thread_retval == -1 ? -1 : retval + thread_retval;
478
479 CloseHandle (thread_handles[i]);
480 }
481
482 if (retval == -1)
483 for (f = fds; f < &fds[nfds]; ++f)
484 f->revents = 0;
485
486 g_free (threads_data);
487 CloseHandle ((HANDLE)stop_event.fd);
488
489 return retval;
490}
491
492#else /* !G_OS_WIN32 */
493
494/* The following implementation of poll() comes from the GNU C Library.
495 * Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
496 */
497
498#include <string.h> /* for bzero on BSD systems */
499
500#ifdef HAVE_SYS_SELECT_H
501#include <sys/select.h>
502#endif /* HAVE_SYS_SELECT_H */
503
504gint
505g_poll (GPollFD *fds,
506 guint nfds,
507 gint timeout)
508{
509 struct timeval tv;
510 fd_set rset, wset, xset;
511 GPollFD *f;
512 int ready;
513 int maxfd = 0;
514
515 FD_ZERO (&rset);
516 FD_ZERO (&wset);
517 FD_ZERO (&xset);
518
519 for (f = fds; f < &fds[nfds]; ++f)
520 if (f->fd >= 0)
521 {
522 if (f->events & G_IO_IN)
523 FD_SET (f->fd, &rset);
524 if (f->events & G_IO_OUT)
525 FD_SET (f->fd, &wset);
526 if (f->events & G_IO_PRI)
527 FD_SET (f->fd, &xset);
528 if (f->fd > maxfd && (f->events & (G_IO_IN|G_IO_OUT|G_IO_PRI)))
529 maxfd = f->fd;
530 }
531
532 tv.tv_sec = timeout / 1000;
533 tv.tv_usec = (timeout % 1000) * 1000;
534
535 ready = select (maxfd + 1, &rset, &wset, &xset,
536 timeout == -1 ? NULL : &tv);
537 if (ready > 0)
538 for (f = fds; f < &fds[nfds]; ++f)
539 {
540 f->revents = 0;
541 if (f->fd >= 0)
542 {
543 if (FD_ISSET (f->fd, &rset))
544 f->revents |= G_IO_IN;
545 if (FD_ISSET (f->fd, &wset))
546 f->revents |= G_IO_OUT;
547 if (FD_ISSET (f->fd, &xset))
548 f->revents |= G_IO_PRI;
549 }
550 }
551
552 return ready;
553}
554
555#endif /* !G_OS_WIN32 */
556
557#endif /* !HAVE_POLL */
558

source code of gtk/subprojects/glib/glib/gpoll.c