1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 8 -*- */
2
3 /* inotify-path.c - GVFS Monitor based on inotify.
4
5 Copyright (C) 2006 John McCutchan
6 Copyright (C) 2009 Codethink Limited
7
8 This library is free software; you can redistribute it and/or
9 modify it under the terms of the GNU Lesser General Public
10 License as published by the Free Software Foundation; either
11 version 2.1 of the License, or (at your option) any later version.
12
13 This library is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with this library; if not, see <http://www.gnu.org/licenses/>.
20
21 Authors:
22 John McCutchan <john@johnmccutchan.com>
23 Ryan Lortie <desrt@desrt.ca>
24 */
25
26 #include "config.h"
27
28 /* Don't put conflicting kernel types in the global namespace: */
29 #define __KERNEL_STRICT_NAMES
30
31 #include <sys/inotify.h>
32 #include <string.h>
33 #include <glib.h>
34 #include "inotify-kernel.h"
35 #include "inotify-path.h"
36 #include "inotify-missing.h"
37
38 #define IP_INOTIFY_DIR_MASK (IN_MODIFY|IN_ATTRIB|IN_MOVED_FROM|IN_MOVED_TO|IN_DELETE|IN_CREATE|IN_DELETE_SELF|IN_UNMOUNT|IN_MOVE_SELF|IN_CLOSE_WRITE)
39
40 #define IP_INOTIFY_FILE_MASK (IN_MODIFY|IN_ATTRIB|IN_CLOSE_WRITE)
41
42 /* Older libcs don't have this */
43 #ifndef IN_ONLYDIR
44 #define IN_ONLYDIR 0
45 #endif
46
47 typedef struct ip_watched_file_s {
48 gchar *filename;
49 gchar *path;
50 gint32 wd;
51
52 GList *subs;
53 } ip_watched_file_t;
54
55 typedef struct ip_watched_dir_s {
56 char *path;
57 /* TODO: We need to maintain a tree of watched directories
58 * so that we can deliver move/delete events to sub folders.
59 * Or the application could do it...
60 */
61 struct ip_watched_dir_s* parent;
62 GList* children;
63
64 /* basename -> ip_watched_file_t
65 * Maps basename to a ip_watched_file_t if the file is currently
66 * being directly watched for changes (ie: 'hardlinks' mode).
67 */
68 GHashTable *files_hash;
69
70 /* Inotify state */
71 gint32 wd;
72
73 /* List of inotify subscriptions */
74 GList *subs;
75 } ip_watched_dir_t;
76
77 static gboolean ip_debug_enabled = FALSE;
78 #define IP_W if (ip_debug_enabled) g_warning
79
80 /* path -> ip_watched_dir */
81 static GHashTable * path_dir_hash = NULL;
82 /* inotify_sub * -> ip_watched_dir *
83 *
84 * Each subscription is attached to a watched directory or it is on
85 * the missing list
86 */
87 static GHashTable * sub_dir_hash = NULL;
88 /* This hash holds GLists of ip_watched_dir_t *'s
89 * We need to hold a list because symbolic links can share
90 * the same wd
91 */
92 static GHashTable * wd_dir_hash = NULL;
93 /* This hash holds GLists of ip_watched_file_t *'s
94 * We need to hold a list because links can share
95 * the same wd
96 */
97 static GHashTable * wd_file_hash = NULL;
98
99 static ip_watched_dir_t *ip_watched_dir_new (const char *path,
100 int wd);
101 static void ip_watched_dir_free (ip_watched_dir_t *dir);
102 static gboolean ip_event_callback (ik_event_t *event);
103
104
105 static gboolean (*event_callback)(ik_event_t *event, inotify_sub *sub, gboolean file_event);
106
107 gboolean
108 _ip_startup (gboolean (*cb)(ik_event_t *event, inotify_sub *sub, gboolean file_event))
109 {
110 static gboolean initialized = FALSE;
111 static gboolean result = FALSE;
112
113 if (initialized == TRUE)
114 return result;
115
116 event_callback = cb;
117 result = _ik_startup (ip_event_callback);
118
119 if (!result)
120 return FALSE;
121
122 path_dir_hash = g_hash_table_new (g_str_hash, g_str_equal);
123 sub_dir_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
124 wd_dir_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
125 wd_file_hash = g_hash_table_new (g_direct_hash, g_direct_equal);
126
127 initialized = TRUE;
128 return TRUE;
129 }
130
131 static void
132 ip_map_path_dir (const char *path,
133 ip_watched_dir_t *dir)
134 {
135 g_assert (path && dir);
136 g_hash_table_insert (path_dir_hash, dir->path, dir);
137 }
138
139 static void
140 ip_map_sub_dir (inotify_sub *sub,
141 ip_watched_dir_t *dir)
142 {
143 /* Associate subscription and directory */
144 g_assert (dir && sub);
145 g_hash_table_insert (sub_dir_hash, sub, dir);
146 dir->subs = g_list_prepend (dir->subs, sub);
147 }
148
149 static void
150 ip_map_wd_dir (gint32 wd,
151 ip_watched_dir_t *dir)
152 {
153 GList *dir_list;
154
155 g_assert (wd >= 0 && dir);
156 dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER (wd));
157 dir_list = g_list_prepend (dir_list, dir);
158 g_hash_table_replace (wd_dir_hash, GINT_TO_POINTER (dir->wd), dir_list);
159 }
160
161 static void
162 ip_map_wd_file (gint32 wd,
163 ip_watched_file_t *file)
164 {
165 GList *file_list;
166
167 g_assert (wd >= 0 && file);
168 file_list = g_hash_table_lookup (wd_file_hash, GINT_TO_POINTER (wd));
169 file_list = g_list_prepend (file_list, file);
170 g_hash_table_replace (wd_file_hash, GINT_TO_POINTER (wd), file_list);
171 }
172
173 static void
174 ip_unmap_wd_file (gint32 wd,
175 ip_watched_file_t *file)
176 {
177 GList *file_list = g_hash_table_lookup (wd_file_hash, GINT_TO_POINTER (wd));
178
179 if (!file_list)
180 return;
181
182 g_assert (wd >= 0 && file);
183 file_list = g_list_remove (file_list, file);
184 if (file_list == NULL)
185 g_hash_table_remove (wd_file_hash, GINT_TO_POINTER (wd));
186 else
187 g_hash_table_replace (wd_file_hash, GINT_TO_POINTER (wd), file_list);
188 }
189
190
191 static ip_watched_file_t *
192 ip_watched_file_new (const gchar *dirname,
193 const gchar *filename)
194 {
195 ip_watched_file_t *file;
196
197 file = g_new0 (ip_watched_file_t, 1);
198 file->path = g_strjoin ("/", dirname, filename, NULL);
199 file->filename = g_strdup (filename);
200 file->wd = -1;
201
202 return file;
203 }
204
205 static void
206 ip_watched_file_free (ip_watched_file_t *file)
207 {
208 g_assert (file->subs == NULL);
209 g_free (file->filename);
210 g_free (file->path);
211 g_free (file);
212 }
213
214 static void
215 ip_watched_file_add_sub (ip_watched_file_t *file,
216 inotify_sub *sub)
217 {
218 file->subs = g_list_prepend (file->subs, sub);
219 }
220
221 static void
222 ip_watched_file_start (ip_watched_file_t *file)
223 {
224 if (file->wd < 0)
225 {
226 gint err;
227
228 file->wd = _ik_watch (file->path,
229 IP_INOTIFY_FILE_MASK,
230 &err);
231
232 if (file->wd >= 0)
233 ip_map_wd_file (file->wd, file);
234 }
235 }
236
237 static void
238 ip_watched_file_stop (ip_watched_file_t *file)
239 {
240 if (file->wd >= 0)
241 {
242 _ik_ignore (file->path, file->wd);
243 ip_unmap_wd_file (file->wd, file);
244 file->wd = -1;
245 }
246 }
247
248 gboolean
249 _ip_start_watching (inotify_sub *sub)
250 {
251 gint32 wd;
252 int err;
253 ip_watched_dir_t *dir;
254
255 g_assert (sub);
256 g_assert (!sub->cancelled);
257 g_assert (sub->dirname);
258
259 IP_W ("Starting to watch %s\n", sub->dirname);
260 dir = g_hash_table_lookup (path_dir_hash, sub->dirname);
261
262 if (dir == NULL)
263 {
264 IP_W ("Trying to add inotify watch ");
265 wd = _ik_watch (sub->dirname, IP_INOTIFY_DIR_MASK|IN_ONLYDIR, &err);
266 if (wd < 0)
267 {
268 IP_W ("Failed\n");
269 return FALSE;
270 }
271 else
272 {
273 /* Create new watched directory and associate it with the
274 * wd hash and path hash
275 */
276 IP_W ("Success\n");
277 dir = ip_watched_dir_new (sub->dirname, wd);
278 ip_map_wd_dir (wd, dir);
279 ip_map_path_dir (sub->dirname, dir);
280 }
281 }
282 else
283 IP_W ("Already watching\n");
284
285 if (sub->hardlinks)
286 {
287 ip_watched_file_t *file;
288
289 file = g_hash_table_lookup (dir->files_hash, sub->filename);
290
291 if (file == NULL)
292 {
293 file = ip_watched_file_new (sub->dirname, sub->filename);
294 g_hash_table_insert (dir->files_hash, file->filename, file);
295 }
296
297 ip_watched_file_add_sub (file, sub);
298 ip_watched_file_start (file);
299 }
300
301 ip_map_sub_dir (sub, dir);
302
303 return TRUE;
304 }
305
306 static void
307 ip_unmap_path_dir (const char *path,
308 ip_watched_dir_t *dir)
309 {
310 g_assert (path && dir);
311 g_hash_table_remove (path_dir_hash, dir->path);
312 }
313
314 static void
315 ip_unmap_wd_dir (gint32 wd,
316 ip_watched_dir_t *dir)
317 {
318 GList *dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER (wd));
319
320 if (!dir_list)
321 return;
322
323 g_assert (wd >= 0 && dir);
324 dir_list = g_list_remove (dir_list, dir);
325 if (dir_list == NULL)
326 g_hash_table_remove (wd_dir_hash, GINT_TO_POINTER (dir->wd));
327 else
328 g_hash_table_replace (wd_dir_hash, GINT_TO_POINTER (dir->wd), dir_list);
329 }
330
331 static void
332 ip_unmap_wd (gint32 wd)
333 {
334 GList *dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER (wd));
335 if (!dir_list)
336 return;
337 g_assert (wd >= 0);
338 g_hash_table_remove (wd_dir_hash, GINT_TO_POINTER (wd));
339 g_list_free (dir_list);
340 }
341
342 static void
343 ip_unmap_sub_dir (inotify_sub *sub,
344 ip_watched_dir_t *dir)
345 {
346 g_assert (sub && dir);
347 g_hash_table_remove (sub_dir_hash, sub);
348 dir->subs = g_list_remove (dir->subs, sub);
349
350 if (sub->hardlinks)
351 {
352 ip_watched_file_t *file;
353
354 file = g_hash_table_lookup (dir->files_hash, sub->filename);
355 file->subs = g_list_remove (file->subs, sub);
356
357 if (file->subs == NULL)
358 {
359 g_hash_table_remove (dir->files_hash, sub->filename);
360 ip_watched_file_stop (file);
361 ip_watched_file_free (file);
362 }
363 }
364 }
365
366 static void
367 ip_unmap_all_subs (ip_watched_dir_t *dir)
368 {
369 while (dir->subs != NULL)
370 ip_unmap_sub_dir (dir->subs->data, dir);
371 }
372
373 gboolean
374 _ip_stop_watching (inotify_sub *sub)
375 {
376 ip_watched_dir_t *dir = NULL;
377
378 dir = g_hash_table_lookup (sub_dir_hash, sub);
379 if (!dir)
380 return TRUE;
381
382 ip_unmap_sub_dir (sub, dir);
383
384 /* No one is subscribing to this directory any more */
385 if (dir->subs == NULL)
386 {
387 _ik_ignore (dir->path, dir->wd);
388 ip_unmap_wd_dir (dir->wd, dir);
389 ip_unmap_path_dir (dir->path, dir);
390 ip_watched_dir_free (dir);
391 }
392
393 return TRUE;
394 }
395
396
397 static ip_watched_dir_t *
398 ip_watched_dir_new (const char *path,
399 gint32 wd)
400 {
401 ip_watched_dir_t *dir = g_new0 (ip_watched_dir_t, 1);
402
403 dir->path = g_strdup (path);
404 dir->files_hash = g_hash_table_new (g_str_hash, g_str_equal);
405 dir->wd = wd;
406
407 return dir;
408 }
409
410 static void
411 ip_watched_dir_free (ip_watched_dir_t *dir)
412 {
413 g_assert_cmpint (g_hash_table_size (dir->files_hash), ==, 0);
414 g_assert (dir->subs == NULL);
415 g_free (dir->path);
416 g_hash_table_unref (dir->files_hash);
417 g_free (dir);
418 }
419
420 static void
421 ip_wd_delete (gpointer data,
422 gpointer user_data)
423 {
424 ip_watched_dir_t *dir = data;
425 GList *l = NULL;
426
427 for (l = dir->subs; l; l = l->next)
428 {
429 inotify_sub *sub = l->data;
430 /* Add subscription to missing list */
431 _im_add (sub);
432 }
433 ip_unmap_all_subs (dir);
434 /* Unassociate the path and the directory */
435 ip_unmap_path_dir (dir->path, dir);
436 ip_watched_dir_free (dir);
437 }
438
439 static gboolean
440 ip_event_dispatch (GList *dir_list,
441 GList *file_list,
442 ik_event_t *event)
443 {
444 gboolean interesting = FALSE;
445
446 GList *l;
447
448 if (!event)
449 return FALSE;
450
451 for (l = dir_list; l; l = l->next)
452 {
453 GList *subl;
454 ip_watched_dir_t *dir = l->data;
455
456 for (subl = dir->subs; subl; subl = subl->next)
457 {
458 inotify_sub *sub = subl->data;
459
460 /* If the subscription and the event
461 * contain a filename and they don't
462 * match, we don't deliver this event.
463 */
464 if (sub->filename &&
465 event->name &&
466 strcmp (sub->filename, event->name) &&
467 (!event->pair || !event->pair->name || strcmp (sub->filename, event->pair->name)))
468 continue;
469
470 /* If the subscription has a filename
471 * but this event doesn't, we don't
472 * deliver this event.
473 */
474 if (sub->filename && !event->name)
475 continue;
476
477 /* If we're also watching the file directly
478 * don't report events that will also be
479 * reported on the file itself.
480 */
481 if (sub->hardlinks)
482 {
483 event->mask &= ~IP_INOTIFY_FILE_MASK;
484 if (!event->mask)
485 continue;
486 }
487
488 /* FIXME: We might need to synthesize
489 * DELETE/UNMOUNT events when
490 * the filename doesn't match
491 */
492
493 interesting |= event_callback (event, sub, FALSE);
494
495 if (sub->hardlinks)
496 {
497 ip_watched_file_t *file;
498
499 file = g_hash_table_lookup (dir->files_hash, sub->filename);
500
501 if (file != NULL)
502 {
503 if (event->mask & (IN_MOVED_FROM | IN_DELETE))
504 ip_watched_file_stop (file);
505
506 if (event->mask & (IN_MOVED_TO | IN_CREATE))
507 ip_watched_file_start (file);
508 }
509 }
510 }
511 }
512
513 for (l = file_list; l; l = l->next)
514 {
515 ip_watched_file_t *file = l->data;
516 GList *subl;
517
518 for (subl = file->subs; subl; subl = subl->next)
519 {
520 inotify_sub *sub = subl->data;
521
522 interesting |= event_callback (event, sub, TRUE);
523 }
524 }
525
526 return interesting;
527 }
528
529 static gboolean
530 ip_event_callback (ik_event_t *event)
531 {
532 gboolean interesting = FALSE;
533 GList* dir_list = NULL;
534 GList *file_list = NULL;
535
536 /* We can ignore the IGNORED events. Likewise, if the event queue overflowed,
537 * there is not much we can do to recover. */
538 if (event->mask & (IN_IGNORED | IN_Q_OVERFLOW))
539 {
540 _ik_event_free (event);
541 return TRUE;
542 }
543
544 dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER (event->wd));
545 file_list = g_hash_table_lookup (wd_file_hash, GINT_TO_POINTER (event->wd));
546
547 if (event->mask & IP_INOTIFY_DIR_MASK)
548 interesting |= ip_event_dispatch (dir_list, file_list, event);
549
550 /* Only deliver paired events if the wds are separate */
551 if (event->pair && event->pair->wd != event->wd)
552 {
553 dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER (event->pair->wd));
554 file_list = g_hash_table_lookup (wd_file_hash, GINT_TO_POINTER (event->pair->wd));
555
556 if (event->pair->mask & IP_INOTIFY_DIR_MASK)
557 interesting |= ip_event_dispatch (dir_list, file_list, event->pair);
558 }
559
560 /* We have to manage the missing list
561 * when we get an event that means the
562 * file has been deleted/moved/unmounted.
563 */
564 if (event->mask & IN_DELETE_SELF ||
565 event->mask & IN_MOVE_SELF ||
566 event->mask & IN_UNMOUNT)
567 {
568 /* Add all subscriptions to missing list */
569 g_list_foreach (dir_list, ip_wd_delete, NULL);
570 /* Unmap all directories attached to this wd */
571 ip_unmap_wd (event->wd);
572 }
573
574 _ik_event_free (event);
575
576 return interesting;
577 }
578
579 const char *
580 _ip_get_path_for_wd (gint32 wd)
581 {
582 GList *dir_list;
583 ip_watched_dir_t *dir;
584
585 g_assert (wd >= 0);
586 dir_list = g_hash_table_lookup (wd_dir_hash, GINT_TO_POINTER (wd));
587 if (dir_list)
588 {
589 dir = dir_list->data;
590 if (dir)
591 return dir->path;
592 }
593
594 return NULL;
595 }