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 Library General Public
   7    License as published by the Free Software Foundation; either
   8    version 2 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    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library 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
 144 again:
 145   result = read (iks->fd, buffer, buffer_len);
 146
 147   if (result < 0)
 148     {
 149       if (errno == EINTR)
 150         goto again;
 151
 152       if (errno == EAGAIN)
 153         return 0;
 154
 155       g_error ("inotify read(): %s", g_strerror (errno));
 156     }
 157   else if (result == 0)
 158     g_error ("inotify unexpectedly hit eof");
 159
 160   return result;
 161 }
 162
 163 static gchar *
 164 ik_source_read_all_the_events (InotifyKernelSource *iks,
 165                                gchar               *buffer,
 166                                gsize                buffer_len,
 167                                gsize               *length_out)
 168 {
 169   gsize n_read;
 170
 171   n_read = ik_source_read_some_events (iks, buffer, buffer_len);
 172
 173   /* Check if we might have gotten another event if we had passed in a
 174    * bigger buffer...
 175    */
 176   if (n_read + MAX_EVENT_SIZE > buffer_len)
 177     {
 178       gchar *new_buffer;
 179       guint n_readable;
 180       gint result;
 181
 182       /* figure out how many more bytes there are to read */
 183       result = ioctl (iks->fd, FIONREAD, &n_readable);
 184       if (result != 0)
 185         g_error ("inotify ioctl(FIONREAD): %s", g_strerror (errno));
 186
 187       if (n_readable != 0)
 188         {
 189           /* there is in fact more data.  allocate a new buffer, copy
 190            * the existing data, and then append the remaining.
 191            */
 192           new_buffer = g_malloc (n_read + n_readable);
 193           memcpy (new_buffer, buffer, n_read);
 194           n_read += ik_source_read_some_events (iks, new_buffer + n_read, n_readable);
 195
 196           buffer = new_buffer;
 197
 198           /* There may be new events in the buffer that were added after
 199            * the FIONREAD was performed, but we can't risk getting into
 200            * a loop.  We'll get them next time.
 201            */
 202         }
 203     }
 204
 205   *length_out = n_read;
 206
 207   return buffer;
 208 }
 209
 210 static gboolean
 211 ik_source_dispatch (GSource     *source,
 212                     GSourceFunc  func,
 213                     gpointer     user_data)
 214 {
 215   InotifyKernelSource *iks = (InotifyKernelSource *) source;
 216   gboolean (*user_callback) (ik_event_t *event) = (void *) func;
 217   gboolean interesting = FALSE;
 218   gint64 now;
 219
 220   now = g_source_get_time (source);
 221
 222   if (iks->is_bored || g_source_query_unix_fd (source, iks->fd_tag))
 223     {
 224       gchar stack_buffer[4096];
 225       gsize buffer_len;
 226       gchar *buffer;
 227       gsize offset;
 228
 229       /* We want to read all of the available events.
 230        *
 231        * We need to do it in a finite number of steps so that we don't
 232        * get caught in a loop of read() with another process
 233        * continuously adding events each time we drain them.
 234        *
 235        * In the normal case we will have only a few events in the queue,
 236        * so start out by reading into a small stack-allocated buffer.
 237        * Even though we're on a fresh stack frame, there is no need to
 238        * pointlessly blow up with the size of the worker thread stack
 239        * with a huge buffer here.
 240        *
 241        * If the result is large enough to cause us to suspect that
 242        * another event may be pending then we allocate a buffer on the
 243        * heap that can hold all of the events and read (once!) into that
 244        * buffer.
 245        */
 246       buffer = ik_source_read_all_the_events (iks, stack_buffer, sizeof stack_buffer, &buffer_len);
 247
 248       offset = 0;
 249
 250       while (offset < buffer_len)
 251         {
 252           struct inotify_event *kevent = (struct inotify_event *) (buffer + offset);
 253           ik_event_t *event;
 254
 255           event = ik_event_new (kevent, now);
 256
 257           offset += sizeof (struct inotify_event) + event->len;
 258
 259           if (event->mask & IN_MOVED_TO)
 260             {
 261               ik_event_t *pair;
 262
 263               pair = g_hash_table_lookup (iks->unmatched_moves, GUINT_TO_POINTER (event->cookie));
 264               if (pair != NULL)
 265                 {
 266                   g_assert (!pair->pair);
 267
 268                   g_hash_table_remove (iks->unmatched_moves, GUINT_TO_POINTER (event->cookie));
 269                   event->is_second_in_pair = TRUE;
 270                   event->pair = pair;
 271                   pair->pair = event;
 272                   continue;
 273                 }
 274
 275               interesting = TRUE;
 276             }
 277
 278           else if (event->mask & IN_MOVED_FROM)
 279             {
 280               gboolean new;
 281
 282               new = g_hash_table_insert (iks->unmatched_moves, GUINT_TO_POINTER (event->cookie), event);
 283               if G_UNLIKELY (!new)
 284                 g_warning ("inotify: got IN_MOVED_FROM event with already-pending cookie %#x", event->cookie);
 285
 286               interesting = TRUE;
 287             }
 288
 289           g_queue_push_tail (&iks->queue, event);
 290         }
 291
 292       if (buffer_len == 0)
 293         {
 294           /* We can end up reading nothing if we arrived here due to a
 295            * boredom timer but the stream of events stopped meanwhile.
 296            *
 297            * In that case, we need to switch back to polling the file
 298            * descriptor in the usual way.
 299            */
 300           g_assert (iks->is_bored);
 301           interesting = TRUE;
 302         }
 303
 304       if (buffer != stack_buffer)
 305         g_free (buffer);
 306     }
 307
 308   while (ik_source_can_dispatch_now (iks, now))
 309     {
 310       ik_event_t *event;
 311
 312       /* callback will free the event */
 313       event = g_queue_pop_head (&iks->queue);
 314
 315       if (event->mask & IN_MOVED_FROM && !event->pair)
 316         g_hash_table_remove (iks->unmatched_moves, GUINT_TO_POINTER (event->cookie));
 317
 318       G_LOCK (inotify_lock);
 319
 320       interesting |= (* user_callback) (event);
 321
 322       G_UNLOCK (inotify_lock);
 323     }
 324
 325   /* The queue gets blocked iff we have unmatched moves */
 326   g_assert ((iks->queue.length > 0) == (g_hash_table_size (iks->unmatched_moves) > 0));
 327
 328   /* Here's where we decide what will wake us up next.
 329    *
 330    * If the last event was interesting then we will wake up on the fd or
 331    * when the timeout is reached on an unpaired move (if any).
 332    *
 333    * If the last event was uninteresting then we will wake up after the
 334    * shorter of the boredom sleep or any timeout for a unpaired move.
 335    */
 336   if (interesting)
 337     {
 338       if (iks->is_bored)
 339         {
 340           g_source_modify_unix_fd (source, iks->fd_tag, G_IO_IN);
 341           iks->is_bored = FALSE;
 342         }
 343
 344       g_source_set_ready_time (source, ik_source_get_dispatch_time (iks));
 345     }
 346   else
 347     {
 348       guint64 dispatch_time = ik_source_get_dispatch_time (iks);
 349       guint64 boredom_time = now + BOREDOM_SLEEP_TIME;
 350
 351       if (!iks->is_bored)
 352         {
 353           g_source_modify_unix_fd (source, iks->fd_tag, 0);
 354           iks->is_bored = TRUE;
 355         }
 356
 357       g_source_set_ready_time (source, MIN (dispatch_time, boredom_time));
 358     }
 359
 360   return TRUE;
 361 }
 362
 363 static InotifyKernelSource *
 364 ik_source_new (gboolean (* callback) (ik_event_t *event))
 365 {
 366   static GSourceFuncs source_funcs = {
 367     NULL, NULL,
 368     ik_source_dispatch
 369     /* should have a finalize, but it will never happen */
 370   };
 371   InotifyKernelSource *iks;
 372   GSource *source;
 373
 374   source = g_source_new (&source_funcs, sizeof (InotifyKernelSource));
 375   iks = (InotifyKernelSource *) source;
 376
 377   g_source_set_name (source, "inotify kernel source");
 378
 379   iks->unmatched_moves = g_hash_table_new (NULL, NULL);
 380   iks->fd = inotify_init1 (IN_CLOEXEC);
 381
 382   if (iks->fd < 0)
 383     iks->fd = inotify_init ();
 384
 385   if (iks->fd >= 0)
 386     {
 387       GError *error = NULL;
 388
 389       g_unix_set_fd_nonblocking (iks->fd, TRUE, &error);
 390       g_assert_no_error (error);
 391
 392       iks->fd_tag = g_source_add_unix_fd (source, iks->fd, G_IO_IN);
 393     }
 394
 395   g_source_set_callback (source, (GSourceFunc) callback, NULL, NULL);
 396
 397   g_source_attach (source, GLIB_PRIVATE_CALL (g_get_worker_context) ());
 398
 399   return iks;
 400 }
 401
 402 gboolean
 403 _ik_startup (gboolean (*cb)(ik_event_t *event))
 404 {
 405   if (g_once_init_enter (&inotify_source))
 406     g_once_init_leave (&inotify_source, ik_source_new (cb));
 407
 408   return inotify_source->fd >= 0;
 409 }
 410
 411 gint32
 412 _ik_watch (const char *path,
 413            guint32     mask,
 414            int        *err)
 415 {
 416   gint32 wd = -1;
 417
 418   g_assert (path != NULL);
 419   g_assert (inotify_source && inotify_source->fd >= 0);
 420
 421   wd = inotify_add_watch (inotify_source->fd, path, mask);
 422
 423   if (wd < 0)
 424     {
 425       int e = errno;
 426       /* FIXME: debug msg failed to add watch */
 427       if (err)
 428         *err = e;
 429       return wd;
 430     }
 431
 432   g_assert (wd >= 0);
 433   return wd;
 434 }
 435
 436 int
 437 _ik_ignore (const char *path,
 438             gint32      wd)
 439 {
 440   g_assert (wd >= 0);
 441   g_assert (inotify_source && inotify_source->fd >= 0);
 442
 443   if (inotify_rm_watch (inotify_source->fd, wd) < 0)
 444     {
 445       /* int e = errno; */
 446       /* failed to rm watch */
 447       return -1;
 448     }
 449
 450   return 0;
 451 }