gio/inotify/inotify-kernel.c

   1 /*
   2    Copyright (C) 2005 John McCutchan
   3    Copyright © 2015 Canonical Limited
   4
   5    This library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    This library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public License
  16    along with this library; if not, see <http://www.gnu.org/licenses/>.
  17
  18    Authors:
  19      Ryan Lortie <desrt@desrt.ca>
  20      John McCutchan <john@johnmccutchan.com>
  21 */
  22
  23 #include "config.h"
  24
  25 #include <stdio.h>
  26 #include <sys/ioctl.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29 #include <string.h>
  30 #include <glib.h>
  31 #include "inotify-kernel.h"
  32 #include <sys/inotify.h>
  33 #include <glib/glib-unix.h>
  34
  35 #include "glib-private.h"
  36
  37 /* From inotify(7) */
  38 #define MAX_EVENT_SIZE       (sizeof(struct inotify_event) + NAME_MAX + 1)
  39
  40 /* Amount of time to sleep on receipt of uninteresting events */
  41 #define BOREDOM_SLEEP_TIME   (100 * G_TIME_SPAN_MILLISECOND)
  42
  43 /* Define limits on the maximum amount of time and maximum amount of
  44  * interceding events between FROM/TO that can be merged.
  45  */
  46 #define MOVE_PAIR_DELAY      (10 * G_TIME_SPAN_MILLISECOND)
  47 #define MOVE_PAIR_DISTANCE   (100)
  48
  49 /* We use the lock from inotify-helper.c
  50  *
  51  * We only have to take it on our read callback.
  52  *
  53  * The rest of locking is taken care of in inotify-helper.c
  54  */
  55 G_LOCK_EXTERN (inotify_lock);
  56
  57 static ik_event_t *
  58 ik_event_new (struct inotify_event *kevent,
  59               gint64                now)
  60 {
  61   ik_event_t *event = g_new0 (ik_event_t, 1);
  62
  63   event->wd = kevent->wd;
  64   event->mask = kevent->mask;
  65   event->cookie = kevent->cookie;
  66   event->len = kevent->len;
  67   event->timestamp = now;
  68   if (event->len)
  69     event->name = g_strdup (kevent->name);
  70   else
  71     event->name = NULL;
  72
  73   return event;
  74 }
  75
  76 void
  77 _ik_event_free (ik_event_t *event)
  78 {
  79   if (event->pair)
  80     {
  81       event->pair->pair = NULL;
  82       _ik_event_free (event->pair);
  83     }
  84
  85   g_free (event->name);
  86   g_free (event);
  87 }
  88
  89 typedef struct
  90 {
  91   GSource     source;
  92
  93   GQueue      queue;
  94   gpointer    fd_tag;
  95   gint        fd;
  96
  97   GHashTable *unmatched_moves;
  98   gboolean    is_bored;
  99 } InotifyKernelSource;
 100
 101 static InotifyKernelSource *inotify_source;
 102
 103 static gint64
 104 ik_source_get_dispatch_time (InotifyKernelSource *iks)
 105 {
 106   ik_event_t *head;
 107
 108   head = g_queue_peek_head (&iks->queue);
 109
 110   /* nothing in the queue: not ready */
 111   if (!head)
 112     return -1;
 113
 114   /* if it's not an unpaired move, it is ready now */
 115   if (~head->mask & IN_MOVED_FROM || head->pair)
 116     return 0;
 117
 118   /* if the queue is too long then it's ready now */
 119   if (iks->queue.length > MOVE_PAIR_DISTANCE)
 120     return 0;
 121
 122   /* otherwise, it's ready after the delay */
 123   return head->timestamp + MOVE_PAIR_DELAY;
 124 }
 125
 126 static gboolean
 127 ik_source_can_dispatch_now (InotifyKernelSource *iks,
 128                             gint64               now)
 129 {
 130   gint64 dispatch_time;
 131
 132   dispatch_time = ik_source_get_dispatch_time (iks);
 133
 134   return 0 <= dispatch_time && dispatch_time <= now;
 135 }
 136
 137 static gsize
 138 ik_source_read_some_events (InotifyKernelSource *iks,
 139                             gchar               *buffer,
 140                             gsize                buffer_len)
 141 {
 142   gssize result;
 143   int errsv;
 144
 145 again:
 146   result = read (iks->fd, buffer, buffer_len);
 147   errsv = errno;
 148
 149   if (result < 0)
 150     {
 151       if (errsv == EINTR)
 152         goto again;
 153
 154       if (errsv == EAGAIN)
 155         return 0;
 156
 157       g_error ("inotify read(): %s", g_strerror (errsv));
 158     }
 159   else if (result == 0)
 160     g_error ("inotify unexpectedly hit eof");
 161
 162   return result;
 163 }
 164
 165 static gchar *
 166 ik_source_read_all_the_events (InotifyKernelSource *iks,
 167                                gchar               *buffer,
 168                                gsize                buffer_len,
 169                                gsize               *length_out)
 170 {
 171   gsize n_read;
 172
 173   n_read = ik_source_read_some_events (iks, buffer, buffer_len);
 174
 175   /* Check if we might have gotten another event if we had passed in a
 176    * bigger buffer...
 177    */
 178   if (n_read + MAX_EVENT_SIZE > buffer_len)
 179     {
 180       gchar *new_buffer;
 181       guint n_readable;
 182       gint result;
 183       int errsv;
 184
 185       /* figure out how many more bytes there are to read */
 186       result = ioctl (iks->fd, FIONREAD, &n_readable);
 187       errsv = errno;
 188       if (result != 0)
 189         g_error ("inotify ioctl(FIONREAD): %s", g_strerror (errsv));
 190
 191       if (n_readable != 0)
 192         {
 193           /* there is in fact more data.  allocate a new buffer, copy
 194            * the existing data, and then append the remaining.
 195            */
 196           new_buffer = g_malloc (n_read + n_readable);
 197           memcpy (new_buffer, buffer, n_read);
 198           n_read += ik_source_read_some_events (iks, new_buffer + n_read, n_readable);
 199
 200           buffer = new_buffer;
 201
 202           /* There may be new events in the buffer that were added after
 203            * the FIONREAD was performed, but we can't risk getting into
 204            * a loop.  We'll get them next time.
 205            */
 206         }
 207     }
 208
 209   *length_out = n_read;
 210
 211   return buffer;
 212 }
 213
 214 static gboolean
 215 ik_source_dispatch (GSource     *source,
 216                     GSourceFunc  func,
 217                     gpointer     user_data)
 218 {
 219   InotifyKernelSource *iks = (InotifyKernelSource *) source;
 220   gboolean (*user_callback) (ik_event_t *event) = (void *) func;
 221   gboolean interesting = FALSE;
 222   gint64 now;
 223
 224   now = g_source_get_time (source);
 225
 226   if (iks->is_bored || g_source_query_unix_fd (source, iks->fd_tag))
 227     {
 228       gchar stack_buffer[4096];
 229       gsize buffer_len;
 230       gchar *buffer;
 231       gsize offset;
 232
 233       /* We want to read all of the available events.
 234        *
 235        * We need to do it in a finite number of steps so that we don't
 236        * get caught in a loop of read() with another process
 237        * continuously adding events each time we drain them.
 238        *
 239        * In the normal case we will have only a few events in the queue,
 240        * so start out by reading into a small stack-allocated buffer.
 241        * Even though we're on a fresh stack frame, there is no need to
 242        * pointlessly blow up with the size of the worker thread stack
 243        * with a huge buffer here.
 244        *
 245        * If the result is large enough to cause us to suspect that
 246        * another event may be pending then we allocate a buffer on the
 247        * heap that can hold all of the events and read (once!) into that
 248        * buffer.
 249        */
 250       buffer = ik_source_read_all_the_events (iks, stack_buffer, sizeof stack_buffer, &buffer_len);
 251
 252       offset = 0;
 253
 254       while (offset < buffer_len)
 255         {
 256           struct inotify_event *kevent = (struct inotify_event *) (buffer + offset);
 257           ik_event_t *event;
 258
 259           event = ik_event_new (kevent, now);
 260
 261           offset += sizeof (struct inotify_event) + event->len;
 262
 263           if (event->mask & IN_MOVED_TO)
 264             {
 265               ik_event_t *pair;
 266
 267               pair = g_hash_table_lookup (iks->unmatched_moves, GUINT_TO_POINTER (event->cookie));
 268               if (pair != NULL)
 269                 {
 270                   g_assert (!pair->pair);
 271
 272                   g_hash_table_remove (iks->unmatched_moves, GUINT_TO_POINTER (event->cookie));
 273                   event->is_second_in_pair = TRUE;
 274                   event->pair = pair;
 275                   pair->pair = event;
 276                   continue;
 277                 }
 278
 279               interesting = TRUE;
 280             }
 281
 282           else if (event->mask & IN_MOVED_FROM)
 283             {
 284               gboolean new;
 285
 286               new = g_hash_table_insert (iks->unmatched_moves, GUINT_TO_POINTER (event->cookie), event);
 287               if G_UNLIKELY (!new)
 288                 g_warning ("inotify: got IN_MOVED_FROM event with already-pending cookie %#x", event->cookie);
 289
 290               interesting = TRUE;
 291             }
 292
 293           g_queue_push_tail (&iks->queue, event);
 294         }
 295
 296       if (buffer_len == 0)
 297         {
 298           /* We can end up reading nothing if we arrived here due to a
 299            * boredom timer but the stream of events stopped meanwhile.
 300            *
 301            * In that case, we need to switch back to polling the file
 302            * descriptor in the usual way.
 303            */
 304           g_assert (iks->is_bored);
 305           interesting = TRUE;
 306         }
 307
 308       if (buffer != stack_buffer)
 309         g_free (buffer);
 310     }
 311
 312   while (ik_source_can_dispatch_now (iks, now))
 313     {
 314       ik_event_t *event;
 315
 316       /* callback will free the event */
 317       event = g_queue_pop_head (&iks->queue);
 318
 319       if (event->mask & IN_MOVED_FROM && !event->pair)
 320         g_hash_table_remove (iks->unmatched_moves, GUINT_TO_POINTER (event->cookie));
 321
 322       G_LOCK (inotify_lock);
 323
 324       interesting |= (* user_callback) (event);
 325
 326       G_UNLOCK (inotify_lock);
 327     }
 328
 329   /* The queue gets blocked iff we have unmatched moves */
 330   g_assert ((iks->queue.length > 0) == (g_hash_table_size (iks->unmatched_moves) > 0));
 331
 332   /* Here's where we decide what will wake us up next.
 333    *
 334    * If the last event was interesting then we will wake up on the fd or
 335    * when the timeout is reached on an unpaired move (if any).
 336    *
 337    * If the last event was uninteresting then we will wake up after the
 338    * shorter of the boredom sleep or any timeout for a unpaired move.
 339    */
 340   if (interesting)
 341     {
 342       if (iks->is_bored)
 343         {
 344           g_source_modify_unix_fd (source, iks->fd_tag, G_IO_IN);
 345           iks->is_bored = FALSE;
 346         }
 347
 348       g_source_set_ready_time (source, ik_source_get_dispatch_time (iks));
 349     }
 350   else
 351     {
 352       guint64 dispatch_time = ik_source_get_dispatch_time (iks);
 353       guint64 boredom_time = now + BOREDOM_SLEEP_TIME;
 354
 355       if (!iks->is_bored)
 356         {
 357           g_source_modify_unix_fd (source, iks->fd_tag, 0);
 358           iks->is_bored = TRUE;
 359         }
 360
 361       g_source_set_ready_time (source, MIN (dispatch_time, boredom_time));
 362     }
 363
 364   return TRUE;
 365 }
 366
 367 static InotifyKernelSource *
 368 ik_source_new (gboolean (* callback) (ik_event_t *event))
 369 {
 370   static GSourceFuncs source_funcs = {
 371     NULL, NULL,
 372     ik_source_dispatch
 373     /* should have a finalize, but it will never happen */
 374   };
 375   InotifyKernelSource *iks;
 376   GSource *source;
 377
 378   source = g_source_new (&source_funcs, sizeof (InotifyKernelSource));
 379   iks = (InotifyKernelSource *) source;
 380
 381   g_source_set_name (source, "inotify kernel source");
 382
 383   iks->unmatched_moves = g_hash_table_new (NULL, NULL);
 384   iks->fd = inotify_init1 (IN_CLOEXEC);
 385
 386   if (iks->fd < 0)
 387     iks->fd = inotify_init ();
 388
 389   if (iks->fd >= 0)
 390     {
 391       GError *error = NULL;
 392
 393       g_unix_set_fd_nonblocking (iks->fd, TRUE, &error);
 394       g_assert_no_error (error);
 395
 396       iks->fd_tag = g_source_add_unix_fd (source, iks->fd, G_IO_IN);
 397     }
 398
 399   g_source_set_callback (source, (GSourceFunc) callback, NULL, NULL);
 400
 401   g_source_attach (source, GLIB_PRIVATE_CALL (g_get_worker_context) ());
 402
 403   return iks;
 404 }
 405
 406 gboolean
 407 _ik_startup (gboolean (*cb)(ik_event_t *event))
 408 {
 409   if (g_once_init_enter (&inotify_source))
 410     g_once_init_leave (&inotify_source, ik_source_new (cb));
 411
 412   return inotify_source->fd >= 0;
 413 }
 414
 415 gint32
 416 _ik_watch (const char *path,
 417            guint32     mask,
 418            int        *err)
 419 {
 420   gint32 wd = -1;
 421
 422   g_assert (path != NULL);
 423   g_assert (inotify_source && inotify_source->fd >= 0);
 424
 425   wd = inotify_add_watch (inotify_source->fd, path, mask);
 426
 427   if (wd < 0)
 428     {
 429       int e = errno;
 430       /* FIXME: debug msg failed to add watch */
 431       if (err)
 432         *err = e;
 433       return wd;
 434     }
 435
 436   g_assert (wd >= 0);
 437   return wd;
 438 }
 439
 440 int
 441 _ik_ignore (const char *path,
 442             gint32      wd)
 443 {
 444   g_assert (wd >= 0);
 445   g_assert (inotify_source && inotify_source->fd >= 0);
 446
 447   if (inotify_rm_watch (inotify_source->fd, wd) < 0)
 448     {
 449       /* int e = errno; */
 450       /* failed to rm watch */
 451       return -1;
 452     }
 453
 454   return 0;
 455 }