ioloop-notify-dn.c revision 01ac83a86f9f29741b585205eefeec9c0c546f8b
/* Copyright (C) 2003 Timo Sirainen */
/* Logic is pretty much based on dnotify by Oskar Liljeblad. */
#define _GNU_SOURCE
#include "lib.h"
#ifdef IOLOOP_NOTIFY_DNOTIFY
#include "ioloop-internal.h"
#include "fd-set-nonblock.h"
#include "fd-close-on-exec.h"
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
struct ioloop_notify_handler_context {
struct io *event_io;
int disabled;
};
static int event_pipe[2] = { -1, -1 };
static void sigrt_handler(int signo __attr_unused__, siginfo_t *si,
void *data __attr_unused__)
{
int ret;
ret = write(event_pipe[1], &si->si_fd, sizeof(int));
if (ret < 0 && errno != EINTR && errno != EAGAIN)
i_fatal("write(event_pipe) failed: %m");
i_assert(ret <= 0 || ret == sizeof(int));
}
static void event_callback(void *context)
{
struct ioloop *ioloop = context;
struct io *io;
int fd, ret;
ret = read(event_pipe[0], &fd, sizeof(fd));
if (ret < 0)
i_fatal("read(event_pipe) failed: %m");
if (ret != sizeof(fd)) {
i_fatal("read(event_pipe) returned %d != %"PRIuSIZE_T,
ret, sizeof(fd));
}
if (gettimeofday(&ioloop_timeval, &ioloop_timezone) < 0)
i_fatal("gettimeofday(): %m");
ioloop_time = ioloop_timeval.tv_sec;
for (io = ioloop->notifys; io != NULL; io = io->next) {
if (io->fd == fd) {
io->callback(io->context);
break;
}
}
}
struct io *io_loop_notify_add(struct ioloop *ioloop, const char *path,
io_callback_t *callback, void *context)
{
struct ioloop_notify_handler_context *ctx =
ioloop->notify_handler_context;
struct io *io;
int fd;
fd = open(path, O_RDONLY);
if (fd == -1) {
i_error("open(%s) for dnotify failed: %m", path);
return NULL;
}
if (fcntl(fd, F_SETSIG, SIGRTMIN) < 0) {
if (errno == EINVAL) {
/* dnotify not in kernel. disable it. */
ctx->disabled = TRUE;
} else {
i_error("fcntl(F_SETSIG) failed: %m");
}
(void)close(fd);
return NULL;
}
if (fcntl(fd, F_NOTIFY, DN_CREATE | DN_DELETE | DN_RENAME |
DN_MULTISHOT) < 0) {
/* we fail here if we're trying to add dnotify to
non-directory fd. fail silently in that case. */
if (errno != ENOTDIR)
i_error("fcntl(F_NOTIFY) failed: %m");
(void)fcntl(fd, F_SETSIG, 0);
(void)close(fd);
return NULL;
}
if (ctx->event_io == NULL) {
ctx->event_io =
io_add(event_pipe[0], IO_READ, event_callback, ioloop);
}
io = p_new(ioloop->pool, struct io, 1);
io->fd = fd;
io->callback = callback;
io->context = context;
io->next = ioloop->notifys;
ioloop->notifys = io;
return io;
}
void io_loop_notify_remove(struct ioloop *ioloop, struct io *io)
{
struct ioloop_notify_handler_context *ctx =
ioloop->notify_handler_context;
struct io **io_p;
if (ctx->disabled)
return;
for (io_p = &ioloop->notifys; *io_p != NULL; io_p = &(*io_p)->next) {
if (*io_p == io) {
*io_p = io->next;
break;
}
}
if (fcntl(io->fd, F_NOTIFY, 0) < 0)
i_error("fcntl(F_NOTIFY, 0) failed: %m");
if (fcntl(io->fd, F_SETSIG, 0) < 0)
i_error("fcntl(F_SETSIG, 0) failed: %m");
if (close(io->fd))
i_error("close(dnotify) failed: %m");
p_free(ioloop->pool, io);
if (ioloop->notifys == NULL) {
io_remove(ctx->event_io);
ctx->event_io = NULL;
}
}
void io_loop_notify_handler_init(struct ioloop *ioloop)
{
struct ioloop_notify_handler_context *ctx;
struct sigaction act;
i_assert(event_pipe[0] == -1);
ctx = ioloop->notify_handler_context =
i_new(struct ioloop_notify_handler_context, 1);
if (pipe(event_pipe) < 0) {
i_fatal("pipe() failed: %m");
return;
}
fd_set_nonblock(event_pipe[0], TRUE);
fd_set_nonblock(event_pipe[1], TRUE);
fd_close_on_exec(event_pipe[0], TRUE);
fd_close_on_exec(event_pipe[1], TRUE);
/* SIGIO is sent if queue gets full. we'll just ignore it. */
signal(SIGIO, SIG_IGN);
act.sa_sigaction = sigrt_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_SIGINFO | SA_RESTART | SA_NODEFER;
if (sigaction(SIGRTMIN, &act, NULL) < 0)
i_fatal("sigaction(SIGRTMIN) failed: %m");
}
void io_loop_notify_handler_deinit(struct ioloop *ioloop __attr_unused__)
{
struct ioloop_notify_handler_context *ctx =
ioloop->notify_handler_context;
signal(SIGRTMIN, SIG_IGN);
if (close(event_pipe[0]) < 0)
i_error("close(event_pipe[0]) failed: %m");
if (close(event_pipe[1]) < 0)
i_error("close(event_pipe[1]) failed: %m");
i_free(ctx);
}
#endif