mon_kqueue.c

Go to the documentation of this file.

/*
    clsync - file tree sync utility based on inotify/kqueue
 
    Copyright (C) 2014  Dmitry Yu Okunev <dyokunev@ut.mephi.ru> 0x8E30679C
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "common.h"
 
#include <glib.h>
 
#include "error.h"
#include "sync.h"
#include "indexes.h"
#include "fileutils.h"
#include "calc.h"
#include "glibex.h"
#include "mon_kqueue.h"
 
enum kqueue_status {
    KQUEUE_STATUS_UNKNOWN,
    KQUEUE_STATUS_RUNNING,
    KQUEUE_STATUS_DEINIT,
    KQUEUE_STATUS_DEAD,
};
enum kqueue_status kqueue_status = KQUEUE_STATUS_UNKNOWN;
 
struct monobj {
    ino_t          inode;
    dev_t          device;
    int            fd;
    int            dir_fd;
    char          *name;
    size_t         name_len;
    uint32_t       name_hash;
    unsigned char  type;
    size_t         changelist_id;
    struct monobj *parent;
 
    // Case specific stuff
    union {
        // For directories only, for original (not dupes) obj_p only
        GTree *children_tree;
        // For duplicates only, see _kqueue_handle_oneevent_dircontent()
        struct monobj *origin;
    };
};
typedef struct monobj monobj_t;
 
struct kqueue_data {
    int kqueue_d;
 
    struct kevent *changelist;
    size_t         changelist_alloced;
    size_t         changelist_used;
    struct kevent  eventlist[KQUEUE_EVENTLISTSIZE];
    size_t         eventlist_count;
    monobj_t     **obj_p_by_clid;           // An associative array to get the monobj pointer by an changelist_id
    GTree   *file_btree;
    GTree     *fd_btree;
};
 
struct recognize_event_return {
    union {
        struct {
            eventobjtype_t objtype_old: 16;
            eventobjtype_t objtype_new: 16;
        } v;
        uint32_t i;
    } u;
};
 
ctx_t     *ctx_p;
indexes_t *indexes_p;
 
static inline uint32_t recognize_event ( uint32_t event, int is_dir )
{
    struct recognize_event_return r = {{{0}}};
    eventobjtype_t type;
    int is_created;
    int is_deleted;
    type       = ( is_dir ? EOT_DIR : EOT_FILE );
    is_created =  event & ( NOTE_LINK );
    is_deleted =  event & ( NOTE_DELETE );
    debug ( 4, "type == %x; is_created == %x; is_deleted == %x", type, is_created, is_deleted );
    r.u.v.objtype_old = type;
    r.u.v.objtype_new = type;
 
    if ( is_created )
        r.u.v.objtype_old = EOT_DOESNTEXIST;
 
    if ( is_deleted )
        r.u.v.objtype_new = EOT_DOESNTEXIST;
 
    return r.u.i;
}
 
extern int kqueue_sync ( ctx_t *ctx_p, indexes_t *indexes_p, struct kevent *ev_p, monobj_t *obj_p );
extern int kqueue_unmark ( ctx_t *ctx_p, monobj_t *obj_p );
 
void unmarkchild ( gpointer _obj_p )
{
    monobj_t *obj_p = _obj_p;
    static struct kevent ev = {0};
    debug ( 10, "Calling kqueue_sync() on \"%s\" (obj_p: %p; dir_fd: %i; fd: %i)", obj_p->name, obj_p, obj_p->dir_fd, obj_p->fd );
    ev.ident  = obj_p->fd;
    ev.fflags = NOTE_DELETE;
    critical_on ( kqueue_sync ( ctx_p, indexes_p, &ev, obj_p ) );
    debug ( 4, "Unmarking the child \"%s\" (dir_fd: %i; fd: %i)", obj_p->name, obj_p->dir_fd, obj_p->fd );
    kqueue_unmark ( ctx_p, obj_p );
    return;
}
gboolean unmarkchild_for_foreach ( gpointer _obj_p, gpointer _value, gpointer _ctx_p )
{
    unmarkchild ( _obj_p );
    return FALSE;
}
 
void monobj_free ( void *monobj_p )
{
    monobj_t *obj_p = monobj_p;
    debug ( 20, "obj_p == %p; obj_p->fd == %i; obj_p->name == \"%s\"", obj_p, obj_p->fd, obj_p->name );
 
    if ( kqueue_status != KQUEUE_STATUS_DEINIT ) {
        if ( obj_p->children_tree != NULL ) {
            debug ( 20, "Removing children" );
 
            if ( g_tree_nnodes ( obj_p->children_tree ) ) {
                g_tree_foreach ( obj_p->children_tree, unmarkchild_for_foreach, ctx_p );
                g_tree_destroy ( obj_p->children_tree );
            }
        }
 
        if ( obj_p->parent != NULL ) {
            monobj_t *parent = obj_p->parent;
            debug ( 20, "Removing the obj from parent->children_tree (obj_p == %p; parent == %p; parent->children_tree == %p)", obj_p, parent, parent->children_tree );
            g_tree_remove ( parent->children_tree, obj_p );
        }
    }
 
    debug ( 20, "free()-s" );
    free ( obj_p->name );
    free ( obj_p );
    return;
}
 
static gint monobj_filecmp ( gconstpointer _a, gconstpointer _b, gpointer _ctx_p )
{
#ifdef VERYPARANOID
    critical_on ( _a == NULL );
    critical_on ( _b == NULL );
#endif
    const monobj_t *a = _a, *b = _b;
    debug ( 95, "a == %p; b == %p", a, b );
    int diff_inode  = a->inode  - b->inode;
    debug ( 90, "diff_inode = %i", diff_inode );
 
    if ( diff_inode )
        return diff_inode;
 
    int diff_device = a->device - b->device;
    debug ( 50, "diff_device = %i", diff_device );
 
    if ( diff_device )
        return diff_device;
 
    int diff_dir_fd = a->dir_fd - b->dir_fd;
    debug ( 50, "diff_dir_fd = %i (%i - %i)", diff_dir_fd, a->dir_fd, b->dir_fd );
 
    if ( diff_dir_fd )
        return diff_dir_fd;
 
    int diff_name_hash = a->name_hash - b->name_hash;
    debug ( 50, "diff_name_hash = %i", diff_name_hash );
 
    if ( diff_name_hash )
        return diff_name_hash;
 
    debug ( 10, "strcmp(\"%s\", \"%s\") = %i", a->name, b->name, strcmp ( a->name, b->name ) );
    return strcmp ( a->name, b->name );
}
 
static int monobj_fdcmp ( gconstpointer a, gconstpointer b, gpointer _ctx_p )
{
    return ( ( monobj_t * ) a )->fd - ( ( monobj_t * ) b )->fd;
}
 
int kqueue_init ( ctx_t *_ctx_p )
{
    struct kqueue_data *mondata;
    debug ( 9, "_ctx_p == %p", _ctx_p );
    ctx_p     = _ctx_p;
    indexes_p =  ctx_p->indexes_p;
    ctx_p->fsmondata = xcalloc ( 1, sizeof ( struct kqueue_data ) );
 
    if ( ctx_p->fsmondata == NULL )
        return -1;
 
    struct kqueue_data *dat = ctx_p->fsmondata;
    dat->kqueue_d = kqueue();
    mondata = ctx_p->fsmondata;
    mondata->file_btree = g_tree_new_full ( monobj_filecmp, _ctx_p, monobj_free, NULL );
    mondata->fd_btree   = g_tree_new_full ( monobj_fdcmp,   _ctx_p, NULL,        NULL );
    kqueue_status = KQUEUE_STATUS_RUNNING;
    return 0;
}
 
int kqueue_mark ( ctx_t *ctx_p, monobj_t *obj_p )
{
    struct kqueue_data *dat = ctx_p->fsmondata;
#ifdef VERYPARANOID
 
    if ( obj_p == NULL ) {
        errno = EINVAL;
        return -1;
    }
 
#endif
    debug ( 9, "" );
 
    if ( obj_p->dir_fd == -1 )
        obj_p->fd = open ( ctx_p->watchdir, O_RDONLY | O_NOFOLLOW );
    else
        obj_p->fd = openat ( obj_p->dir_fd, obj_p->name, O_RDONLY | O_NOFOLLOW );
 
    debug ( 4, "obj_p-> (%p): dir_fd == %i; name == \"%s\"; fd == %i; type == %i (isdir == %i)", obj_p, obj_p->dir_fd, obj_p->name, obj_p->fd, obj_p->type, obj_p->type == DT_DIR );
 
    if ( obj_p->fd == -1 ) {
        debug ( 2, "File/dir \"%s\" disappeared. Skipping", obj_p->name );
        return 0;
    }
 
    if ( dat->changelist_used >= dat->changelist_alloced ) {
        dat->changelist_alloced += ALLOC_PORTION;
        dat->changelist          = xrealloc ( dat->changelist,    dat->changelist_alloced * sizeof ( *dat->changelist ) );
        dat->obj_p_by_clid       = xrealloc ( dat->obj_p_by_clid, dat->changelist_alloced * sizeof ( *dat->obj_p_by_clid ) );
    }
 
    switch ( obj_p->type ) {
        case DT_DIR:
            EV_SET ( &dat->changelist[dat->changelist_used], obj_p->fd,
                     EVFILT_VNODE,
                     EV_ADD | EV_CLEAR,
                     NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_DELETE,
                     0, 0 );
            break;
 
        default:
            EV_SET ( &dat->changelist[dat->changelist_used], obj_p->fd,
                     EVFILT_VNODE,
                     EV_ADD | EV_CLEAR,
                     NOTE_WRITE | NOTE_ATTRIB | NOTE_DELETE,
                     0, 0 );
            break;
    }
 
    obj_p->changelist_id = dat->changelist_used++;
    dat->obj_p_by_clid[obj_p->changelist_id] = obj_p;
    return 0;
}
 
 
void child_free ( monobj_t *node )
{
    critical_on ( kqueue_unmark ( ctx_p, node ) );
}
int kqueue_unmark ( ctx_t *ctx_p, monobj_t *obj_p )
{
    int changelist_id_last;
    debug ( 20, "obj_p == %p", obj_p );
    struct kqueue_data *dat = ctx_p->fsmondata;
#ifdef VERYPARANOID
 
    if ( obj_p == NULL ) {
        errno = EINVAL;
        return -1;
    }
 
#endif
    debug ( 30, "dat->changelist_used == %i", dat->changelist_used );
 
    if ( dat->changelist_used ) {
        dat->changelist_used--;
        changelist_id_last = dat->changelist_used;
        debug ( 30, "Checking: (obj_p->changelist_id [%i] < changelist_id_last [%i]) == %i", obj_p->changelist_id, changelist_id_last, ( obj_p->changelist_id < changelist_id_last ) );
#ifdef PARANOID
        critical_on ( obj_p->changelist_id > changelist_id_last );
#endif
 
        if ( obj_p->changelist_id < changelist_id_last ) {
            debug ( 20, "dat->changelist: moving %i -> %i", changelist_id_last, obj_p->changelist_id );
            dat->obj_p_by_clid[ obj_p->changelist_id ]                = dat->obj_p_by_clid[ changelist_id_last ];
            dat->obj_p_by_clid[ obj_p->changelist_id ]->changelist_id = obj_p->changelist_id;
            memcpy ( &dat->changelist[obj_p->changelist_id], &dat->changelist[changelist_id_last], sizeof ( *dat->changelist ) );
            debug ( 30,
                    "dat->obj_p_by_clid[ obj_p->changelist_id ] == %p; "
                    "dat->obj_p_by_clid[ obj_p->changelist_id ]->fd == %i; "
                    "dat->obj_p_by_clid[ obj_p->changelist_id ]->name == \"%s\"",
                    dat->obj_p_by_clid[ obj_p->changelist_id ],
                    dat->obj_p_by_clid[ obj_p->changelist_id ]->fd,
                    dat->obj_p_by_clid[ obj_p->changelist_id ]->name
                  );
        }
    }
 
    close ( obj_p->fd );
    debug ( 20, "Removing the obj itself" );
    g_tree_remove ( dat->fd_btree,   obj_p );
    g_tree_remove ( dat->file_btree, obj_p );
    return 0;
}
 
monobj_t *kqueue_start_watch ( ctx_t *ctx_p, ino_t inode, dev_t device, int dir_fd, const char *const fname, size_t name_len, unsigned char type )
{
    monobj_t *obj_p, *parent, parent_pattern;
    struct kqueue_data *dat = ctx_p->fsmondata;
    debug ( 3, "(ctx_p, %i, \"%s\", %u, %u)", dir_fd, fname, name_len, type );
#ifdef VERYPARANOID
    obj_p = xcalloc ( sizeof ( *obj_p ), 1 );
#else
    obj_p = xmalloc ( sizeof ( *obj_p ) );
#endif
    obj_p->inode     = inode;
    obj_p->device    = device;
    obj_p->dir_fd    = dir_fd;
    obj_p->name_len  = name_len;
    obj_p->name  = xmalloc ( obj_p->name_len + 1 );
    obj_p->type  = type;
    memcpy ( obj_p->name, fname, obj_p->name_len + 1 );
    obj_p->name_hash = adler32_calc ( ( const unsigned char * ) fname, name_len );
    parent = NULL;
    parent_pattern.fd = dir_fd;
    parent = g_tree_lookup ( dat->fd_btree, &parent_pattern );
 
    if ( parent != NULL ) {
        obj_p->parent = parent;
        debug ( 20, "Adding a child for dir_fd == %i", dir_fd );
        g_tree_replace ( parent->children_tree, obj_p, obj_p );
        debug ( 25, "parent->children_tree == %p", parent->children_tree );
    }
 
    debug ( 20, "parent == %p; obj_p == %p", parent, obj_p );
 
    switch ( type ) {
        case DT_DIR:
            obj_p->children_tree = g_tree_new_full ( monobj_filecmp, ctx_p, NULL, NULL );
            debug ( 25, "dir_p->children_tree == %p", obj_p->children_tree );
 
        case DT_UNKNOWN:
        case DT_REG:
            if ( kqueue_mark ( ctx_p, obj_p ) ) {
                error ( "Got error while kqueue_mark()" );
                free ( obj_p->name );
                free ( obj_p );
                return NULL;
            }
 
            break;
 
        default:
            debug ( 4, "I won't open() this object due to it's type == %u.", type );
            break;
    }
 
    debug ( 8, "storing: inode == %u; device == %u; dir_fd == %i; fd == %i; parent == %p", obj_p->inode, obj_p->device, obj_p->dir_fd, obj_p->fd, parent );
    g_tree_replace ( dat->file_btree, obj_p, obj_p );
    g_tree_replace (  dat->fd_btree, obj_p, obj_p );
    return obj_p;
}
 
monobj_t *kqueue_add_watch_direntry ( ctx_t *ctx_p, indexes_t *indexes_p, struct dirent *entry, monobj_t *dir_obj_p )
{
    struct kqueue_data *dat = ctx_p->fsmondata;
    monobj_t *obj_p;
    uint32_t name_hash;
#ifdef VERYPARANOID
    critical_on ( entry == NULL );
#endif
    size_t name_len = strlen ( entry->d_name );
    name_hash = adler32_calc ( ( unsigned char * ) entry->d_name, name_len );
    {
        monobj_t obj;
        obj.inode     = entry->d_ino;
        obj.device    = dir_obj_p->device;
        obj.dir_fd    = dir_obj_p->fd;
        obj.name_hash = name_hash;
 
        if ( ( obj_p = g_tree_lookup ( dat->file_btree, &obj ) ) != NULL )
            return obj_p;
    }
 
    if ( ( obj_p = kqueue_start_watch ( ctx_p, entry->d_ino, dir_obj_p->device, dir_obj_p->fd, entry->d_name, name_len, entry->d_type ) ) == NULL )
        error ( "Got error while kqueue_start_watch()" );
 
    obj_p->inode     = entry->d_ino;
    obj_p->device    = dir_obj_p->device;
    obj_p->dir_fd    = dir_obj_p->fd;
    obj_p->name_hash = name_hash;
    return obj_p;
}
 
monobj_t *kqueue_add_watch_path ( ctx_t *ctx_p, indexes_t *indexes_p, const char *const path )
{
    struct stat st;
    struct kqueue_data *dat = ctx_p->fsmondata;
    monobj_t *obj_p = NULL;
    uint32_t name_hash;
    const char *file_name;
    int dir_fd;
    size_t name_len;
#ifdef VERYPARANOID
 
    if ( path == NULL ) {
        errno = EINVAL;
        return NULL;
    }
 
#endif
    debug ( 6, "(ctx_p, indexes_p, \"%s\")", path );
    {
        char *dir_path, *ptr;
        ptr = strrchr ( path, '/' );
 
        if ( ptr == NULL ) {
            file_name = path;
            dir_fd = indexes_fpath2wd ( indexes_p, "" );
        } else {
            dir_path = strdup ( path );
            dir_path[ptr - path] = 0;
            dir_fd = indexes_fpath2wd ( indexes_p, dir_path );
 
            if ( dir_fd == -1 ) {
                if ( strcmp ( ctx_p->watchdir, path ) ) {
                    errno = ENOENT;
                    error ( "Cannot find file descriptor of directory \"%s\"", dir_path );
                    return NULL;
                }
            }
 
            free ( dir_path );
            file_name = &ptr[1];
        }
 
        name_len  = strlen ( file_name );
        name_hash = adler32_calc ( ( unsigned char * ) file_name, name_len );
    }
    lstat ( path, &st );
    {
        monobj_t obj;
        obj.inode     = st.st_ino;
        obj.device    = st.st_dev;
        obj.dir_fd    = dir_fd;
        obj.name_hash = name_hash;
        obj.name      = ( char * ) file_name;
 
        if ( ( obj_p = g_tree_lookup ( dat->file_btree, &obj ) ) != NULL )
            return obj_p;
    }
    debug ( 9, "not monitored file/dir \"%s\", yet.", file_name );
    {
        const char *name_start;
        name_start = strrchr ( path, '/' );
 
        if ( name_start == NULL )
            name_start = path;
        else
            name_start++;
 
        if ( ( obj_p = kqueue_start_watch ( ctx_p, st.st_ino, st.st_dev, dir_fd, file_name, name_len, ( st.st_mode & S_IFMT ) == S_IFDIR ? DT_DIR : DT_REG ) ) == NULL )
            error ( "Got error while kqueue_start_watch()" );
    }
    obj_p->inode     = st.st_ino;
    obj_p->device    = st.st_dev;
    obj_p->dir_fd    = dir_fd;
    obj_p->name_hash = name_hash;
    return obj_p;
}
 
int kqueue_add_watch_dir ( ctx_t *ctx_p, indexes_t *indexes_p, const char *const accpath )
{
    DIR      *dir;
    monobj_t *dir_obj_p = NULL;
    struct dirent *entry;
#ifdef VERYPARANOID
 
    if ( accpath == NULL ) {
        errno = EINVAL;
        return -1;
    }
 
#endif
    debug ( 5, "(ctx_p, indexes_p, \"%s\")", accpath );
 
    if ( ( dir_obj_p = kqueue_add_watch_path ( ctx_p, indexes_p, accpath ) ) == NULL ) {
        error ( "Got error while kqueue_add_watch_path(ctx_p, \"%s\")", accpath );
        return -1;
    }
 
    dir = fdopendir ( dir_obj_p->fd );
 
    if ( dir == NULL )
        return -1;
 
    while ( ( entry = readdir ( dir ) ) ) {
        if ( !memcmp ( entry->d_name, ".",  2 ) )
            continue;
 
        if ( !memcmp ( entry->d_name, "..", 3 ) )
            continue;
 
        if ( kqueue_add_watch_direntry ( ctx_p, indexes_p, entry, dir_obj_p ) == NULL ) {
            error ( "Got error while kqueue_add_watch_direntry(ctx_p, indexes_p, entry {->d_name == \"%s\"}, %u)", entry->d_name, dir_obj_p->fd );
            return -1;
        }
    }
 
    return dir_obj_p->fd;
}
 
int kqueue_wait ( ctx_t *ctx_p, struct indexes *indexes_p, struct timeval *tv_p )
{
    struct kqueue_data *dat = ctx_p->fsmondata;
    struct timespec ts;
    debug ( 3, "tv_p->: tv_sec == %li; tv_usec == %li", tv_p->tv_sec, tv_p->tv_usec );
#ifdef PARANOID
 
    if ( tv_p == NULL )
        return dat->eventlist_count = kevent ( dat->kqueue_d, dat->changelist, dat->changelist_used, dat->eventlist, KQUEUE_EVENTLISTSIZE, NULL );
 
#endif
    ts.tv_sec  = tv_p->tv_sec;
    ts.tv_nsec = tv_p->tv_usec * 1000;
    return dat->eventlist_count = kevent ( dat->kqueue_d, dat->changelist, dat->changelist_used, dat->eventlist, KQUEUE_EVENTLISTSIZE, &ts );
}
 
// Not a thread-safe function!
char *kqueue_getpath ( ctx_t *ctx_p, indexes_t *indexes_p, monobj_t *obj_p )
{
    char  *dirpath;
    size_t dirpath_len;
    static char   filepath[PATH_MAX + 2];
    size_t filepath_len;
    dirpath = indexes_wd2fpath ( indexes_p, obj_p->fd );
 
    if ( dirpath != NULL )
        return strdup ( dirpath );
 
    if ( obj_p->dir_fd == -1 ) {
        errno = ENOENT;
        error ( "Cannot find fd of parent directory of \"%s\"", obj_p->name );
        return NULL;
    }
 
    dirpath = indexes_wd2fpath ( indexes_p, obj_p->dir_fd );
 
    if ( dirpath == NULL ) {
        errno = ENOENT;
        error ( "Cannot find directory with fd == %u", obj_p->dir_fd );
        return NULL;
    }
 
    dirpath_len  = strlen ( dirpath );
    filepath_len = dirpath_len + obj_p->name_len + 1;
#ifdef PARANOID
 
    if ( filepath_len + 1 >= PATH_MAX ) {
        errno = ENAMETOOLONG;
        error ( "Too long file path: \"%s/%s\"", dirpath, obj_p->name );
        return NULL;
    }
 
#endif
    memcpy ( filepath, dirpath, dirpath_len );
    filepath[dirpath_len] = '/';
    memcpy ( &filepath[dirpath_len + 1], obj_p->name, obj_p->name_len + 1 );
    return filepath;
}
 
int kqueue_sync ( ctx_t *ctx_p, indexes_t *indexes_p, struct kevent *ev_p, monobj_t *obj_p )
{
    stat64_t lst, *lst_p;
    char *path_full = kqueue_getpath ( ctx_p, indexes_p, obj_p );
#ifdef PARANOID
 
    if ( path_full == NULL ) {
        error ( "Cannot get full path for \"%s\" (fd: %u)", obj_p->name, obj_p->fd );
        return -1;
    }
 
#endif
    debug ( 8, "path_full = \"%s\"", path_full );
    mode_t st_mode;
    size_t st_size;
 
    if ( ( ev_p->fflags == NOTE_DELETE ) || ( ctx_p->flags[CANCEL_SYSCALLS]&CSC_MON_STAT ) || lstat64 ( path_full, &lst ) ) {
        debug ( 2, "Cannot or cancelled lstat64(\"%s\", lst). The object had been deleted (%i) or option \"--cancel-syscalls=mon_stat\" (%i) is set.", path_full, ev_p->fflags == NOTE_DELETE, ctx_p->flags[CANCEL_SYSCALLS]&CSC_MON_STAT );
        st_mode = ( obj_p->type == DT_DIR ? S_IFDIR : S_IFREG );
        st_size = 0;
        lst_p = NULL;
    } else {
        st_mode =  lst.st_mode;
        st_size =  lst.st_size;
        lst_p = &lst;
    }
 
    {
        char   *path_rel    = NULL;
        size_t  path_rel_len    = 0;
        struct  recognize_event_return r;
        r.u.i = recognize_event ( ev_p->fflags, obj_p->type == DT_DIR );
        int ret = sync_prequeue_loadmark ( 1, ctx_p, indexes_p, path_full, NULL, lst_p, r.u.v.objtype_old, r.u.v.objtype_new, ev_p->fflags, ev_p->ident, st_mode, st_size, &path_rel, &path_rel_len, NULL );
 
        if ( path_rel != NULL )
            free ( path_rel );
 
        return ret;
    }
 
    return 0;
}
 
static inline int _kqueue_handle_oneevent_dircontent_item ( struct kqueue_data *dat, ctx_t *ctx_p, indexes_t *indexes_p, monobj_t *dir_obj_p, struct dirent *entry, void *children_notfound )
{
    static monobj_t obj, *obj_p;
    struct kevent ev = {0};
    debug ( 9, "\"%s\"", entry->d_name );
    obj.type      = entry->d_type;
    obj.inode     = entry->d_ino;
    obj.device    = dir_obj_p->device;
    obj.dir_fd    = dir_obj_p->fd;
    obj.name      = entry->d_name;
    obj.name_len  = strlen ( entry->d_name );
    obj.name_hash = adler32_calc ( ( unsigned char * ) entry->d_name, obj.name_len );
    debug ( 20, "Checking if the object is already monitored (obj_p == %p)", obj_p );
 
    if ( ( obj_p = g_tree_lookup ( dat->file_btree, &obj ) ) != NULL ) {
        debug ( 20, "Marking the the object is found" );
        g_tree_remove ( children_notfound, obj_p );
        return 0;
    }
 
    debug ( 20, "Calling kqueue_start_watch() on the object" );
 
    if ( ( obj_p = kqueue_start_watch ( ctx_p, entry->d_ino, dir_obj_p->device, dir_obj_p->fd, obj.name, obj.name_len, obj.type ) ) == NULL ) {
        error ( "Got error while kqueue_start_watch()" );
        return -1;
    }
 
    debug ( 20, "Calling kqueue_sync() for the object" );
    ev.ident  = obj_p->fd;
    ev.fflags = NOTE_LINK;
 
    if ( kqueue_sync ( ctx_p, indexes_p, &ev, obj_p ) ) {
        error ( "Got error while kqueue_sync()" );
        return -1;
    }
 
    return 0;
}
 
void monobj_freedup ( gpointer _obj_p )
{
    monobj_t *obj_p = _obj_p;
    free ( obj_p->name );
    free ( obj_p );
    return;
}
 
gpointer monobj_dup ( gpointer _obj_p )
{
    monobj_t *src = _obj_p, *dst;
    dst = xmalloc ( sizeof ( *src ) );
    memcpy ( dst, src, sizeof ( *src ) );
    dst->name   = xmalloc ( src->name_len + 2 );
    memcpy ( dst->name, src->name, src->name_len + 1 );
    dst->origin = src;
    return dst;
}
 
gboolean unmarkdupchild ( gpointer _obj_p, gpointer value, gpointer _ctx_p )
{
    monobj_t *dupobj_p = _obj_p;
    monobj_t *obj_p    = dupobj_p->origin;
//  ctx_t    *ctx_p    = _ctx_p;
    unmarkchild ( obj_p );
    return FALSE;
}
 
int _kqueue_handle_oneevent_dircontent ( ctx_t *ctx_p, indexes_t *indexes_p, monobj_t *obj_p )
{
    DIR *dir;
    GTree *children_tree_dup;
    struct dirent *entry;
    struct kqueue_data *dat = ctx_p->fsmondata;
    debug ( 8, "obj_p == %p; obj_p->dir_fd == %i", obj_p, obj_p->dir_fd );
    debug ( 20, "open*()-ing the directory" );
    int fd;
 
    if ( obj_p->dir_fd == -1 )
        fd = open ( ctx_p->watchdir, O_RDONLY | O_PATH );
    else
        fd = openat ( obj_p->dir_fd, obj_p->name, O_RDONLY | O_PATH );
 
    debug ( 20, "fdopendir()-ing the directory" );
    dir = fdopendir ( fd );
 
    if ( dir == NULL ) {
        debug ( 20, "dir == NULL. return 0" );
        return 0;
    }
 
    debug ( 20, "tdup()-ing the children_tree == %p", obj_p->children_tree );
    children_tree_dup = g_tree_dup ( obj_p->children_tree, monobj_filecmp, ctx_p, monobj_freedup, NULL, monobj_dup, NULL );
    debug ( 8, "children_count == %i", g_tree_nnodes ( children_tree_dup ) );
    debug ( 20, "reading the directory" );
 
    while ( ( entry = readdir ( dir ) ) ) {
        debug ( 10, "file/dir: \"%s\"", entry->d_name );
 
        if ( !memcmp ( entry->d_name, ".",  2 ) )
            continue;
 
        if ( !memcmp ( entry->d_name, "..", 3 ) )
            continue;
 
        if ( _kqueue_handle_oneevent_dircontent_item ( dat, ctx_p, indexes_p, obj_p, entry, children_tree_dup ) ) {
            error ( "Got error while _kqueue_handle_oneevent_dircontent_item(ctx_p, obj_p, entry {->d_name == \"%s\"})", entry->d_name );
            return -1;
        }
    }
 
    debug ( 20, "searching for deleted objects from the directory" );
    g_tree_foreach ( children_tree_dup, unmarkdupchild, ctx_p );
    g_tree_destroy ( children_tree_dup );
    debug ( 20, "end" );
    closedir ( dir );
    return 0;
}
 
int kqueue_handle_oneevent ( ctx_t *ctx_p, indexes_t *indexes_p, struct kevent *ev_p, monobj_t *obj_p )
{
#ifdef VERYPARANOID
 
    if ( ev_p == NULL ) {
        errno = EINVAL;
        return -1;
    }
 
    if ( obj_p == NULL ) {
        errno = EINVAL;
        return -1;
    }
 
#endif
    debug ( 9, "obj_p->: name == \"%s\"; dir_fd == %i; type == 0x%x (isdir == %i); fd = %i. ev_p->fflags == 0x%x", obj_p->name, obj_p->dir_fd, obj_p->type, obj_p->type == DT_DIR, obj_p->fd, ev_p->fflags );
    int ret    = 0;
 
    if ( obj_p->type == DT_DIR && ( ev_p->fflags & ( NOTE_EXTEND | NOTE_WRITE ) ) )
        ret |= _kqueue_handle_oneevent_dircontent ( ctx_p, indexes_p, obj_p );
 
    if ( ev_p->fflags & ( NOTE_EXTEND | NOTE_WRITE | NOTE_ATTRIB | NOTE_DELETE | NOTE_RENAME ) )
        ret |= kqueue_sync ( ctx_p, indexes_p, ev_p, obj_p );
 
    if ( ev_p->fflags & NOTE_DELETE )
        ret |= kqueue_unmark ( ctx_p, obj_p );
 
    return ret;
}
 
int kqueue_handle ( ctx_t *ctx_p, indexes_t *indexes_p )
{
    static struct timeval tv = {0};
    struct kqueue_data *dat = ctx_p->fsmondata;
    debug ( 3, "dat->eventlist_count == %i", dat->eventlist_count );
 
    if ( dat->eventlist_count == 0 )
        return 0;
 
    int count = 0;
 
    do {
        int i = 0;
#ifdef PARANOID
        g_hash_table_remove_all ( indexes_p->fpath2ei_ht );
#endif
 
        while ( i < dat->eventlist_count ) {
            struct kevent *ev_p = &dat->eventlist[i++];
            monobj_t obj;
            obj.fd = ev_p->ident;
            monobj_t *obj_p = g_tree_lookup ( dat->fd_btree, &obj );
 
            if ( obj_p == NULL ) {
                debug ( 3, "Cannot find internal structure for fd == %u. Skipping the event.", ev_p->ident );
                continue;
            }
 
            if ( kqueue_handle_oneevent ( ctx_p, indexes_p, ev_p, obj_p ) ) {
                error ( "Got error from kqueue_handle_oneevent()" );
                return -1;
            }
 
            count++;
        }
 
        // Globally queueing captured events:
        // Moving events from local queue to global ones
        sync_prequeue_unload ( ctx_p, indexes_p );
        dat->eventlist_count = 0;
    } while ( kqueue_wait ( ctx_p, indexes_p, &tv ) );
 
    return count;
}
 
int kqueue_deinit ( ctx_t *ctx_p )
{
    kqueue_status = KQUEUE_STATUS_DEINIT;
    struct kqueue_data *dat = ctx_p->fsmondata;
    debug ( 3, "dat->eventlist_count == %i", dat->eventlist_count );
    g_tree_destroy ( dat->file_btree );
    g_tree_destroy ( dat->fd_btree );
    kqueue_status = KQUEUE_STATUS_DEAD;
    return 0;
}