1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /* vim:set expandtab ts=4 shiftwidth=4: */
4 * Copyright (c) 2008, 2010 Oracle and/or its affiliates, Inc. All rights
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser 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.
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 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General
18 * Public License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
20 * Boston, MA 02111-1307, USA.
22 * Authors: Lin Ma <lin.ma@sun.com>
30 #include "fen-kernel.h"
34 #ifdef GIO_COMPILATION
35 #include "gfilemonitor.h"
37 #include "gam_event.h"
38 #include "gam_server.h"
39 #include "gam_protocol.h"
42 #ifdef GIO_COMPILATION
43 #define FN_W if (fn_debug_enabled) g_debug
44 static gboolean fn_debug_enabled = FALSE;
46 #include "gam_error.h"
47 #define FN_W(...) GAM_DEBUG(DEBUG_INFO, __VA_ARGS__)
50 G_LOCK_EXTERN (fen_lock);
52 /* Must continue monitoring if:
54 * 2) The subscribed children (one of the children has subs) are missing,
55 * 3) my parent is subscribed (monitoring directory).
57 #define NODE_NEED_MONITOR(f) \
58 (NODE_IS_ACTIVE(f) || node_children_num(f) > 0 || NODE_IS_REQUIRED_BY_PARENT(f))
60 static int concern_events[] = {
65 #ifdef GIO_COMPILATION
69 FILE_MODIFIED | FILE_ATTRIB,
76 static void node_emit_one_event(node_t *f, GList *subs, node_t *other, int event);
77 static void node_emit_events(node_t *f, const node_event_t *ne);
78 static int node_event_translate(int event, gboolean pair);
79 static void node_add_event (node_t *f, node_event_t *ev);
80 static node_t* node_new (node_t* parent, const gchar* basename);
81 static void node_delete (node_t* parent);
82 static node_t* node_get_child (node_t *f, const gchar *basename);
83 static void children_add (node_t *p, node_t *f);
84 static void children_remove (node_t *p, node_t *f);
85 static gboolean children_remove_cb (gpointer key, gpointer value, gpointer user_data);
86 static guint node_children_num (node_t *f);
89 node_timeval_lt(const GTimeVal *val1, const GTimeVal *val2)
91 if (val1->tv_sec < val2->tv_sec)
94 if (val1->tv_sec > val2->tv_sec)
97 /* val1->tv_sec == val2->tv_sec */
98 if (val1->tv_usec < val2->tv_usec)
105 node_traverse (node_t* node, void(*traverse_cb)(node_t*, gpointer), gpointer user_data)
110 g_assert(traverse_cb);
116 traverse_cb(node, user_data);
119 g_hash_table_iter_init (&iter, node->children);
120 while (g_hash_table_iter_next (&iter, NULL, &value)) {
121 node_traverse((node_t *)value, traverse_cb, user_data);
126 node_find(node_t* node, const gchar* filename, gboolean create_on_missing)
134 g_assert (filename && filename[0] == '/');
140 FN_W ("%s %s\n", __func__, filename);
142 parent = child = node;
143 str = g_strdup (filename);
145 for (token = strtok_r (str, G_DIR_SEPARATOR_S, &lasts);
146 token != NULL && child != NULL;
147 token = strtok_r (NULL, G_DIR_SEPARATOR_S, &lasts)) {
148 FN_W ("%s %s + %s\n", __func__, NODE_NAME(parent), token);
149 child = node_get_child(parent, token);
152 } else if (create_on_missing) {
153 child = node_new (parent, token);
155 children_add (parent, child);
159 FN_W ("%s create %s failed", __func__, token);
171 node_lstat(node_t *f)
175 g_assert(!NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED));
177 if (lstat(NODE_NAME(f), &buf) == 0) {
178 FN_W ("%s %s\n", __func__, NODE_NAME(f));
179 FILE_OBJECT(f)->fo_atime = buf.st_atim;
180 FILE_OBJECT(f)->fo_mtime = buf.st_mtim;
181 FILE_OBJECT(f)->fo_ctime = buf.st_ctim;
182 NODE_SET_FLAG(f, NODE_FLAG_STAT_UPDATED |
183 (S_ISDIR (buf.st_mode) ? NODE_FLAG_DIR : NODE_FLAG_NONE));
186 FN_W ("%s(lstat) %s %s\n", __func__, NODE_NAME(f), g_strerror (errno));
192 node_create_children_snapshot(node_t *f, gint created_event, gboolean emit)
197 FN_W ("%s %s [0x%p]\n", __func__, NODE_NAME(f), f);
199 dir = g_dir_open (NODE_NAME(f), 0, &err);
201 const char *basename;
202 node_t *child = NULL;
204 while ((basename = g_dir_read_name (dir))) {
208 child = node_get_child (f, basename);
212 child = node_new (f, basename);
213 children_add (f, child);
217 /* We need monitor the new children, or the existed child which
218 * is in the DELETED mode.
220 if (!NODE_HAS_STATE(child, NODE_STATE_ASSOCIATED) &&
221 node_lstat(child) == 0 && port_add(child) == 0) {
223 /* Emit the whatever event for the new found file. */
224 node_emit_one_event(child, child->dir_subs, NULL, created_event);
225 node_emit_one_event(child, child->subs, NULL, created_event);
226 node_emit_one_event(child, f->dir_subs, NULL, created_event);
227 node_emit_one_event(child, f->subs, NULL, created_event);
230 /* else ignore, because it may be deleted. */
235 /* We have finished children snapshot. Any other new added subs should
236 * directory iterate the snapshot instead of scan directory again.
238 NODE_SET_FLAG(f, NODE_FLAG_SNAPSHOT_UPDATED);
247 * If all active children nodes are ported, then cancel monitor the parent
248 * node. If we know how many children are created, then we can stop accordingly.
253 foreach_known_children_scan(gpointer key, gpointer value, gpointer user_data)
255 node_t* f = (node_t*)value;
257 FN_W ("%s 0x%p %s\n", __func__, f, NODE_NAME(f));
259 if (!NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED)) {
260 if (node_lstat(f) == 0 && port_add(f) == 0) {
261 node_emit_one_event(f, f->dir_subs, NULL, FN_EVENT_CREATED);
262 node_emit_one_event(f, f->subs, NULL, FN_EVENT_CREATED);
263 if (NODE_PARENT(f)) {
264 node_emit_one_event(f, NODE_PARENT(f)->dir_subs, NULL, FN_EVENT_CREATED);
265 node_emit_one_event(f, NODE_PARENT(f)->subs, NULL, FN_EVENT_CREATED);
272 node_try_delete(node_t* node)
276 FN_W ("%s 0x%p %s\n", __func__, node, NODE_NAME(node));
278 /* Try clean children */
279 if (node_children_num (node) > 0) {
280 g_hash_table_foreach_remove(node->children, children_remove_cb, NULL);
282 if (!NODE_NEED_MONITOR(node)) {
283 /* Clean some flags. */
284 /* NODE_CLE_FLAG(node, NODE_FLAG_HAS_SNAPSHOT | NODE_FLAG_STAT_DONE); */
287 /* Now we handle the state. */
288 if (NODE_HAS_STATE(node, NODE_STATE_ASSOCIATED)) {
291 /* Actually ignore the ROOT node. */
292 if (node->state == 0 && NODE_PARENT(node)) {
293 children_remove(NODE_PARENT(node), node);
294 /* Do clean instead of returning TRUE. */
297 /* else, we have events, clean event queue? */
303 node_new (node_t* parent, const gchar* basename)
307 g_assert (basename && basename[0]);
309 if ((f = g_new0(node_t, 1)) != NULL) {
311 NODE_NAME(f) = g_build_filename(NODE_NAME(parent), basename, NULL);
313 NODE_NAME(f) = g_strdup(G_DIR_SEPARATOR_S);
315 f->basename = g_strdup (basename);
316 /* f->children = g_hash_table_new_full (g_str_hash, g_str_equal, */
317 /* NULL, (GDestroyNotify)node_delete); */
318 f->children = g_hash_table_new_full (g_str_hash, g_str_equal,
320 #ifdef GIO_COMPILATION
321 f->gfile = g_file_new_for_path (NODE_NAME(f));
323 FN_W ("%s 0x%p %s\n", __func__, f, NODE_NAME(f));
329 node_delete (node_t *f)
331 FN_W ("%s 0x%p %s\n", __func__, f, NODE_NAME(f));
332 g_assert(f->state == 0);
333 g_assert(!NODE_IS_ACTIVE(f));
334 g_assert(g_hash_table_size (f->children) == 0);
335 g_assert(NODE_PARENT(f) == NULL);
336 g_hash_table_unref(f->children);
337 #ifdef GIO_COMPILATION
338 g_object_unref (f->gfile);
341 g_free(NODE_NAME(f));
346 children_add (node_t *p, node_t *f)
348 FN_W ("%s %s %s\n", __func__, NODE_NAME(p), f->basename);
349 g_hash_table_insert (p->children, f->basename, f);
354 children_remove (node_t *p, node_t *f)
356 FN_W ("%s %s %s\n", __func__, NODE_NAME(p), f->basename);
357 g_hash_table_steal (p->children, f->basename);
358 NODE_PARENT(f) = NULL;
362 node_get_child (node_t *f, const gchar *basename)
365 return (node_t *) g_hash_table_lookup (f->children, (gpointer)basename);
371 node_children_num (node_t *f)
373 return g_hash_table_size (f->children);
377 * depth first delete recursively
380 children_remove_cb (gpointer key, gpointer value, gpointer user_data)
382 return node_try_delete ((node_t*)value);
388 ROOT = node_new (NULL, G_DIR_SEPARATOR_S);
390 FN_W ("[node] Create ROOT node failed.\n");
394 return port_class_init (node_add_event);
398 * Adjust self on failing to Port
401 node_adjust_deleted(node_t* f)
405 FN_W ("%s %s\n", __func__, NODE_NAME(f));
407 for (ancestor = NODE_PARENT(f);
409 ancestor = NODE_PARENT(ancestor)) {
410 /* Stop if we find a node which been already associated or is existed
411 * and can be associated.
413 if (NODE_HAS_STATE(ancestor, NODE_STATE_ASSOCIATED) ||
414 (node_lstat(ancestor) == 0 && port_add(ancestor) == 0)) {
419 /* We assume we shouldn't reach here, because Root is always existed and
420 * associated. But given bugster#6955199, if PORT FS has problems on root,
421 * we may reach here. So just return ROOT and the whole GIO fen backend will
424 /* g_assert(ancestor != NULL); */
429 node_emit_events(node_t *f, const node_event_t *ne)
431 gsize num = sizeof(concern_events)/sizeof(int);
436 if (node_timeval_lt(&f->atv, &ne->ctv)) {
439 /* Emit DELETED on the pair_data */
441 node_t *from = ne->pair_data;
442 node_emit_one_event(from, from->dir_subs, NULL, node_event_translate(FILE_DELETE, FALSE));
443 node_emit_one_event(from, from->subs, NULL, node_event_translate(FILE_DELETE, FALSE));
446 for (i = 0; i < num; i++) {
447 if (event & concern_events[i]) {
448 translated_e = node_event_translate(concern_events[i], FALSE);
449 /* Neither GIO or gamin cares about modified events on a
452 #ifdef GIO_COMPILATION
453 if ((concern_events[i] & FILE_MODIFIED) == 0) {
454 node_emit_one_event(f, f->dir_subs, NULL, translated_e);
457 /* Gamin doesn't care about attrib changed events on a directory
460 if ((concern_events[i] & (FILE_MODIFIED | FILE_ATTRIB)) == 0) {
461 node_emit_one_event(f, f->dir_subs, NULL, translated_e);
464 node_emit_one_event(f, f->subs, NULL, translated_e);
466 event &= ~concern_events[i];
471 if (p != NULL && node_timeval_lt(&p->atv, &ne->ctv)) {
473 for (i = 0; i < num; i++) {
474 if (event & concern_events[i]) {
475 translated_e = node_event_translate(concern_events[i], ne->pair_data != NULL);
476 node_emit_one_event(f, p->dir_subs, ne->pair_data, translated_e);
477 node_emit_one_event(f, p->subs, ne->pair_data, translated_e);
479 event &= ~concern_events[i];
489 node_add_event (node_t *f, node_event_t *ev)
491 FN_W ("%s %d\n", __func__, ev->e);
493 /* Clean the events flag early, because all received events need be
494 * processed in this function.
496 NODE_CLE_STATE(f, NODE_STATE_HAS_EVENTS);
499 * Node the node has been created, so we can delete create event in
500 * optimizing. To reduce the statings, we add it to Port on discoving
501 * it then emit CREATED event. So we don't need to do anything here.
503 if (NODE_NEED_MONITOR(f)) {
504 if (HAS_NO_EXCEPTION_EVENTS(ev->e)) {
505 if (NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED) || port_add(f) == 0) {
506 if ((ev->e & FILE_MODIFIED) && NODE_HAS_FLAG(f, NODE_FLAG_DIR)) {
508 node_create_children_snapshot(f, FN_EVENT_CREATED, TRUE);
510 g_hash_table_foreach(f->children, foreach_known_children_scan, NULL);
514 /* Emit delete event */
515 ev->e |= FILE_DELETE;
517 node_adjust_deleted(f);
521 node_adjust_deleted(f);
524 /* Send events to clients. */
525 node_emit_events (f, ev);
528 /* Send events to clients. */
529 node_emit_events (f, ev);
535 node_t *from = ev->pair_data;
536 g_assert(ev->e == FILE_RENAME_TO);
538 if (NODE_NEED_MONITOR(from)) {
539 /* Clean the events flag, since it may block free this node. */
540 NODE_CLE_STATE(from, NODE_STATE_HAS_EVENTS);
541 node_adjust_deleted(from);
543 node_try_delete(from);
547 node_event_delete (ev);
551 node_emit_one_event(node_t *f, GList *subs, node_t *other, int event)
555 FN_W ("%s %s %d\n", __func__, NODE_NAME(f), event);
557 #ifdef GIO_COMPILATION
558 for (idx = subs; idx; idx = idx->next) {
559 g_file_monitor_emit_event(G_FILE_MONITOR(idx->data), f->gfile,
560 (other == NULL ? NULL : other->gfile), event);
563 for (idx = subs; idx; idx = idx->next) {
564 gam_server_emit_one_event(NODE_NAME(f), gam_subscription_is_dir(idx->data), event, idx->data, 1);
570 node_event_translate(int event, gboolean pair)
572 #ifdef GIO_COMPILATION
575 case FILE_RENAME_FROM:
576 return G_FILE_MONITOR_EVENT_DELETED;
578 return G_FILE_MONITOR_EVENT_UNMOUNTED;
580 return G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED;
583 return G_FILE_MONITOR_EVENT_CHANGED;
586 return G_FILE_MONITOR_EVENT_MOVED;
588 return G_FILE_MONITOR_EVENT_CREATED;
591 /* case FILE_ACCESS: */
592 g_assert_not_reached ();
598 case FILE_RENAME_FROM:
599 return GAMIN_EVENT_DELETED;
602 return GAMIN_EVENT_CHANGED;
605 return GAMIN_EVENT_MOVED;
607 return GAMIN_EVENT_CREATED;
610 if (event & (FILE_ATTRIB | FILE_MODIFIED)) {
611 return GAMIN_EVENT_CHANGED;
613 /* case FILE_ACCESS: */
614 g_assert_not_reached ();
621 node_event_new (int event, gpointer user_data)
625 if ((ev = g_new (node_event_t, 1)) != NULL) {
628 ev->user_data = user_data;
629 ev->pair_data = NULL; /* For renamed file. */
630 /* Created timestamp */
631 g_get_current_time(&ev->ctv);
632 ev->rename_tv = ev->ctv;
638 node_event_delete (node_event_t* ev)