glib/gpoll.c

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