mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-02 07:36:17 +01:00
f27ab8977b
svn path=/trunk/; revision=7203
535 lines
14 KiB
C
535 lines
14 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* vim:set expandtab ts=4 shiftwidth=4: */
|
|
/*
|
|
* Copyright (C) 2008 Sun Microsystems, Inc. All rights reserved.
|
|
* Use is subject to license terms.
|
|
*
|
|
* 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 <rctl.h>
|
|
#include <strings.h>
|
|
#include <errno.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <glib.h>
|
|
#include "fen-kernel.h"
|
|
#include "fen-dump.h"
|
|
|
|
#ifdef GIO_COMPILATION
|
|
#define FK_W if (fk_debug_enabled) g_warning
|
|
static gboolean fk_debug_enabled = FALSE;
|
|
#else
|
|
#include "gam_error.h"
|
|
#define FK_W(...) GAM_DEBUG(DEBUG_INFO, __VA_ARGS__)
|
|
#endif
|
|
|
|
G_GNUC_INTERNAL G_LOCK_DEFINE (fen_lock);
|
|
#define PE_ALLOC 64
|
|
#define F_PORT(pfo) (((_f *)(pfo))->port->port)
|
|
#define F_NAME(pfo) (((_f *)(pfo))->fobj->fo_name)
|
|
#define FEN_ALL_EVENTS (FILE_MODIFIED | FILE_ATTRIB | FILE_NOFOLLOW)
|
|
#define FEN_IGNORE_EVENTS (FILE_ACCESS)
|
|
#define PROCESS_PORT_EVENTS_TIME 400 /* in milliseconds */
|
|
|
|
static GHashTable *_obj_fen_hash = NULL; /* <user_data, port> */
|
|
static ulong max_port_events = 512;
|
|
static GList *pn_vq; /* the queue of ports which don't have the max objs */
|
|
static GList *pn_fq; /* the queue of ports which have the max objs */
|
|
static GQueue *g_eventq = NULL;
|
|
static void (*add_event_cb) (gpointer, fnode_event_t*);
|
|
|
|
typedef struct pnode
|
|
{
|
|
long ref; /* how many fds are associated to this port */
|
|
int port;
|
|
guint port_source_id;
|
|
} pnode_t;
|
|
|
|
typedef struct {
|
|
pnode_t* port;
|
|
file_obj_t* fobj;
|
|
|
|
gboolean is_active;
|
|
gpointer user_data;
|
|
} _f;
|
|
|
|
static gboolean port_fetch_event_cb (void *arg);
|
|
static pnode_t *pnode_new ();
|
|
static void pnode_delete (pnode_t *pn);
|
|
|
|
gboolean
|
|
is_ported (gpointer f)
|
|
{
|
|
_f* fo = g_hash_table_lookup (_obj_fen_hash, f);
|
|
|
|
if (fo) {
|
|
return fo->is_active;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static gchar*
|
|
printevent (const char *pname, int event, const char *tag)
|
|
{
|
|
static gchar *event_string = NULL;
|
|
GString *str;
|
|
|
|
if (event_string) {
|
|
g_free(event_string);
|
|
}
|
|
|
|
str = g_string_new ("");
|
|
g_string_printf (str, "[%s] [%-20s]", tag, pname);
|
|
if (event & FILE_ACCESS) {
|
|
str = g_string_append (str, " ACCESS");
|
|
}
|
|
if (event & FILE_MODIFIED) {
|
|
str = g_string_append (str, " MODIFIED");
|
|
}
|
|
if (event & FILE_ATTRIB) {
|
|
str = g_string_append (str, " ATTRIB");
|
|
}
|
|
if (event & FILE_DELETE) {
|
|
str = g_string_append (str, " DELETE");
|
|
}
|
|
if (event & FILE_RENAME_TO) {
|
|
str = g_string_append (str, " RENAME_TO");
|
|
}
|
|
if (event & FILE_RENAME_FROM) {
|
|
str = g_string_append (str, " RENAME_FROM");
|
|
}
|
|
if (event & UNMOUNTED) {
|
|
str = g_string_append (str, " UNMOUNTED");
|
|
}
|
|
if (event & MOUNTEDOVER) {
|
|
str = g_string_append (str, " MOUNTEDOVER");
|
|
}
|
|
event_string = str->str;
|
|
g_string_free (str, FALSE);
|
|
return event_string;
|
|
}
|
|
|
|
static void
|
|
port_add_kevent (int e, gpointer f)
|
|
{
|
|
fnode_event_t *ev, *tail;
|
|
GTimeVal t;
|
|
gboolean has_twin = FALSE;
|
|
|
|
/*
|
|
* Child FILE_DELETE | FILE_RENAME_FROM will trigger parent FILE_MODIFIED.
|
|
* FILE_MODIFIED will trigger FILE_ATTRIB.
|
|
*/
|
|
|
|
if ((e & FILE_ATTRIB) && e != FILE_ATTRIB) {
|
|
e ^= FILE_ATTRIB;
|
|
has_twin = TRUE;
|
|
}
|
|
if (e == FILE_RENAME_FROM) {
|
|
e = FILE_DELETE;
|
|
}
|
|
if (e == FILE_RENAME_TO) {
|
|
e = FILE_MODIFIED;
|
|
}
|
|
|
|
switch (e) {
|
|
case FILE_DELETE:
|
|
case FILE_RENAME_FROM:
|
|
case FILE_MODIFIED:
|
|
case FILE_ATTRIB:
|
|
case UNMOUNTED:
|
|
case MOUNTEDOVER:
|
|
break;
|
|
case FILE_RENAME_TO:
|
|
case FILE_ACCESS:
|
|
default:
|
|
g_assert_not_reached ();
|
|
return;
|
|
}
|
|
|
|
tail = (fnode_event_t*) g_queue_peek_tail (g_eventq);
|
|
if (tail) {
|
|
if (tail->user_data == f) {
|
|
if (tail->e == e) {
|
|
tail->has_twin = (has_twin | (tail->has_twin ^ has_twin));
|
|
/* skip the current */
|
|
return;
|
|
} else if (e == FILE_MODIFIED && !has_twin
|
|
&& tail->e == FILE_ATTRIB) {
|
|
tail->e = FILE_MODIFIED;
|
|
tail->has_twin = TRUE;
|
|
return;
|
|
} else if (e == FILE_ATTRIB
|
|
&& tail->e == FILE_MODIFIED && !tail->has_twin) {
|
|
tail->has_twin = TRUE;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((ev = fnode_event_new (e, has_twin, f)) != NULL) {
|
|
g_queue_push_tail (g_eventq, ev);
|
|
}
|
|
}
|
|
|
|
static void
|
|
port_process_kevents ()
|
|
{
|
|
fnode_event_t *ev;
|
|
|
|
while ((ev = (fnode_event_t*)g_queue_pop_head (g_eventq)) != NULL) {
|
|
FK_W ("[%s] 0x%p %s\n", __func__, ev, _event_string (ev->e));
|
|
add_event_cb (ev->user_data, ev);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
port_fetch_event_cb (void *arg)
|
|
{
|
|
pnode_t *pn = (pnode_t *)arg;
|
|
_f* fo;
|
|
uint_t nget = 0;
|
|
port_event_t pe[PE_ALLOC];
|
|
timespec_t timeout;
|
|
gpointer f;
|
|
gboolean ret = TRUE;
|
|
|
|
/* FK_W ("IN <======== %s\n", __func__); */
|
|
G_LOCK (fen_lock);
|
|
|
|
memset (&timeout, 0, sizeof (timespec_t));
|
|
do {
|
|
nget = 1;
|
|
if (port_getn (pn->port, pe, PE_ALLOC, &nget, &timeout) == 0) {
|
|
int i;
|
|
for (i = 0; i < nget; i++) {
|
|
fo = (_f*)pe[i].portev_user;
|
|
/* handle event */
|
|
switch (pe[i].portev_source) {
|
|
case PORT_SOURCE_FILE:
|
|
/* If got FILE_EXCEPTION or add to port failed,
|
|
delete the pnode */
|
|
fo->is_active = FALSE;
|
|
if (fo->user_data) {
|
|
FK_W("%s\n",
|
|
printevent(F_NAME(fo), pe[i].portev_events, "RAW"));
|
|
port_add_kevent (pe[i].portev_events, fo->user_data);
|
|
} else {
|
|
/* fnode is deleted */
|
|
goto L_delete;
|
|
}
|
|
if (pe[i].portev_events & FILE_EXCEPTION) {
|
|
g_hash_table_remove (_obj_fen_hash, fo->user_data);
|
|
L_delete:
|
|
FK_W ("[ FREE_FO ] [0x%p]\n", fo);
|
|
pnode_delete (fo->port);
|
|
g_free (fo);
|
|
}
|
|
break;
|
|
default:
|
|
/* case PORT_SOURCE_TIMER: */
|
|
FK_W ("[kernel] unknown portev_source %d\n", pe[i].portev_source);
|
|
}
|
|
}
|
|
} else {
|
|
FK_W ("[kernel] port_getn %s\n", g_strerror (errno));
|
|
nget = 0;
|
|
}
|
|
} while (nget == PE_ALLOC);
|
|
|
|
/* Processing g_eventq */
|
|
port_process_kevents ();
|
|
|
|
if (pn->ref == 0) {
|
|
pn->port_source_id = 0;
|
|
ret = FALSE;
|
|
}
|
|
G_UNLOCK (fen_lock);
|
|
/* FK_W ("OUT ========> %s\n", __func__); */
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* ref - 1 if remove a watching file succeeded.
|
|
*/
|
|
static void
|
|
pnode_delete (pnode_t *pn)
|
|
{
|
|
g_assert (pn->ref <= max_port_events);
|
|
|
|
if (pn->ref == max_port_events) {
|
|
FK_W ("PORT : move to visible queue - [pn] 0x%p [ref] %d\n", pn, pn->ref);
|
|
pn_fq = g_list_remove (pn_fq, pn);
|
|
pn_vq = g_list_prepend (pn_vq, pn);
|
|
}
|
|
if ((-- pn->ref) == 0) {
|
|
/* Should dispatch the source */
|
|
}
|
|
FK_W ("%s [pn] 0x%p [ref] %d\n", __func__, pn, pn->ref);
|
|
}
|
|
|
|
/*
|
|
* malloc pnode_t and port_create, start thread at pnode_ref.
|
|
* if pnode_new succeeded, the pnode_t will never
|
|
* be freed. So pnode_t can be freed only in pnode_new.
|
|
* Note pnode_monitor_remove_all can also free pnode_t, but currently no one
|
|
* invork it.
|
|
*/
|
|
static pnode_t *
|
|
pnode_new ()
|
|
{
|
|
pnode_t *pn = NULL;
|
|
|
|
if (pn_vq) {
|
|
pn = (pnode_t*)pn_vq->data;
|
|
g_assert (pn->ref < max_port_events);
|
|
} else {
|
|
pn = g_new0 (pnode_t, 1);
|
|
if (pn != NULL) {
|
|
if ((pn->port = port_create ()) >= 0) {
|
|
g_assert (g_list_find (pn_vq, pn) == NULL);
|
|
pn_vq = g_list_prepend (pn_vq, pn);
|
|
} else {
|
|
FK_W ("PORT_CREATE %s\n", g_strerror (errno));
|
|
g_free (pn);
|
|
pn = NULL;
|
|
}
|
|
}
|
|
}
|
|
if (pn) {
|
|
FK_W ("%s [pn] 0x%p [ref] %d\n", __func__, pn, pn->ref);
|
|
pn->ref++;
|
|
if (pn->ref == max_port_events) {
|
|
FK_W ("PORT : move to full queue - [pn] 0x%p [ref] %d\n", pn, pn->ref);
|
|
pn_vq = g_list_remove (pn_vq, pn);
|
|
pn_fq = g_list_prepend (pn_fq, pn);
|
|
g_assert (g_list_find (pn_vq, pn) == NULL);
|
|
}
|
|
/* attach the source */
|
|
if (pn->port_source_id == 0) {
|
|
pn->port_source_id = g_timeout_add (PROCESS_PORT_EVENTS_TIME,
|
|
port_fetch_event_cb,
|
|
(void *)pn);
|
|
g_assert (pn->port_source_id > 0);
|
|
}
|
|
}
|
|
|
|
return pn;
|
|
}
|
|
|
|
/**
|
|
* port_add_internal
|
|
*
|
|
* < private >
|
|
* Unsafe, need lock fen_lock.
|
|
*/
|
|
static gboolean
|
|
port_add_internal (file_obj_t* fobj, off_t* len,
|
|
gpointer f, gboolean need_stat)
|
|
{
|
|
int ret;
|
|
struct stat buf;
|
|
_f* fo = NULL;
|
|
|
|
g_assert (f && fobj);
|
|
FK_W ("%s [0x%p] %s\n", __func__, f, fobj->fo_name);
|
|
|
|
if ((fo = g_hash_table_lookup (_obj_fen_hash, f)) == NULL) {
|
|
fo = g_new0 (_f, 1);
|
|
fo->fobj = fobj;
|
|
fo->user_data = f;
|
|
g_assert (fo);
|
|
FK_W ("[ NEW_FO ] [0x%p] %s\n", fo, F_NAME(fo));
|
|
g_hash_table_insert (_obj_fen_hash, f, fo);
|
|
}
|
|
|
|
if (fo->is_active) {
|
|
return TRUE;
|
|
}
|
|
|
|
if (fo->port == NULL) {
|
|
fo->port = pnode_new ();
|
|
}
|
|
|
|
if (need_stat) {
|
|
if (FN_STAT (F_NAME(fo), &buf) != 0) {
|
|
FK_W ("LSTAT [%-20s] %s\n", F_NAME(fo), g_strerror (errno));
|
|
goto L_exit;
|
|
}
|
|
g_assert (len);
|
|
fo->fobj->fo_atime = buf.st_atim;
|
|
fo->fobj->fo_mtime = buf.st_mtim;
|
|
fo->fobj->fo_ctime = buf.st_ctim;
|
|
*len = buf.st_size;
|
|
}
|
|
|
|
if (port_associate (F_PORT(fo),
|
|
PORT_SOURCE_FILE,
|
|
(uintptr_t)fo->fobj,
|
|
FEN_ALL_EVENTS,
|
|
(void *)fo) == 0) {
|
|
fo->is_active = TRUE;
|
|
FK_W ("%s %s\n", "PORT_ASSOCIATE", F_NAME(fo));
|
|
return TRUE;
|
|
} else {
|
|
FK_W ("PORT_ASSOCIATE [%-20s] %s\n", F_NAME(fo), g_strerror (errno));
|
|
L_exit:
|
|
FK_W ("[ FREE_FO ] [0x%p]\n", fo);
|
|
g_hash_table_remove (_obj_fen_hash, f);
|
|
pnode_delete (fo->port);
|
|
g_free (fo);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
gboolean
|
|
port_add (file_obj_t* fobj, off_t* len, gpointer f)
|
|
{
|
|
return port_add_internal (fobj, len, f, TRUE);
|
|
}
|
|
|
|
gboolean
|
|
port_add_simple (file_obj_t* fobj, gpointer f)
|
|
{
|
|
return port_add_internal (fobj, NULL, f, FALSE);
|
|
}
|
|
|
|
/**
|
|
* port_remove
|
|
*
|
|
* < private >
|
|
* Unsafe, need lock fen_lock.
|
|
*/
|
|
void
|
|
port_remove (gpointer f)
|
|
{
|
|
_f* fo = NULL;
|
|
|
|
FK_W ("%s\n", __func__);
|
|
if ((fo = g_hash_table_lookup (_obj_fen_hash, f)) != NULL) {
|
|
/* Marked */
|
|
fo->user_data = NULL;
|
|
g_hash_table_remove (_obj_fen_hash, f);
|
|
|
|
if (port_dissociate (F_PORT(fo),
|
|
PORT_SOURCE_FILE,
|
|
(uintptr_t)fo->fobj) == 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.
|
|
*/
|
|
FK_W ("[ FREE_FO ] [0x%p]\n", fo);
|
|
pnode_delete (fo->port);
|
|
g_free (fo);
|
|
} else {
|
|
FK_W ("PORT_DISSOCIATE [%-20s] %s\n", F_NAME(fo), g_strerror (errno));
|
|
}
|
|
}
|
|
}
|
|
|
|
const gchar *
|
|
_event_string (int event)
|
|
{
|
|
switch (event) {
|
|
case FILE_DELETE:
|
|
return "FILE_DELETE";
|
|
case FILE_RENAME_FROM:
|
|
return "FILE_RENAME_FROM";
|
|
case FILE_MODIFIED:
|
|
return "FILE_MODIFIED";
|
|
case FILE_RENAME_TO:
|
|
return "FILE_RENAME_TO";
|
|
case MOUNTEDOVER:
|
|
return "MOUNTEDOVER";
|
|
case FILE_ATTRIB:
|
|
return "FILE_ATTRIB";
|
|
case UNMOUNTED:
|
|
return "UNMOUNTED";
|
|
case FILE_ACCESS:
|
|
return "FILE_ACCESS";
|
|
default:
|
|
return "EVENT_UNKNOWN";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get Solaris resouce values.
|
|
*
|
|
*/
|
|
|
|
extern gboolean
|
|
port_class_init (void (*user_add_event) (gpointer, fnode_event_t*))
|
|
{
|
|
rctlblk_t *rblk;
|
|
FK_W ("%s\n", __func__);
|
|
if ((rblk = malloc (rctlblk_size ())) == NULL) {
|
|
FK_W ("[kernel] rblk malloc %s\n", g_strerror (errno));
|
|
return FALSE;
|
|
}
|
|
if (getrctl ("process.max-port-events", NULL, rblk, RCTL_FIRST) == -1) {
|
|
FK_W ("[kernel] getrctl %s\n", g_strerror (errno));
|
|
free (rblk);
|
|
return FALSE;
|
|
} else {
|
|
max_port_events = rctlblk_get_value(rblk);
|
|
FK_W ("[kernel] max_port_events = %u\n", max_port_events);
|
|
free (rblk);
|
|
}
|
|
if ((_obj_fen_hash = g_hash_table_new(g_direct_hash,
|
|
g_direct_equal)) == NULL) {
|
|
FK_W ("[kernel] fobj hash initializing faild\n");
|
|
return FALSE;
|
|
}
|
|
if ((g_eventq = g_queue_new ()) == NULL) {
|
|
FK_W ("[kernel] FEN global event queue initializing faild\n");
|
|
}
|
|
if (user_add_event == NULL) {
|
|
return FALSE;
|
|
}
|
|
add_event_cb = user_add_event;
|
|
return TRUE;
|
|
}
|
|
|
|
fnode_event_t*
|
|
fnode_event_new (int event, gboolean has_twin, gpointer user_data)
|
|
{
|
|
fnode_event_t *ev;
|
|
|
|
if ((ev = g_new (fnode_event_t, 1)) != NULL) {
|
|
g_assert (ev);
|
|
ev->e = event;
|
|
ev->user_data = user_data;
|
|
ev->has_twin = has_twin;
|
|
/* Default isn't a pending event. */
|
|
ev->is_pending = FALSE;
|
|
}
|
|
return ev;
|
|
}
|
|
|
|
void
|
|
fnode_event_delete (fnode_event_t* ev)
|
|
{
|
|
g_free (ev);
|
|
}
|