glib/gwakeup.c

   1 /*
   2  * Copyright © 2011 Canonical Limited
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the licence, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Author: Ryan Lortie <desrt@desrt.ca>
  18  */
  19
  20 #include "config.h"
  21
  22
  23 /* gwakeup.c is special -- GIO and some test cases include it.  As such,
  24  * it cannot include other glib headers without triggering the single
  25  * includes warnings.  We have to manually include its dependencies here
  26  * (and at all other use sites).
  27  */
  28 #ifdef GLIB_COMPILATION
  29 #include "gtypes.h"
  30 #include "gpoll.h"
  31 #else
  32 #include <glib.h>
  33 #endif
  34
  35 #include "gwakeup.h"
  36
  37 /*< private >
  38  * SECTION:gwakeup
  39  * @title: GWakeup
  40  * @short_description: portable cross-thread event signal mechanism
  41  *
  42  * #GWakeup is a simple and portable way of signaling events between
  43  * different threads in a way that integrates nicely with g_poll().
  44  * GLib uses it internally for cross-thread signalling in the
  45  * implementation of #GMainContext and #GCancellable.
  46  *
  47  * You first create a #GWakeup with g_wakeup_new() and initialise a
  48  * #GPollFD from it using g_wakeup_get_pollfd().  Polling on the created
  49  * #GPollFD will block until g_wakeup_signal() is called, at which point
  50  * it will immediately return.  Future attempts to poll will continue to
  51  * return until g_wakeup_acknowledge() is called.  g_wakeup_free() is
  52  * used to free a #GWakeup.
  53  *
  54  * On sufficiently modern Linux, this is implemented using eventfd.  On
  55  * Windows it is implemented using an event handle.  On other systems it
  56  * is implemented with a pair of pipes.
  57  *
  58  * Since: 2.30
  59  **/
  60 #ifdef _WIN32
  61
  62 #include <windows.h>
  63
  64 #ifdef GLIB_COMPILATION
  65 #include "gmessages.h"
  66 #include "giochannel.h"
  67 #include "gwin32.h"
  68 #endif
  69
  70 GWakeup *
  71 g_wakeup_new (void)
  72 {
  73   HANDLE wakeup;
  74
  75   wakeup = CreateEvent (NULL, TRUE, FALSE, NULL);
  76
  77   if (wakeup == NULL)
  78     g_error ("Cannot create event for GWakeup: %s",
  79              g_win32_error_message (GetLastError ()));
  80
  81   return (GWakeup *) wakeup;
  82 }
  83
  84 void
  85 g_wakeup_get_pollfd (GWakeup *wakeup,
  86                      GPollFD *poll_fd)
  87 {
  88   poll_fd->fd = (gintptr) wakeup;
  89   poll_fd->events = G_IO_IN;
  90 }
  91
  92 void
  93 g_wakeup_acknowledge (GWakeup *wakeup)
  94 {
  95   ResetEvent ((HANDLE) wakeup);
  96 }
  97
  98 void
  99 g_wakeup_signal (GWakeup *wakeup)
 100 {
 101   SetEvent ((HANDLE) wakeup);
 102 }
 103
 104 void
 105 g_wakeup_free (GWakeup *wakeup)
 106 {
 107   CloseHandle ((HANDLE) wakeup);
 108 }
 109
 110 #else
 111
 112 #include "glib-unix.h"
 113 #include <fcntl.h>
 114
 115 #if defined (HAVE_EVENTFD)
 116 #include <sys/eventfd.h>
 117 #endif
 118
 119 struct _GWakeup
 120 {
 121   gint fds[2];
 122 };
 123
 124 /**
 125  * g_wakeup_new:
 126  *
 127  * Creates a new #GWakeup.
 128  *
 129  * You should use g_wakeup_free() to free it when you are done.
 130  *
 131  * Returns: a new #GWakeup
 132  *
 133  * Since: 2.30
 134  **/
 135 GWakeup *
 136 g_wakeup_new (void)
 137 {
 138   GError *error = NULL;
 139   GWakeup *wakeup;
 140
 141   wakeup = g_slice_new (GWakeup);
 142
 143   /* try eventfd first, if we think we can */
 144 #if defined (HAVE_EVENTFD)
 145 #ifndef TEST_EVENTFD_FALLBACK
 146   wakeup->fds[0] = eventfd (0, EFD_CLOEXEC | EFD_NONBLOCK);
 147 #else
 148   wakeup->fds[0] = -1;
 149 #endif
 150
 151   if (wakeup->fds[0] != -1)
 152     {
 153       wakeup->fds[1] = -1;
 154       return wakeup;
 155     }
 156
 157   /* for any failure, try a pipe instead */
 158 #endif
 159
 160   if (!g_unix_open_pipe (wakeup->fds, FD_CLOEXEC, &error))
 161     g_error ("Creating pipes for GWakeup: %s\n", error->message);
 162
 163   if (!g_unix_set_fd_nonblocking (wakeup->fds[0], TRUE, &error) ||
 164       !g_unix_set_fd_nonblocking (wakeup->fds[1], TRUE, &error))
 165     g_error ("Set pipes non-blocking for GWakeup: %s\n", error->message);
 166
 167   return wakeup;
 168 }
 169
 170 /**
 171  * g_wakeup_get_pollfd:
 172  * @wakeup: a #GWakeup
 173  * @poll_fd: a #GPollFD
 174  *
 175  * Prepares a @poll_fd such that polling on it will succeed when
 176  * g_wakeup_signal() has been called on @wakeup.
 177  *
 178  * @poll_fd is valid until @wakeup is freed.
 179  *
 180  * Since: 2.30
 181  **/
 182 void
 183 g_wakeup_get_pollfd (GWakeup *wakeup,
 184                      GPollFD *poll_fd)
 185 {
 186   poll_fd->fd = wakeup->fds[0];
 187   poll_fd->events = G_IO_IN;
 188 }
 189
 190 /**
 191  * g_wakeup_acknowledge:
 192  * @wakeup: a #GWakeup
 193  *
 194  * Acknowledges receipt of a wakeup signal on @wakeup.
 195  *
 196  * You must call this after @wakeup polls as ready.  If not, it will
 197  * continue to poll as ready until you do so.
 198  *
 199  * If you call this function and @wakeup is not signaled, nothing
 200  * happens.
 201  *
 202  * Since: 2.30
 203  **/
 204 void
 205 g_wakeup_acknowledge (GWakeup *wakeup)
 206 {
 207   char buffer[16];
 208
 209   /* read until it is empty */
 210   while (read (wakeup->fds[0], buffer, sizeof buffer) == sizeof buffer);
 211 }
 212
 213 /**
 214  * g_wakeup_signal:
 215  * @wakeup: a #GWakeup
 216  *
 217  * Signals @wakeup.
 218  *
 219  * Any future (or present) polling on the #GPollFD returned by
 220  * g_wakeup_get_pollfd() will immediately succeed until such a time as
 221  * g_wakeup_acknowledge() is called.
 222  *
 223  * This function is safe to call from a UNIX signal handler.
 224  *
 225  * Since: 2.30
 226  **/
 227 void
 228 g_wakeup_signal (GWakeup *wakeup)
 229 {
 230   int res;
 231
 232   if (wakeup->fds[1] == -1)
 233     {
 234       guint64 one = 1;
 235
 236       /* eventfd() case. It requires a 64-bit counter increment value to be
 237        * written. */
 238       do
 239         res = write (wakeup->fds[0], &one, sizeof one);
 240       while (G_UNLIKELY (res == -1 && errno == EINTR));
 241     }
 242   else
 243     {
 244       guint8 one = 1;
 245
 246       /* Non-eventfd() case. Only a single byte needs to be written, and it can
 247        * have an arbitrary value. */
 248       do
 249         res = write (wakeup->fds[1], &one, sizeof one);
 250       while (G_UNLIKELY (res == -1 && errno == EINTR));
 251     }
 252 }
 253
 254 /**
 255  * g_wakeup_free:
 256  * @wakeup: a #GWakeup
 257  *
 258  * Frees @wakeup.
 259  *
 260  * You must not currently be polling on the #GPollFD returned by
 261  * g_wakeup_get_pollfd(), or the result is undefined.
 262  **/
 263 void
 264 g_wakeup_free (GWakeup *wakeup)
 265 {
 266   close (wakeup->fds[0]);
 267
 268   if (wakeup->fds[1] != -1)
 269     close (wakeup->fds[1]);
 270
 271   g_slice_free (GWakeup, wakeup);
 272 }
 273
 274 #endif /* !_WIN32 */