gio/inotify/inotify-helper.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 8 -*- */
   2
   3 /* inotify-helper.c - GVFS Monitor based on inotify.
   4
   5    Copyright (C) 2007 John McCutchan
   6
   7    This library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Library General Public
   9    License as published by the Free Software Foundation; either
  10    version 2 of the License, or (at your option) any later version.
  11
  12    This library is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Library General Public License for more details.
  16
  17    You should have received a copy of the GNU Library General Public License
  18    along with this library; if not, see <http://www.gnu.org/licenses/>.
  19
  20    Authors:
  21                  John McCutchan <john@johnmccutchan.com>
  22 */
  23
  24 #include "config.h"
  25 #include <errno.h>
  26 #include <time.h>
  27 #include <string.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/stat.h>
  30 /* Just include the local header to stop all the pain */
  31 #include <sys/inotify.h>
  32 #include <gio/glocalfilemonitor.h>
  33 #include <gio/gfile.h>
  34 #include "inotify-helper.h"
  35 #include "inotify-missing.h"
  36 #include "inotify-path.h"
  37
  38 static gboolean ih_debug_enabled = FALSE;
  39 #define IH_W if (ih_debug_enabled) g_warning
  40
  41 static gboolean ih_event_callback (ik_event_t  *event,
  42                                    inotify_sub *sub,
  43                                    gboolean     file_event);
  44 static void ih_not_missing_callback (inotify_sub *sub);
  45
  46 /* We share this lock with inotify-kernel.c and inotify-missing.c
  47  *
  48  * inotify-kernel.c takes the lock when it reads events from
  49  * the kernel and when it processes those events
  50  *
  51  * inotify-missing.c takes the lock when it is scanning the missing
  52  * list.
  53  *
  54  * We take the lock in all public functions
  55  */
  56 G_LOCK_DEFINE (inotify_lock);
  57
  58 static GFileMonitorEvent ih_mask_to_EventFlags (guint32 mask);
  59
  60 /**
  61  * _ih_startup:
  62  *
  63  * Initializes the inotify backend.  This must be called before
  64  * any other functions in this module.
  65  *
  66  * Returns: #TRUE if initialization succeeded, #FALSE otherwise
  67  */
  68 gboolean
  69 _ih_startup (void)
  70 {
  71   static gboolean initialized = FALSE;
  72   static gboolean result = FALSE;
  73
  74   G_LOCK (inotify_lock);
  75
  76   if (initialized == TRUE)
  77     {
  78       G_UNLOCK (inotify_lock);
  79       return result;
  80     }
  81
  82   result = _ip_startup (ih_event_callback);
  83   if (!result)
  84     {
  85       G_UNLOCK (inotify_lock);
  86       return FALSE;
  87     }
  88   _im_startup (ih_not_missing_callback);
  89
  90   IH_W ("started gvfs inotify backend\n");
  91
  92   initialized = TRUE;
  93
  94   G_UNLOCK (inotify_lock);
  95
  96   return TRUE;
  97 }
  98
  99 /*
 100  * Adds a subscription to be monitored.
 101  */
 102 gboolean
 103 _ih_sub_add (inotify_sub *sub)
 104 {
 105   G_LOCK (inotify_lock);
 106
 107   if (!_ip_start_watching (sub))
 108     _im_add (sub);
 109
 110   G_UNLOCK (inotify_lock);
 111
 112   return TRUE;
 113 }
 114
 115 /*
 116  * Cancels a subscription which was being monitored.
 117  */
 118 gboolean
 119 _ih_sub_cancel (inotify_sub *sub)
 120 {
 121   G_LOCK (inotify_lock);
 122
 123   if (!sub->cancelled)
 124     {
 125       IH_W ("cancelling %s\n", sub->dirname);
 126       sub->cancelled = TRUE;
 127       _im_rm (sub);
 128       _ip_stop_watching (sub);
 129     }
 130
 131   G_UNLOCK (inotify_lock);
 132
 133   return TRUE;
 134 }
 135
 136 static char *
 137 _ih_fullpath_from_event (ik_event_t *event,
 138                          const char *dirname,
 139                          const char *filename)
 140 {
 141   char *fullpath;
 142
 143   if (filename)
 144     fullpath = g_strdup_printf ("%s/%s", dirname, filename);
 145   else if (event->name)
 146     fullpath = g_strdup_printf ("%s/%s", dirname, event->name);
 147   else
 148     fullpath = g_strdup_printf ("%s/", dirname);
 149
 150    return fullpath;
 151 }
 152
 153 static gboolean
 154 ih_event_callback (ik_event_t  *event,
 155                    inotify_sub *sub,
 156                    gboolean     file_event)
 157 {
 158   gboolean interesting;
 159
 160   g_assert (!file_event); /* XXX hardlink support */
 161
 162   if (event->mask & IN_MOVE)
 163     {
 164       /* We either have a rename (in the same directory) or a move
 165        * (between different directories).
 166        */
 167       if (event->pair && event->pair->wd == event->wd)
 168         {
 169           /* this is a rename */
 170           interesting = g_file_monitor_source_handle_event (sub->user_data, G_FILE_MONITOR_EVENT_RENAMED,
 171                                                             event->name, event->pair->name, NULL, event->timestamp);
 172         }
 173       else
 174         {
 175           GFile *other;
 176
 177           if (event->pair)
 178             {
 179               const char *parent_dir;
 180               gchar *fullpath;
 181
 182               parent_dir = _ip_get_path_for_wd (event->pair->wd);
 183               fullpath = _ih_fullpath_from_event (event->pair, parent_dir, NULL);
 184               other = g_file_new_for_path (fullpath);
 185               g_free (fullpath);
 186             }
 187           else
 188             other = NULL;
 189
 190           /* this is either an incoming or outgoing move */
 191           interesting = g_file_monitor_source_handle_event (sub->user_data, ih_mask_to_EventFlags (event->mask),
 192                                                             event->name, NULL, other, event->timestamp);
 193
 194           if (other)
 195             g_object_unref (other);
 196         }
 197     }
 198   else
 199     /* unpaired event -- no 'other' field */
 200     interesting = g_file_monitor_source_handle_event (sub->user_data, ih_mask_to_EventFlags (event->mask),
 201                                                       event->name, NULL, NULL, event->timestamp);
 202
 203   if (event->mask & IN_CREATE)
 204     {
 205       const gchar *parent_dir;
 206       gchar *fullname;
 207       struct stat buf;
 208       gint s;
 209
 210       /* The kernel reports IN_CREATE for two types of events:
 211        *
 212        *  - creat(), in which case IN_CLOSE_WRITE will come soon; or
 213        *  - link(), mkdir(), mknod(), etc., in which case it won't
 214        *
 215        * We can attempt to detect the second case and send the
 216        * CHANGES_DONE immediately so that the user isn't left waiting.
 217        *
 218        * The detection for link() is not 100% reliable since the link
 219        * count could be 1 if the original link was deleted or if
 220        * O_TMPFILE was being used, but in that case the virtual
 221        * CHANGES_DONE will be emitted to close the loop.
 222        */
 223
 224       parent_dir = _ip_get_path_for_wd (event->wd);
 225       fullname = _ih_fullpath_from_event (event, parent_dir, NULL);
 226       s = stat (fullname, &buf);
 227       g_free (fullname);
 228
 229       /* if it doesn't look like the result of creat()... */
 230       if (s != 0 || !S_ISREG (buf.st_mode) || buf.st_nlink != 1)
 231         g_file_monitor_source_handle_event (sub->user_data, G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
 232                                             event->name, NULL, NULL, event->timestamp);
 233     }
 234
 235   return interesting;
 236 }
 237
 238 static void
 239 ih_not_missing_callback (inotify_sub *sub)
 240 {
 241   gint now = g_get_monotonic_time ();
 242
 243   g_file_monitor_source_handle_event (sub->user_data, G_FILE_MONITOR_EVENT_CREATED,
 244                                       sub->filename, NULL, NULL, now);
 245   g_file_monitor_source_handle_event (sub->user_data, G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
 246                                       sub->filename, NULL, NULL, now);
 247 }
 248
 249 /* Transforms a inotify event to a GVFS event. */
 250 static GFileMonitorEvent
 251 ih_mask_to_EventFlags (guint32 mask)
 252 {
 253   mask &= ~IN_ISDIR;
 254   switch (mask)
 255     {
 256     case IN_MODIFY:
 257       return G_FILE_MONITOR_EVENT_CHANGED;
 258     case IN_CLOSE_WRITE:
 259       return G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT;
 260     case IN_ATTRIB:
 261       return G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED;
 262     case IN_MOVE_SELF:
 263     case IN_DELETE:
 264     case IN_DELETE_SELF:
 265       return G_FILE_MONITOR_EVENT_DELETED;
 266     case IN_CREATE:
 267       return G_FILE_MONITOR_EVENT_CREATED;
 268     case IN_MOVED_FROM:
 269       return G_FILE_MONITOR_EVENT_MOVED_OUT;
 270     case IN_MOVED_TO:
 271       return G_FILE_MONITOR_EVENT_MOVED_IN;
 272     case IN_UNMOUNT:
 273       return G_FILE_MONITOR_EVENT_UNMOUNTED;
 274     case IN_Q_OVERFLOW:
 275     case IN_OPEN:
 276     case IN_CLOSE_NOWRITE:
 277     case IN_ACCESS:
 278     case IN_IGNORED:
 279     default:
 280       return -1;
 281     }
 282 }