fsevents.c

/** fsevents.c from Lsyncd - Live (Mirror) Syncing Demon
 *
 * License: GPLv2 (see COPYING) or any later version
 *
 * Authors: Axel Kittenberger <axkibe@gmail.com>
 *          Damian Steward <damian.stewart@gmail.com>
 *
 * -----------------------------------------------------------------------
 *
 * Event interface for MacOS 10.5 (Leopard) /dev/fsevents interface.
 *
 * Special thanks go to Amit Singh and his fslogger demonstration that showed
 * how apples /dev/fsevents can be used.  http://osxbook.com/software/fslogger/
 *
 * -- WARNING -- Quoting http://www.osxbook.com/software/fslogger/ --
 *
 * The interface that fslogger [and thus Lsyncd] uses is private to Apple.
 * Currently, there is a caveat regarding the use of this interface by third
 * parties (including fslogger [and thus Lsyncd]). While the change
 * notification interface supports multiple clients, there is a single kernel
 * buffer for holding events that are to be delivered to one or more
 * subscribers, with the primary subscriber being Spotlight. Now, the kernel
 * must hold events until it has notified all subscribers that are interested
 * in them. Since there is a single buffer, a slow subscriber can cause it to
 * overflow. If this happens, events will be dropped — for all subscribers,
 * including Spotlight.  Consequently, Spotlight may need to look at the entire
 * volume to determine "what changed".
 */
#include "lsyncd.h"

#include <sys/types.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "bsd/sys/fsevents.h"

#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>


/* the fsevents pseudo-device */
#define DEV_FSEVENTS     "/dev/fsevents"

/* buffer for reading from the device */
#define FSEVENT_BUFSIZ   131072

/* limited by MAX_KFS_EVENTS */
#define EVENT_QUEUE_SIZE 4096

#define KFS_NUM_ARGS  FSE_MAX_ARGS

/* OS 10.5 structuce */
/* an event argument */
struct kfs_event_arg {
	/* argument type */
    u_int16_t  type;

    /* size of argument data that follows this field */
    u_int16_t  len;

    union {
        struct vnode *vp;
        char    *str;
        void    *ptr;
        int32_t  int32;
        dev_t    dev;
        ino_t    ino;
        int32_t  mode;
        uid_t    uid;
        gid_t    gid;
        uint64_t timestamp;
    } data;
};

/* OS 10.5 structuce */
/* an event */
struct kfs_event {

	/* event type */
    int32_t  type;

	/* pid of the process that performed the operation */
    pid_t    pid;

	/* event arguments */
    struct kfs_event_arg* args[FSE_MAX_ARGS];
};

/**
 * fsevents (cloned) filedescriptor
 */
static int fsevents_fd = -1;

/* event names */
/*static const char *eventNames[FSE_MAX_EVENTS] = {
	"CREATE_FILE",
	"DELETE",
	"STAT_CHANGED",
	"RENAME",
	"CONTENT_MODIFIED",
	"EXCHANGE",
	"FINDER_INFO_CHANGED",
	"CREATE_DIR",
	"CHOWN",
	"XATTR_MODIFIED",
	"XATTR_REMOVED",
};*/

/* argument names*/
/*static const char *argNames[] = {
	"UNKNOWN",
	"VNODE",
	"STRING",
	"PATH",
	"INT32",
	"INT64",
	"RAW",
	"INO",
	"UID",
	"DEV",
	"MODE",
	"GID",
	"FINFO",
};*/

/**
 * The read buffer
 */
static size_t const readbuf_size = 131072;
static char * readbuf = NULL;

/**
 * The event buffer
 */
static size_t const eventbuf_size = FSEVENT_BUFSIZ;
static char* eventbuf = NULL;

/**
 * Handles one fsevents event
 */
static void
handle_event(lua_State *L, struct kfs_event *event, ssize_t mlen)
{
	int32_t atype;
	const char *path = NULL;
	const char *trg  = NULL;
	const char *etype = NULL;
	int isdir = -1;

	if (event->type == FSE_EVENTS_DROPPED) {
		logstring("Fsevents", "Events dropped!");
		load_runner_func(L, "overflow");
		if (lua_pcall(L, 0, 0, -2)) {
			exit(-1); // ERRNO
		}
		lua_pop(L, 1);
		hup = 1;
		return;
	}

	atype  = event->type & FSE_TYPE_MASK;
	/*uint32_t aflags = FSE_GET_FLAGS(event->type);*/

	if ((atype < FSE_MAX_EVENTS) && (atype >= -1)) {
		/*printlogf(L, "Fsevents", "got event %s", eventNames[atype]);
		if (aflags & FSE_COMBINED_EVENTS) {
			logstring("Fsevents", "combined events");
		}
		if (aflags & FSE_CONTAINS_DROPPED_EVENTS) {
			logstring("Fsevents", "contains dropped events");
		}*/
	} else {
		printlogf(
			L,
			"Error",
			"unknown event(%d) in fsevents.",
			atype
		);

		exit(-1); // ERRNO
	}

	{
		/* assigns the expected arguments */
		int whichArg = 0;
		while (whichArg < FSE_MAX_ARGS) {
			struct kfs_event_arg * arg = event->args[whichArg++];
			if (arg->type == FSE_ARG_DONE) {
				break;
			}

			switch (arg->type) {
			case FSE_ARG_STRING :
				switch(atype) {
				case FSE_RENAME :
					if (path) {
						// for move events second string is target
						trg = (char *) &arg->data.str;
					}
					// fallthrough
				case FSE_CHOWN :
				case FSE_CONTENT_MODIFIED :
				case FSE_CREATE_FILE :
				case FSE_CREATE_DIR :
				case FSE_DELETE :
				case FSE_STAT_CHANGED :
					if (!path) path = (char *)&arg->data.str;
					break;
				}
				break;
			case FSE_ARG_MODE :
				switch(atype) {
				case FSE_RENAME :
				case FSE_CHOWN :
				case FSE_CONTENT_MODIFIED :
				case FSE_CREATE_FILE :
				case FSE_CREATE_DIR :
				case FSE_DELETE :
				case FSE_STAT_CHANGED :
					isdir = arg->data.mode & S_IFDIR ? 1 : 0;
					break;
				}
				break;
			}
		}
	}

	switch(atype) {
	case FSE_CHOWN :
	case FSE_STAT_CHANGED :
		etype = "Attrib";
		break;
	case FSE_CREATE_DIR :
	case FSE_CREATE_FILE :
		etype = "Create";
		break;
	case FSE_DELETE :
		etype = "Delete";
		break;
	case FSE_RENAME :
		etype = "Move";
		break;
	case FSE_CONTENT_MODIFIED :
		etype = "Modify";
		break;
	}

	if (etype) {
		if (!path) {
			printlogf(L, "Error", "Internal fail, fsevents, no path.");
			exit(-1);
		}
		if (isdir < 0) {
			printlogf(L, "Error", "Internal fail, fsevents, neither dir nor file.");
			exit(-1);
		}
		load_runner_func(L, "fsEventsEvent");
		lua_pushstring(L, etype);
		lua_pushboolean(L, isdir);
		l_now(L);
		lua_pushstring(L, path);
		if (trg) {
			lua_pushstring(L, trg);
		} else {
			lua_pushnil(L);
		}

   	 	if (lua_pcall(L, 5, 0, -7)) {
			exit(-1); // ERRNO
		}
		lua_pop(L, 1);
	}
}

/**
 * Called when fsevents has something to read
 */
static void
fsevents_ready(lua_State *L, struct observance *obs)
{
	if (obs->fd != fsevents_fd) {
		logstring("Error", "Internal, fsevents_fd != ob->fd");
		exit(-1); // ERRNO
	}

	ptrdiff_t len = read (fsevents_fd, readbuf, readbuf_size);
	int err = errno;
	if (len == 0) {
		return;
	}
	if (len < 0) {
		if (err == EAGAIN) {
			/* nothing more */
			return;
		} else {
			printlogf(L, "Error", "Read fail on fsevents");
			exit(-1); // ERRNO
		}
	}
	{
		int off = 0;
		while (off < len && !hup && !term) {
			/* deals with alignment issues on 64 bit by copying data bit by bit */
			struct kfs_event* event = (struct kfs_event *) eventbuf;
			event->type = *(int32_t*)(readbuf+off);
			off += sizeof(int32_t);
			event->pid = *(pid_t*)(readbuf+off);
			off += sizeof(pid_t);
			/* arguments */
			int whichArg = 0;
			int eventbufOff = sizeof(struct kfs_event);
			size_t ptrSize = sizeof(void*);
			if ((eventbufOff % ptrSize) != 0) {
				eventbufOff += ptrSize-(eventbufOff%ptrSize);
			}
			while (off < len && whichArg < FSE_MAX_ARGS) {
				/* assign argument pointer to eventbuf based on 
				   known current offset into eventbuf */
				uint16_t argLen = 0;
				event->args[whichArg] = (struct kfs_event_arg *) (eventbuf + eventbufOff);
				/* copy type */
				uint16_t argType = *(uint16_t*)(readbuf + off);
				event->args[whichArg]->type = argType;
				off += sizeof(uint16_t);
				if (argType == FSE_ARG_DONE) {
					/* done */
					break;
				} else {
					/* copy data length */
					argLen = *(uint16_t *)(readbuf + off);
					event->args[whichArg]->len = argLen;
					off += sizeof(uint16_t);
					/* copy data */
					memcpy(&(event->args[whichArg]->data), readbuf + off, argLen);
					  off += argLen;
				}
				/* makes sure alignment is correct for 64 bit systems */
				size_t argStructLen = sizeof(uint16_t) + sizeof(uint16_t);
				if ((argStructLen % ptrSize) != 0) {
					argStructLen += ptrSize-(argStructLen % ptrSize);
				}
				argStructLen += argLen;
				if ((argStructLen % ptrSize) != 0) {
					argStructLen += ptrSize-(argStructLen % ptrSize);
				}
				eventbufOff += argStructLen;
				whichArg++;
			}
			handle_event(L, event, len);
		}
	}
}

/**
 * Called to close/tidy fsevents
 */
static void
fsevents_tidy(struct observance *obs)
{
	if (obs->fd != fsevents_fd) {
		logstring("Error", "Internal, fsevents_fd != ob->fd");
		exit(-1); // ERRNO
	}
	close(fsevents_fd);
	free(readbuf);
	readbuf = NULL;
	free(eventbuf);
	eventbuf = NULL;
}

/**
 * opens and initalizes fsevents.
 */
extern void
open_fsevents(lua_State *L)
{
	int8_t event_list[] = { // action to take for each event
		FSE_REPORT,  // FSE_CREATE_FILE
		FSE_REPORT,  // FSE_DELETE
		FSE_REPORT,  // FSE_STAT_CHANGED
		FSE_REPORT,  // FSE_RENAME
		FSE_REPORT,  // FSE_CONTENT_MODIFIED
		FSE_REPORT,  // FSE_EXCHANGE
		FSE_REPORT,  // FSE_FINDER_INFO_CHANGED
		FSE_REPORT,  // FSE_CREATE_DIR
		FSE_REPORT,  // FSE_CHOWN
		FSE_REPORT,  // FSE_XATTR_MODIFIED
		FSE_REPORT,  // FSE_XATTR_REMOVED
	};
	struct fsevent_clone_args fca = {
		.event_list = (int8_t *) event_list,
		.num_events = sizeof(event_list)/sizeof(int8_t),
		.event_queue_depth = EVENT_QUEUE_SIZE,
		.fd = &fsevents_fd,
	};
	int fd = open(DEV_FSEVENTS, O_RDONLY);
	int err = errno;
	printlogf(L, "Warn",
		"Using /dev/fsevents which is considered an OSX internal interface.");
	printlogf(L, "Warn",
		"Functionality might break across OSX versions (This is for 10.5.X)");
	printlogf(L, "Warn",
		"A hanging Lsyncd might cause Spotlight/Timemachine doing extra work.");

	if (fd < 0) {
		printlogf(L, "Error",
			"Cannot access %s monitor! (%d:%s)",
			DEV_FSEVENTS, err, strerror(err));
		exit(-1); // ERRNO
	}

	if (ioctl(fd, FSEVENTS_CLONE, (char *)&fca) < 0) {
		printlogf(L, "Error",
			"Cannot control %s monitor! (%d:%s)",
			DEV_FSEVENTS, errno, strerror(errno));
		exit(-1); // ERRNO
	}

	if (readbuf) {
		logstring("Error",
			"internal fail, inotify readbuf!=NULL in open_inotify()")
		exit(-1); // ERRNO
	}
	readbuf = s_malloc(readbuf_size);
	eventbuf = s_malloc(eventbuf_size);
	// fd has been cloned, closes access fd
	close(fd);
	close_exec_fd(fsevents_fd);
	non_block_fd(fsevents_fd);
	observe_fd(fsevents_fd, fsevents_ready, NULL, fsevents_tidy, NULL);
}