| /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ |
| /* vim:set expandtab ts=4 shiftwidth=4: */ |
| /* |
| * Copyright (c) 2008, 2010 Oracle and/or its affiliates, Inc. All rights |
| * reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General |
| * Public License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 59 Temple Place, Suite 330, |
| * Boston, MA 02111-1307, USA. |
| * |
| * Authors: Lin Ma <lin.ma@sun.com> |
| */ |
| |
| #include "config.h" |
| #include <sys/stat.h> |
| #include <errno.h> |
| #include <strings.h> |
| #include <glib.h> |
| #include "fen-kernel.h" |
| #include "fen-node.h" |
| #include "fen-dump.h" |
| |
| #ifdef GIO_COMPILATION |
| #include <gio/gfilemonitor.h> |
| #else |
| #include "gam_event.h" |
| #include "gam_server.h" |
| #include "gam_protocol.h" |
| #endif |
| |
| #ifdef GIO_COMPILATION |
| #define FN_W if (fn_debug_enabled) g_debug |
| static gboolean fn_debug_enabled = FALSE; |
| #else |
| #include "gam_error.h" |
| #define FN_W(...) GAM_DEBUG(DEBUG_INFO, __VA_ARGS__) |
| #endif |
| |
| G_LOCK_EXTERN (fen_lock); |
| |
| /* Must continue monitoring if: |
| * 1) I'm subscribed, |
| * 2) The subscribed children (one of the children has subs) are missing, |
| * 3) my parent is subscribed (monitoring directory). |
| */ |
| #define NODE_NEED_MONITOR(f) \ |
| (NODE_IS_ACTIVE(f) || node_children_num(f) > 0 || NODE_IS_REQUIRED_BY_PARENT(f)) |
| |
| static int concern_events[] = { |
| FILE_DELETE, |
| FILE_RENAME_FROM, |
| UNMOUNTED, |
| MOUNTEDOVER, |
| #ifdef GIO_COMPILATION |
| FILE_MODIFIED, |
| FILE_ATTRIB, |
| #else |
| FILE_MODIFIED | FILE_ATTRIB, |
| #endif |
| FILE_RENAME_TO, |
| }; |
| |
| node_t *ROOT = NULL; |
| |
| static void node_emit_one_event(node_t *f, GList *subs, node_t *other, int event); |
| static void node_emit_events(node_t *f, const node_event_t *ne); |
| static int node_event_translate(int event, gboolean pair); |
| static void node_add_event (node_t *f, node_event_t *ev); |
| static node_t* node_new (node_t* parent, const gchar* basename); |
| static void node_delete (node_t* parent); |
| static node_t* node_get_child (node_t *f, const gchar *basename); |
| static void children_add (node_t *p, node_t *f); |
| static void children_remove (node_t *p, node_t *f); |
| static gboolean children_remove_cb (gpointer key, gpointer value, gpointer user_data); |
| static guint node_children_num (node_t *f); |
| |
| gboolean |
| node_timeval_lt(const GTimeVal *val1, const GTimeVal *val2) |
| { |
| if (val1->tv_sec < val2->tv_sec) |
| return TRUE; |
| |
| if (val1->tv_sec > val2->tv_sec) |
| return FALSE; |
| |
| /* val1->tv_sec == val2->tv_sec */ |
| if (val1->tv_usec < val2->tv_usec) |
| return TRUE; |
| |
| return FALSE; |
| } |
| |
| void |
| node_traverse (node_t* node, void(*traverse_cb)(node_t*, gpointer), gpointer user_data) |
| { |
| GHashTableIter iter; |
| gpointer value; |
| |
| g_assert(traverse_cb); |
| if (node == NULL) { |
| node = ROOT; |
| } |
| |
| if (node) { |
| traverse_cb(node, user_data); |
| } |
| |
| g_hash_table_iter_init (&iter, node->children); |
| while (g_hash_table_iter_next (&iter, NULL, &value)) { |
| node_traverse((node_t *)value, traverse_cb, user_data); |
| } |
| } |
| |
| node_t* |
| node_find(node_t* node, const gchar* filename, gboolean create_on_missing) |
| { |
| gchar* str; |
| gchar* token; |
| gchar* lasts; |
| node_t* parent; |
| node_t* child; |
| |
| g_assert (filename && filename[0] == '/'); |
| |
| if (node == NULL) { |
| node = ROOT; |
| } |
| |
| FN_W ("%s %s\n", __func__, filename); |
| |
| parent = child = node; |
| str = g_strdup (filename); |
| |
| for (token = strtok_r (str, G_DIR_SEPARATOR_S, &lasts); |
| token != NULL && child != NULL; |
| token = strtok_r (NULL, G_DIR_SEPARATOR_S, &lasts)) { |
| FN_W ("%s %s + %s\n", __func__, NODE_NAME(parent), token); |
| child = node_get_child(parent, token); |
| if (child) { |
| parent = child; |
| } else if (create_on_missing) { |
| child = node_new (parent, token); |
| if (child) { |
| children_add (parent, child); |
| parent = child; |
| continue; |
| } else { |
| FN_W ("%s create %s failed", __func__, token); |
| } |
| } else { |
| break; |
| } |
| } |
| |
| g_free (str); |
| return child; |
| } |
| |
| gint |
| node_lstat(node_t *f) |
| { |
| struct stat buf; |
| |
| g_assert(!NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED)); |
| |
| if (lstat(NODE_NAME(f), &buf) == 0) { |
| FN_W ("%s %s\n", __func__, NODE_NAME(f)); |
| FILE_OBJECT(f)->fo_atime = buf.st_atim; |
| FILE_OBJECT(f)->fo_mtime = buf.st_mtim; |
| FILE_OBJECT(f)->fo_ctime = buf.st_ctim; |
| NODE_SET_FLAG(f, NODE_FLAG_STAT_UPDATED | |
| (S_ISDIR (buf.st_mode) ? NODE_FLAG_DIR : NODE_FLAG_NONE)); |
| return 0; |
| } else { |
| FN_W ("%s(lstat) %s %s\n", __func__, NODE_NAME(f), g_strerror (errno)); |
| } |
| return errno; |
| } |
| |
| void |
| node_create_children_snapshot(node_t *f, gint created_event, gboolean emit) |
| { |
| GDir *dir; |
| GError *err = NULL; |
| |
| FN_W ("%s %s [0x%p]\n", __func__, NODE_NAME(f), f); |
| |
| dir = g_dir_open (NODE_NAME(f), 0, &err); |
| if (dir) { |
| const char *basename; |
| node_t *child = NULL; |
| |
| while ((basename = g_dir_read_name (dir))) { |
| node_t* data; |
| GList *idx; |
| |
| child = node_get_child (f, basename); |
| if (child == NULL) { |
| gchar *filename; |
| |
| child = node_new (f, basename); |
| children_add (f, child); |
| } |
| |
| if (f->dir_subs) { |
| /* We need monitor the new children, or the existed child which |
| * is in the DELETED mode. |
| */ |
| if (!NODE_HAS_STATE(child, NODE_STATE_ASSOCIATED) && |
| node_lstat(child) == 0 && port_add(child) == 0) { |
| if (emit) { |
| /* Emit the whatever event for the new found file. */ |
| node_emit_one_event(child, child->dir_subs, NULL, created_event); |
| node_emit_one_event(child, child->subs, NULL, created_event); |
| node_emit_one_event(child, f->dir_subs, NULL, created_event); |
| node_emit_one_event(child, f->subs, NULL, created_event); |
| } |
| } |
| /* else ignore, because it may be deleted. */ |
| } |
| } |
| g_dir_close (dir); |
| |
| /* We have finished children snapshot. Any other new added subs should |
| * directory iterate the snapshot instead of scan directory again. |
| */ |
| NODE_SET_FLAG(f, NODE_FLAG_SNAPSHOT_UPDATED); |
| |
| } else { |
| FN_W (err->message); |
| g_error_free (err); |
| } |
| } |
| |
| /* |
| * If all active children nodes are ported, then cancel monitor the parent |
| * node. If we know how many children are created, then we can stop accordingly. |
| * |
| * Unsafe, need lock. |
| */ |
| static void |
| foreach_known_children_scan(gpointer key, gpointer value, gpointer user_data) |
| { |
| node_t* f = (node_t*)value; |
| |
| FN_W ("%s 0x%p %s\n", __func__, f, NODE_NAME(f)); |
| |
| if (!NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED)) { |
| if (node_lstat(f) == 0 && port_add(f) == 0) { |
| node_emit_one_event(f, f->dir_subs, NULL, FN_EVENT_CREATED); |
| node_emit_one_event(f, f->subs, NULL, FN_EVENT_CREATED); |
| if (NODE_PARENT(f)) { |
| node_emit_one_event(f, NODE_PARENT(f)->dir_subs, NULL, FN_EVENT_CREATED); |
| node_emit_one_event(f, NODE_PARENT(f)->subs, NULL, FN_EVENT_CREATED); |
| } |
| } |
| } |
| } |
| |
| gboolean |
| node_try_delete(node_t* node) |
| { |
| g_assert (node); |
| |
| FN_W ("%s 0x%p %s\n", __func__, node, NODE_NAME(node)); |
| |
| /* Try clean children */ |
| if (node_children_num (node) > 0) { |
| g_hash_table_foreach_remove(node->children, children_remove_cb, NULL); |
| } |
| if (!NODE_NEED_MONITOR(node)) { |
| /* Clean some flags. */ |
| /* NODE_CLE_FLAG(node, NODE_FLAG_HAS_SNAPSHOT | NODE_FLAG_STAT_DONE); */ |
| node->flag = 0; |
| |
| /* Now we handle the state. */ |
| if (NODE_HAS_STATE(node, NODE_STATE_ASSOCIATED)) { |
| port_remove(node); |
| } |
| /* Actually ignore the ROOT node. */ |
| if (node->state == 0 && NODE_PARENT(node)) { |
| children_remove(NODE_PARENT(node), node); |
| /* Do clean instead of returning TRUE. */ |
| node_delete (node); |
| } |
| /* else, we have events, clean event queue? */ |
| } |
| return FALSE; |
| } |
| |
| static node_t* |
| node_new (node_t* parent, const gchar* basename) |
| { |
| node_t *f = NULL; |
| |
| g_assert (basename && basename[0]); |
| |
| if ((f = g_new0(node_t, 1)) != NULL) { |
| if (parent) { |
| NODE_NAME(f) = g_build_filename(NODE_NAME(parent), basename, NULL); |
| } else { |
| NODE_NAME(f) = g_strdup(G_DIR_SEPARATOR_S); |
| } |
| f->basename = g_strdup (basename); |
| /* f->children = g_hash_table_new_full (g_str_hash, g_str_equal, */ |
| /* NULL, (GDestroyNotify)node_delete); */ |
| f->children = g_hash_table_new_full (g_str_hash, g_str_equal, |
| NULL, NULL); |
| #ifdef GIO_COMPILATION |
| f->gfile = g_file_new_for_path (NODE_NAME(f)); |
| #endif |
| FN_W ("%s 0x%p %s\n", __func__, f, NODE_NAME(f)); |
| } |
| return f; |
| } |
| |
| static void |
| node_delete (node_t *f) |
| { |
| FN_W ("%s 0x%p %s\n", __func__, f, NODE_NAME(f)); |
| g_assert(f->state == 0); |
| g_assert(!NODE_IS_ACTIVE(f)); |
| g_assert(g_hash_table_size (f->children) == 0); |
| g_assert(NODE_PARENT(f) == NULL); |
| g_hash_table_unref(f->children); |
| #ifdef GIO_COMPILATION |
| g_object_unref (f->gfile); |
| #endif |
| g_free(f->basename); |
| g_free(NODE_NAME(f)); |
| g_free (f); |
| } |
| |
| static void |
| children_add (node_t *p, node_t *f) |
| { |
| FN_W ("%s %s %s\n", __func__, NODE_NAME(p), f->basename); |
| g_hash_table_insert (p->children, f->basename, f); |
| NODE_PARENT(f) = p; |
| } |
| |
| static void |
| children_remove (node_t *p, node_t *f) |
| { |
| FN_W ("%s %s %s\n", __func__, NODE_NAME(p), f->basename); |
| g_hash_table_steal (p->children, f->basename); |
| NODE_PARENT(f) = NULL; |
| } |
| |
| static node_t * |
| node_get_child (node_t *f, const gchar *basename) |
| { |
| if (f->children) { |
| return (node_t *) g_hash_table_lookup (f->children, (gpointer)basename); |
| } |
| return NULL; |
| } |
| |
| static guint |
| node_children_num (node_t *f) |
| { |
| return g_hash_table_size (f->children); |
| } |
| |
| /* |
| * depth first delete recursively |
| */ |
| static gboolean |
| children_remove_cb (gpointer key, gpointer value, gpointer user_data) |
| { |
| return node_try_delete ((node_t*)value); |
| } |
| |
| gboolean |
| node_class_init() |
| { |
| ROOT = node_new (NULL, G_DIR_SEPARATOR_S); |
| if (ROOT == NULL) { |
| FN_W ("[node] Create ROOT node failed.\n"); |
| return FALSE; |
| } |
| |
| return port_class_init (node_add_event); |
| } |
| |
| /* |
| * Adjust self on failing to Port |
| */ |
| void |
| node_adjust_deleted(node_t* f) |
| { |
| node_t *ancestor; |
| |
| FN_W ("%s %s\n", __func__, NODE_NAME(f)); |
| |
| for (ancestor = NODE_PARENT(f); |
| ancestor != NULL; |
| ancestor = NODE_PARENT(ancestor)) { |
| /* Stop if we find a node which been already associated or is existed |
| * and can be associated. |
| */ |
| if (NODE_HAS_STATE(ancestor, NODE_STATE_ASSOCIATED) || |
| (node_lstat(ancestor) == 0 && port_add(ancestor) == 0)) { |
| break; |
| } |
| } |
| |
| /* We assume we shouldn't reach here, because Root is always existed and |
| * associated. But given bugster#6955199, if PORT FS has problems on root, |
| * we may reach here. So just return ROOT and the whole GIO fen backend will |
| * fail. |
| */ |
| /* g_assert(ancestor != NULL); */ |
| } |
| |
| |
| static void |
| node_emit_events(node_t *f, const node_event_t *ne) |
| { |
| gsize num = sizeof(concern_events)/sizeof(int); |
| gint i; |
| int translated_e; |
| node_t *p; |
| |
| if (node_timeval_lt(&f->atv, &ne->ctv)) { |
| int event = ne->e; |
| |
| /* Emit DELETED on the pair_data */ |
| if (ne->pair_data) { |
| node_t *from = ne->pair_data; |
| node_emit_one_event(from, from->dir_subs, NULL, node_event_translate(FILE_DELETE, FALSE)); |
| node_emit_one_event(from, from->subs, NULL, node_event_translate(FILE_DELETE, FALSE)); |
| } |
| |
| for (i = 0; i < num; i++) { |
| if (event & concern_events[i]) { |
| translated_e = node_event_translate(concern_events[i], FALSE); |
| /* Neither GIO or gamin cares about modified events on a |
| * directory. |
| */ |
| #ifdef GIO_COMPILATION |
| if ((concern_events[i] & FILE_MODIFIED) == 0) { |
| node_emit_one_event(f, f->dir_subs, NULL, translated_e); |
| } |
| #else |
| /* Gamin doesn't care about attrib changed events on a directory |
| * either. |
| */ |
| if ((concern_events[i] & (FILE_MODIFIED | FILE_ATTRIB)) == 0) { |
| node_emit_one_event(f, f->dir_subs, NULL, translated_e); |
| } |
| #endif |
| node_emit_one_event(f, f->subs, NULL, translated_e); |
| } |
| event &= ~concern_events[i]; |
| } |
| } |
| |
| p = NODE_PARENT(f); |
| if (p != NULL && node_timeval_lt(&p->atv, &ne->ctv)) { |
| int event = ne->e; |
| for (i = 0; i < num; i++) { |
| if (event & concern_events[i]) { |
| translated_e = node_event_translate(concern_events[i], ne->pair_data != NULL); |
| node_emit_one_event(f, p->dir_subs, ne->pair_data, translated_e); |
| node_emit_one_event(f, p->subs, ne->pair_data, translated_e); |
| } |
| event &= ~concern_events[i]; |
| } |
| } |
| } |
| |
| /* |
| * node_add_event: |
| * |
| */ |
| static void |
| node_add_event (node_t *f, node_event_t *ev) |
| { |
| FN_W ("%s %d\n", __func__, ev->e); |
| |
| /* Clean the events flag early, because all received events need be |
| * processed in this function. |
| */ |
| NODE_CLE_STATE(f, NODE_STATE_HAS_EVENTS); |
| |
| /* |
| * Node the node has been created, so we can delete create event in |
| * optimizing. To reduce the statings, we add it to Port on discoving |
| * it then emit CREATED event. So we don't need to do anything here. |
| */ |
| if (NODE_NEED_MONITOR(f)) { |
| if (HAS_NO_EXCEPTION_EVENTS(ev->e)) { |
| if (NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED) || port_add(f) == 0) { |
| if ((ev->e & FILE_MODIFIED) && NODE_HAS_FLAG(f, NODE_FLAG_DIR)) { |
| if (f->dir_subs) { |
| node_create_children_snapshot(f, FN_EVENT_CREATED, TRUE); |
| } else { |
| g_hash_table_foreach(f->children, foreach_known_children_scan, NULL); |
| } |
| } |
| } else { |
| /* Emit delete event */ |
| ev->e |= FILE_DELETE; |
| |
| node_adjust_deleted(f); |
| } |
| |
| } else { |
| node_adjust_deleted(f); |
| } |
| |
| /* Send events to clients. */ |
| node_emit_events (f, ev); |
| |
| } else { |
| /* Send events to clients. */ |
| node_emit_events (f, ev); |
| |
| node_try_delete(f); |
| } |
| |
| if (ev->pair_data) { |
| node_t *from = ev->pair_data; |
| g_assert(ev->e == FILE_RENAME_TO); |
| |
| if (NODE_NEED_MONITOR(from)) { |
| /* Clean the events flag, since it may block free this node. */ |
| NODE_CLE_STATE(from, NODE_STATE_HAS_EVENTS); |
| node_adjust_deleted(from); |
| } else { |
| node_try_delete(from); |
| } |
| } |
| |
| node_event_delete (ev); |
| } |
| |
| static void |
| node_emit_one_event(node_t *f, GList *subs, node_t *other, int event) |
| { |
| GList* idx; |
| |
| FN_W ("%s %s %d\n", __func__, NODE_NAME(f), event); |
| |
| #ifdef GIO_COMPILATION |
| for (idx = subs; idx; idx = idx->next) { |
| g_file_monitor_emit_event(G_FILE_MONITOR(idx->data), f->gfile, |
| (other == NULL ? NULL : other->gfile), event); |
| } |
| #else |
| for (idx = subs; idx; idx = idx->next) { |
| gam_server_emit_one_event(NODE_NAME(f), gam_subscription_is_dir(idx->data), event, idx->data, 1); |
| } |
| #endif |
| } |
| |
| static int |
| node_event_translate(int event, gboolean pair) |
| { |
| #ifdef GIO_COMPILATION |
| switch (event) { |
| case FILE_DELETE: |
| case FILE_RENAME_FROM: |
| return G_FILE_MONITOR_EVENT_DELETED; |
| case UNMOUNTED: |
| return G_FILE_MONITOR_EVENT_UNMOUNTED; |
| case FILE_ATTRIB: |
| return G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED; |
| case MOUNTEDOVER: |
| case FILE_MODIFIED: |
| return G_FILE_MONITOR_EVENT_CHANGED; |
| case FILE_RENAME_TO: |
| if (pair) { |
| return G_FILE_MONITOR_EVENT_MOVED; |
| } else { |
| return G_FILE_MONITOR_EVENT_CREATED; |
| } |
| default: |
| /* case FILE_ACCESS: */ |
| g_assert_not_reached (); |
| return -1; |
| } |
| #else |
| switch (event) { |
| case FILE_DELETE: |
| case FILE_RENAME_FROM: |
| return GAMIN_EVENT_DELETED; |
| case MOUNTEDOVER: |
| case UNMOUNTED: |
| return GAMIN_EVENT_CHANGED; |
| case FILE_RENAME_TO: |
| if (pair) { |
| return GAMIN_EVENT_MOVED; |
| } else { |
| return GAMIN_EVENT_CREATED; |
| } |
| default: |
| if (event & (FILE_ATTRIB | FILE_MODIFIED)) { |
| return GAMIN_EVENT_CHANGED; |
| } |
| /* case FILE_ACCESS: */ |
| g_assert_not_reached (); |
| return -1; |
| } |
| #endif |
| } |
| |
| node_event_t* |
| node_event_new (int event, gpointer user_data) |
| { |
| node_event_t *ev; |
| |
| if ((ev = g_new (node_event_t, 1)) != NULL) { |
| g_assert (ev); |
| ev->e = event; |
| ev->user_data = user_data; |
| ev->pair_data = NULL; /* For renamed file. */ |
| /* Created timestamp */ |
| g_get_current_time(&ev->ctv); |
| ev->rename_tv = ev->ctv; |
| } |
| return ev; |
| } |
| |
| void |
| node_event_delete (node_event_t* ev) |
| { |
| g_free (ev); |
| } |