gio/fen/fen-kernel.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* vim:set expandtab ts=4 shiftwidth=4: */
   3 /*
   4  * Copyright (C) 2008 Sun Microsystems, Inc. All rights reserved.
   5  * Use is subject to license terms.
   6  *
   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.
  11  *
  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.
  16  *
  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.
  21  *
  22  * Authors: Lin Ma <lin.ma@sun.com>
  23  */
  24
  25 #include "config.h"
  26 #include <rctl.h>
  27 #include <strings.h>
  28 #include <errno.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <glib.h>
  33 #include "fen-kernel.h"
  34 #include "fen-dump.h"
  35
  36 #define FK_W if (fk_debug_enabled) g_warning
  37 #ifdef GIO_COMPILATION
  38 static gboolean fk_debug_enabled = FALSE;
  39 #else
  40 static gboolean fk_debug_enabled = TRUE;
  41 #endif
  42
  43 G_GNUC_INTERNAL G_LOCK_DEFINE (fen_lock);
  44 #define PE_ALLOC        64
  45 #define F_PORT(pp)              (((_f *)(fo))->port->port)
  46 #define F_NAME(pp)              (((_f *)(fo))->fobj->fo_name)
  47 #define FEN_ALL_EVENTS  (FILE_MODIFIED | FILE_ATTRIB | FILE_NOFOLLOW)
  48 #define FEN_IGNORE_EVENTS       (FILE_ACCESS)
  49 #define PROCESS_PORT_EVENTS_TIME        400     /* in milliseconds */
  50
  51 static GHashTable *_obj_fen_hash = NULL;        /* <user_data, port> */
  52 static ulong max_port_events = 512;
  53 static GList *pn_vq;    /* the queue of ports which don't have the max objs */
  54 static GList *pn_fq;    /* the queue of ports which have the max objs */
  55 static GQueue *g_eventq = NULL;
  56 static void (*add_event_cb) (gpointer, fnode_event_t*);
  57
  58 typedef struct pnode
  59 {
  60         long ref;       /* how many fds are associated to this port */
  61         int port;
  62     guint port_source_id;
  63 } pnode_t;
  64
  65 typedef struct {
  66     pnode_t*    port;
  67     file_obj_t* fobj;
  68
  69     gboolean    is_active;
  70     gpointer    user_data;
  71 } _f;
  72
  73 static gboolean port_fetch_event_cb (void *arg);
  74 static pnode_t *pnode_new ();
  75 static void pnode_delete (pnode_t *pn);
  76
  77 gboolean
  78 is_ported (gpointer f)
  79 {
  80     _f* fo = g_hash_table_lookup (_obj_fen_hash, f);
  81
  82     if (fo) {
  83         return fo->is_active;
  84     }
  85     return FALSE;
  86 }
  87
  88 static void
  89 printevent (const char *pname, int event, const char *tag)
  90 {
  91     GString* str;
  92     str = g_string_new ("");
  93
  94     g_string_printf (str, "[%s] [%-20s]", tag, pname);
  95     if (event & FILE_ACCESS) {
  96         str = g_string_append (str, " ACCESS");
  97     }
  98     if (event & FILE_MODIFIED) {
  99         str = g_string_append (str, " MODIFIED");
 100     }
 101     if (event & FILE_ATTRIB) {
 102         str = g_string_append (str, " ATTRIB");
 103     }
 104     if (event & FILE_DELETE) {
 105         str = g_string_append (str, " DELETE");
 106     }
 107     if (event & FILE_RENAME_TO) {
 108         str = g_string_append (str, " RENAME_TO");
 109     }
 110     if (event & FILE_RENAME_FROM) {
 111         str = g_string_append (str, " RENAME_FROM");
 112     }
 113     if (event & UNMOUNTED) {
 114         str = g_string_append (str, " UNMOUNTED");
 115     }
 116     if (event & MOUNTEDOVER) {
 117         str = g_string_append (str, " MOUNTEDOVER");
 118     }
 119
 120     FK_W ("%s\n", str->str);
 121     g_string_free (str, TRUE);
 122 }
 123
 124 static void
 125 port_add_kevent (int e, gpointer f)
 126 {
 127     fnode_event_t *ev, *tail;
 128     GTimeVal t;
 129     gboolean has_twin = FALSE;
 130
 131     /* printevent (F_NAME(f), e, "org"); */
 132     /*
 133      * Child FILE_DELETE | FILE_RENAME_FROM will trigger parent FILE_MODIFIED.
 134      * FILE_MODIFIED will trigger FILE_ATTRIB.
 135      */
 136
 137     if ((e & FILE_ATTRIB) && e != FILE_ATTRIB) {
 138         e ^= FILE_ATTRIB;
 139         has_twin = TRUE;
 140     }
 141     if (e == FILE_RENAME_FROM) {
 142         e = FILE_DELETE;
 143     }
 144     if (e == FILE_RENAME_TO) {
 145         e = FILE_MODIFIED;
 146     }
 147
 148     switch (e) {
 149     case FILE_DELETE:
 150     case FILE_RENAME_FROM:
 151     case FILE_MODIFIED:
 152     case FILE_ATTRIB:
 153     case UNMOUNTED:
 154     case MOUNTEDOVER:
 155         break;
 156     case FILE_RENAME_TO:
 157     case FILE_ACCESS:
 158     default:
 159         g_assert_not_reached ();
 160         return;
 161     }
 162
 163     tail = (fnode_event_t*) g_queue_peek_tail (g_eventq);
 164     if (tail) {
 165         if (tail->user_data == f) {
 166             if (tail->e == e) {
 167                 tail->has_twin = (has_twin | (tail->has_twin ^ has_twin));
 168                 /* skip the current */
 169                 return;
 170             } else if (e == FILE_MODIFIED && !has_twin
 171               && tail->e == FILE_ATTRIB) {
 172                 tail->e = FILE_MODIFIED;
 173                 tail->has_twin = TRUE;
 174                 return;
 175             } else if (e == FILE_ATTRIB
 176               && tail->e == FILE_MODIFIED && !tail->has_twin) {
 177                 tail->has_twin = TRUE;
 178                 return;
 179             }
 180         }
 181     }
 182
 183     if ((ev = fnode_event_new (e, has_twin, f)) != NULL) {
 184         g_queue_push_tail (g_eventq, ev);
 185     }
 186 }
 187
 188 static void
 189 port_process_kevents ()
 190 {
 191     fnode_event_t *ev;
 192
 193     while ((ev = (fnode_event_t*)g_queue_pop_head (g_eventq)) != NULL) {
 194         FK_W ("[%s] 0x%p %s\n", __func__, ev, _event_string (ev->e));
 195         add_event_cb (ev->user_data, ev);
 196     }
 197 }
 198
 199 static gboolean
 200 port_fetch_event_cb (void *arg)
 201 {
 202         pnode_t *pn = (pnode_t *)arg;
 203     _f* fo;
 204         uint_t nget = 0;
 205         port_event_t pe[PE_ALLOC];
 206     timespec_t timeout;
 207     gpointer f;
 208     gboolean ret = TRUE;
 209
 210     /* FK_W ("IN <======== %s\n", __func__); */
 211     G_LOCK (fen_lock);
 212
 213     memset (&timeout, 0, sizeof (timespec_t));
 214     do {
 215         nget = 1;
 216         if (port_getn (pn->port, pe, PE_ALLOC, &nget, &timeout) == 0) {
 217             int i;
 218             for (i = 0; i < nget; i++) {
 219                 fo = (_f*)pe[i].portev_user;
 220                 /* handle event */
 221                 switch (pe[i].portev_source) {
 222                 case PORT_SOURCE_FILE:
 223                     /* If got FILE_EXCEPTION or add to port failed,
 224                        delete the pnode */
 225                     fo->is_active = FALSE;
 226                     if (fo->user_data) {
 227                         printevent (F_NAME(fo), pe[i].portev_events, "RAW");
 228                         port_add_kevent (pe[i].portev_events, fo->user_data);
 229                     } else {
 230                         /* fnode is deleted */
 231                         goto L_delete;
 232                     }
 233                     if (pe[i].portev_events & FILE_EXCEPTION) {
 234                         g_hash_table_remove (_obj_fen_hash, fo->user_data);
 235                     L_delete:
 236                         FK_W ("[ FREE_FO ] [0x%p]\n", fo);
 237                         pnode_delete (fo->port);
 238                         g_free (fo);
 239                     }
 240                     break;
 241                 default:
 242                     /* case PORT_SOURCE_TIMER: */
 243                     FK_W ("[kernel] unknown portev_source %d\n", pe[i].portev_source);
 244                 }
 245             }
 246         } else {
 247             FK_W ("[kernel] port_getn %s\n", g_strerror (errno));
 248             nget = 0;
 249         }
 250     } while (nget == PE_ALLOC);
 251
 252         /* Processing g_eventq */
 253     port_process_kevents ();
 254
 255     if (pn->ref == 0) {
 256         pn->port_source_id = 0;
 257         ret = FALSE;
 258     }
 259     G_UNLOCK (fen_lock);
 260     /* FK_W ("OUT ========> %s\n", __func__); */
 261         return ret;
 262 }
 263
 264 /*
 265  * ref - 1 if remove a watching file succeeded.
 266  */
 267 static void
 268 pnode_delete (pnode_t *pn)
 269 {
 270     g_assert (pn->ref <= max_port_events);
 271
 272         if (pn->ref == max_port_events) {
 273         FK_W ("PORT : move to visible queue - [pn] 0x%p [ref] %d\n", pn, pn->ref);
 274                 pn_fq = g_list_remove (pn_fq, pn);
 275                 pn_vq = g_list_prepend (pn_vq, pn);
 276         }
 277         if ((-- pn->ref) == 0) {
 278         /* Should dispatch the source */
 279         }
 280         FK_W ("%s [pn] 0x%p [ref] %d\n", __func__, pn, pn->ref);
 281 }
 282
 283 /*
 284  * malloc pnode_t and port_create, start thread at pnode_ref.
 285  * if pnode_new succeeded, the pnode_t will never
 286  * be freed. So pnode_t can be freed only in pnode_new.
 287  * Note pnode_monitor_remove_all can also free pnode_t, but currently no one
 288  * invork it.
 289  */
 290 static pnode_t *
 291 pnode_new ()
 292 {
 293         pnode_t *pn = NULL;
 294
 295         if (pn_vq) {
 296                 pn = (pnode_t*)pn_vq->data;
 297         g_assert (pn->ref < max_port_events);
 298         } else {
 299                 pn = g_new0 (pnode_t, 1);
 300                 if (pn != NULL) {
 301             if ((pn->port = port_create ()) >= 0) {
 302                 g_assert (g_list_find (pn_vq, pn) == NULL);
 303                 pn_vq = g_list_prepend (pn_vq, pn);
 304             } else {
 305                 FK_W ("PORT_CREATE %s\n", g_strerror (errno));
 306                 g_free (pn);
 307                 pn = NULL;
 308                         }
 309                 }
 310         }
 311         if (pn) {
 312                 FK_W ("%s [pn] 0x%p [ref] %d\n", __func__, pn, pn->ref);
 313         pn->ref++;
 314         if (pn->ref == max_port_events) {
 315             FK_W ("PORT : move to full queue - [pn] 0x%p [ref] %d\n", pn, pn->ref);
 316             pn_vq = g_list_remove (pn_vq, pn);
 317             pn_fq = g_list_prepend (pn_fq, pn);
 318             g_assert (g_list_find (pn_vq, pn) == NULL);
 319         }
 320         /* attach the source */
 321         if (pn->port_source_id == 0) {
 322             pn->port_source_id = g_timeout_add (PROCESS_PORT_EVENTS_TIME,
 323               port_fetch_event_cb,
 324               (void *)pn);
 325             g_assert (pn->port_source_id > 0);
 326         }
 327         }
 328
 329         return pn;
 330 }
 331
 332 /**
 333  * port_add_internal
 334  *
 335  * < private >
 336  * Unsafe, need lock fen_lock.
 337  */
 338 static gboolean
 339 port_add_internal (file_obj_t* fobj, off_t* len,
 340   gpointer f, gboolean need_stat)
 341 {
 342     int ret;
 343     struct stat buf;
 344     _f* fo = NULL;
 345
 346     g_assert (f && fobj);
 347     FK_W ("%s [0x%p] %s\n", __func__, f, fobj->fo_name);
 348
 349     if ((fo = g_hash_table_lookup (_obj_fen_hash, f)) == NULL) {
 350         fo = g_new0 (_f, 1);
 351         fo->fobj = fobj;
 352         fo->user_data = f;
 353         g_assert (fo);
 354         FK_W ("[ NEW_FO ] [0x%p] %s\n", fo, F_NAME(fo));
 355         g_hash_table_insert (_obj_fen_hash, f, fo);
 356     }
 357
 358     if (fo->is_active) {
 359         return TRUE;
 360     }
 361
 362     if (fo->port == NULL) {
 363         fo->port = pnode_new ();
 364     }
 365
 366     if (need_stat) {
 367         if (FN_STAT (F_NAME(fo), &buf) != 0) {
 368             FK_W ("LSTAT [%-20s] %s\n", F_NAME(fo), g_strerror (errno));
 369             goto L_exit;
 370         }
 371         g_assert (len);
 372         fo->fobj->fo_atime = buf.st_atim;
 373         fo->fobj->fo_mtime = buf.st_mtim;
 374         fo->fobj->fo_ctime = buf.st_ctim;
 375         *len = buf.st_size;
 376     }
 377
 378     if (port_associate (F_PORT(fo),
 379           PORT_SOURCE_FILE,
 380           (uintptr_t)fo->fobj,
 381           FEN_ALL_EVENTS,
 382           (void *)fo) == 0) {
 383         fo->is_active = TRUE;
 384         FK_W ("%s %s\n", "PORT_ASSOCIATE", F_NAME(fo));
 385         return TRUE;
 386     } else {
 387         FK_W ("PORT_ASSOCIATE [%-20s] %s\n", F_NAME(fo), g_strerror (errno));
 388     L_exit:
 389         FK_W ("[ FREE_FO ] [0x%p]\n", fo);
 390         g_hash_table_remove (_obj_fen_hash, f);
 391         pnode_delete (fo->port);
 392         g_free (fo);
 393     }
 394     return FALSE;
 395 }
 396
 397 gboolean
 398 port_add (file_obj_t* fobj, off_t* len, gpointer f)
 399 {
 400     return port_add_internal (fobj, len, f, TRUE);
 401 }
 402
 403 gboolean
 404 port_add_simple (file_obj_t* fobj, gpointer f)
 405 {
 406     return port_add_internal (fobj, NULL, f, FALSE);
 407 }
 408
 409 /**
 410  * port_remove
 411  *
 412  * < private >
 413  * Unsafe, need lock fen_lock.
 414  */
 415 void
 416 port_remove (gpointer f)
 417 {
 418     _f* fo = NULL;
 419
 420     FK_W ("%s\n", __func__);
 421     if ((fo = g_hash_table_lookup (_obj_fen_hash, f)) != NULL) {
 422         /* Marked */
 423         fo->user_data = NULL;
 424         g_hash_table_remove (_obj_fen_hash, f);
 425
 426         if (port_dissociate (F_PORT(fo),
 427               PORT_SOURCE_FILE,
 428               (uintptr_t)fo->fobj) == 0) {
 429             /*
 430              * Note, we can run foode_delete if dissociating is failed,
 431              * because there may be some pending events (mostly like
 432              * FILE_DELETE) in the port_get. If we delete the foode
 433              * the fnode may be deleted, then port_get will run on an invalid
 434              * address.
 435              */
 436             FK_W ("[ FREE_FO ] [0x%p]\n", fo);
 437             pnode_delete (fo->port);
 438             g_free (fo);
 439         } else {
 440             FK_W ("PORT_DISSOCIATE [%-20s] %s\n", F_NAME(fo), g_strerror (errno));
 441         }
 442     }
 443 }
 444
 445 const gchar *
 446 _event_string (int event)
 447 {
 448     switch (event) {
 449     case FILE_DELETE:
 450         return "FILE_DELETE";
 451     case FILE_RENAME_FROM:
 452         return "FILE_RENAME_FROM";
 453     case FILE_MODIFIED:
 454         return "FILE_MODIFIED";
 455     case FILE_RENAME_TO:
 456         return "FILE_RENAME_TO";
 457     case MOUNTEDOVER:
 458         return "MOUNTEDOVER";
 459     case FILE_ATTRIB:
 460         return "FILE_ATTRIB";
 461     case UNMOUNTED:
 462         return "UNMOUNTED";
 463     case FILE_ACCESS:
 464         return "FILE_ACCESS";
 465     default:
 466         return "EVENT_UNKNOWN";
 467     }
 468 }
 469
 470 /**
 471  * Get Solaris resouce values.
 472  *
 473  */
 474
 475 extern gboolean
 476 port_class_init (void (*user_add_event) (gpointer, fnode_event_t*))
 477 {
 478         rctlblk_t *rblk;
 479     FK_W ("%s\n", __func__);
 480         if ((rblk = malloc (rctlblk_size ())) == NULL) {
 481         FK_W ("[kernel] rblk malloc %s\n", g_strerror (errno));
 482                 return FALSE;
 483         }
 484         if (getrctl ("process.max-port-events", NULL, rblk, RCTL_FIRST) == -1) {
 485         FK_W ("[kernel] getrctl %s\n", g_strerror (errno));
 486         free (rblk);
 487         return FALSE;
 488         } else {
 489         max_port_events = rctlblk_get_value(rblk);
 490                 FK_W ("[kernel] max_port_events = %u\n", max_port_events);
 491         free (rblk);
 492         }
 493     if ((_obj_fen_hash = g_hash_table_new(g_direct_hash,
 494            g_direct_equal)) == NULL) {
 495         FK_W ("[kernel] fobj hash initializing faild\n");
 496         return FALSE;
 497     }
 498     if ((g_eventq = g_queue_new ()) == NULL) {
 499                 FK_W ("[kernel] FEN global event queue initializing faild\n");
 500     }
 501     if (user_add_event == NULL) {
 502         return FALSE;
 503     }
 504     add_event_cb = user_add_event;
 505         return TRUE;
 506 }
 507
 508 fnode_event_t*
 509 fnode_event_new (int event, gboolean has_twin, gpointer user_data)
 510 {
 511     fnode_event_t *ev;
 512
 513     if ((ev = g_new (fnode_event_t, 1)) != NULL) {
 514         g_assert (ev);
 515         ev->e = event;
 516         ev->user_data = user_data;
 517         ev->has_twin = has_twin;
 518         /* Default isn't a pending event. */
 519         ev->is_pending = FALSE;
 520     }
 521     return ev;
 522 }
 523
 524 void
 525 fnode_event_delete (fnode_event_t* ev)
 526 {
 527     g_free (ev);
 528 }