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; }
/* * 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); */ }
/* * port_remove * * < private > * Unsafe, need lock fen_lock. */ void port_remove (node_t *f) { /* g_assert(f->source); */ if (NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED)) { /* Mark unregisted. */ if (port_dissociate(PGPFD(f->source)->fd, PORT_SOURCE_FILE, (uintptr_t)FILE_OBJECT(f)) == 0) { /* * Note, we can run foode_delete if dissociating is failed, * because there may be some pending events (mostly like * FILE_DELETE) in the port_get. If we delete the foode * the fnode may be deleted, then port_get will run on an invalid * address. */ NODE_CLE_STATE(f, NODE_STATE_ASSOCIATED); FK_W ("PORT_DISSOCIATE 0x%p OK\n", f); } else if (errno == ENOENT) { /* The file has been removed from port, after port_get or before * port_get but DELETED event has been generated. * Ignored. */ } else { FK_W ("PORT_DISSOCIATE 0x%p %s\n", f, g_strerror (errno)); g_return_if_reached(); } } }
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); } }
/** * fen_add * * Won't hold a ref, we have a timout callback to clean unused node_t. * If there is no value for a key, add it and return it; else return the old * one. */ void fen_add (const gchar *filename, gpointer sub, gboolean is_mondir) { node_t* f; g_assert (filename); g_assert (sub); G_LOCK (fen_lock); f = node_find(NULL, filename, TRUE); FH_W ("%s 0x%p sub[0x%p] %s\n", __func__, f, sub, filename); g_assert (f); /* Update timestamp, the events in global queue will compare itself to this * timestamp to decide if be emitted. TODO, timestamp should be per sub. */ if (!NODE_IS_ACTIVE(f)) { g_get_current_time(&f->atv); } if (is_mondir) { f->dir_subs = g_list_prepend(f->dir_subs, sub); } else { f->subs = g_list_prepend(f->subs, sub); } if (NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED) || (node_lstat(f) == 0 && port_add(f) == 0)) { #ifndef GIO_COMPILATION gam_server_emit_one_event (NODE_NAME(f), gam_subscription_is_dir (sub), GAMIN_EVENT_EXISTS, sub, 1); #endif if (is_mondir) { scan_children_init (f, sub); } } else { #ifndef GIO_COMPILATION gam_server_emit_one_event (NODE_NAME(f), gam_subscription_is_dir (sub), GAMIN_EVENT_DELETED, sub, 1); #endif node_adjust_deleted (f); } #ifndef GIO_COMPILATION gam_server_emit_one_event (NODE_NAME(f), gam_subscription_is_dir (sub), GAMIN_EVENT_ENDEXISTS, sub, 1); #endif G_UNLOCK (fen_lock); }
/* * 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); } } } }
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; }
/* * 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); }