[qemu.git] / util / filemonitor-inotify.c

/*
 * QEMU file monitor Linux inotify impl
 *
 * Copyright (c) 2018 Red Hat, Inc.
 *
 * 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, see <http://www.gnu.org/licenses/>.
 *
 */

#include "qemu/osdep.h"
#include "qemu/filemonitor.h"
#include "qemu/main-loop.h"
#include "qemu/error-report.h"
#include "qapi/error.h"
#include "trace.h"

#include <sys/inotify.h>

struct QFileMonitor {
    int fd;
    QemuMutex lock; /* protects dirs & idmap */
    GHashTable *dirs; /* dirname => QFileMonitorDir */
    GHashTable *idmap; /* inotify ID => dirname */
};


typedef struct {
    int64_t id; /* watch ID */
    char *filename; /* optional filter */
    QFileMonitorHandler cb;
    void *opaque;
} QFileMonitorWatch;


typedef struct {
    char *path;
    int inotify_id; /* inotify ID */
    int next_file_id; /* file ID counter */
    GArray *watches; /* QFileMonitorWatch elements */
} QFileMonitorDir;


static void qemu_file_monitor_watch(void *arg)
{
    QFileMonitor *mon = arg;
    char buf[4096]
        __attribute__ ((aligned(__alignof__(struct inotify_event))));
    int used = 0;
    int len;

    qemu_mutex_lock(&mon->lock);

    if (mon->fd == -1) {
        qemu_mutex_unlock(&mon->lock);
        return;
    }

    len = read(mon->fd, buf, sizeof(buf));

    if (len < 0) {
        if (errno != EAGAIN) {
            error_report("Failure monitoring inotify FD '%s',"
                         "disabling events", strerror(errno));
            goto cleanup;
        }

        /* no more events right now */
        goto cleanup;
    }

    /* Loop over all events in the buffer */
    while (used < len) {
        struct inotify_event *ev =
            (struct inotify_event *)(buf + used);
        const char *name = ev->len ? ev->name : "";
        QFileMonitorDir *dir = g_hash_table_lookup(mon->idmap,
                                                   GINT_TO_POINTER(ev->wd));
        uint32_t iev = ev->mask &
            (IN_CREATE | IN_MODIFY | IN_DELETE | IN_IGNORED |
             IN_MOVED_TO | IN_MOVED_FROM | IN_ATTRIB);
        int qev;
        gsize i;

        used += sizeof(struct inotify_event) + ev->len;

        if (!dir) {
            continue;
        }

        /*
         * During a rename operation, the old name gets
         * IN_MOVED_FROM and the new name gets IN_MOVED_TO.
         * To simplify life for callers, we turn these into
         * DELETED and CREATED events
         */
        switch (iev) {
        case IN_CREATE:
        case IN_MOVED_TO:
            qev = QFILE_MONITOR_EVENT_CREATED;
            break;
        case IN_MODIFY:
            qev = QFILE_MONITOR_EVENT_MODIFIED;
            break;
        case IN_DELETE:
        case IN_MOVED_FROM:
            qev = QFILE_MONITOR_EVENT_DELETED;
            break;
        case IN_ATTRIB:
            qev = QFILE_MONITOR_EVENT_ATTRIBUTES;
            break;
        case IN_IGNORED:
            qev = QFILE_MONITOR_EVENT_IGNORED;
            break;
        default:
            g_assert_not_reached();
        }

        trace_qemu_file_monitor_event(mon, dir->path, name, ev->mask,
                                      dir->inotify_id);
        for (i = 0; i < dir->watches->len; i++) {
            QFileMonitorWatch *watch = &g_array_index(dir->watches,
                                                      QFileMonitorWatch,
                                                      i);

            if (watch->filename == NULL ||
                (name && g_str_equal(watch->filename, name))) {
                trace_qemu_file_monitor_dispatch(mon, dir->path, name,
                                                 qev, watch->cb,
                                                 watch->opaque, watch->id);
                watch->cb(watch->id, qev, name, watch->opaque);
            }
        }
    }

 cleanup:
    qemu_mutex_unlock(&mon->lock);
}


static void
qemu_file_monitor_dir_free(void *data)
{
    QFileMonitorDir *dir = data;
    gsize i;

    for (i = 0; i < dir->watches->len; i++) {
        QFileMonitorWatch *watch = &g_array_index(dir->watches,
                                                  QFileMonitorWatch, i);
        g_free(watch->filename);
    }
    g_array_unref(dir->watches);
    g_free(dir->path);
    g_free(dir);
}


QFileMonitor *
qemu_file_monitor_new(Error **errp)
{
    int fd;
    QFileMonitor *mon;

    fd = inotify_init1(IN_NONBLOCK);
    if (fd < 0) {
        error_setg_errno(errp, errno,
                         "Unable to initialize inotify");
        return NULL;
    }

    mon = g_new0(QFileMonitor, 1);
    qemu_mutex_init(&mon->lock);
    mon->fd = fd;

    mon->dirs = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
                                      qemu_file_monitor_dir_free);
    mon->idmap = g_hash_table_new(g_direct_hash, g_direct_equal);

    trace_qemu_file_monitor_new(mon, mon->fd);

    return mon;
}

static gboolean
qemu_file_monitor_free_idle(void *opaque)
{
    QFileMonitor *mon = opaque;

    if (!mon) {
        return G_SOURCE_REMOVE;
    }

    qemu_mutex_lock(&mon->lock);

    g_hash_table_unref(mon->idmap);
    g_hash_table_unref(mon->dirs);

    qemu_mutex_unlock(&mon->lock);

    qemu_mutex_destroy(&mon->lock);
    g_free(mon);

    return G_SOURCE_REMOVE;
}

void
qemu_file_monitor_free(QFileMonitor *mon)
{
    if (!mon) {
        return;
    }

    qemu_mutex_lock(&mon->lock);
    if (mon->fd != -1) {
        qemu_set_fd_handler(mon->fd, NULL, NULL, NULL);
        close(mon->fd);
        mon->fd = -1;
    }
    qemu_mutex_unlock(&mon->lock);

    /*
     * Can't free it yet, because another thread
     * may be running event loop, so the inotify
     * callback might be pending. Using an idle
     * source ensures we'll only free after the
     * pending callback is done
     */
    g_idle_add((GSourceFunc)qemu_file_monitor_free_idle, mon);
}

int64_t
qemu_file_monitor_add_watch(QFileMonitor *mon,
                            const char *dirpath,
                            const char *filename,
                            QFileMonitorHandler cb,
                            void *opaque,
                            Error **errp)
{
    QFileMonitorDir *dir;
    QFileMonitorWatch watch;
    int64_t ret = -1;

    qemu_mutex_lock(&mon->lock);
    dir = g_hash_table_lookup(mon->dirs, dirpath);
    if (!dir) {
        int rv = inotify_add_watch(mon->fd, dirpath,
                                   IN_CREATE | IN_DELETE | IN_MODIFY |
                                   IN_MOVED_TO | IN_MOVED_FROM | IN_ATTRIB);

        if (rv < 0) {
            error_setg_errno(errp, errno, "Unable to watch '%s'", dirpath);
            goto cleanup;
        }

        trace_qemu_file_monitor_enable_watch(mon, dirpath, rv);

        dir = g_new0(QFileMonitorDir, 1);
        dir->path = g_strdup(dirpath);
        dir->inotify_id = rv;
        dir->watches = g_array_new(FALSE, TRUE, sizeof(QFileMonitorWatch));

        g_hash_table_insert(mon->dirs, dir->path, dir);
        g_hash_table_insert(mon->idmap, GINT_TO_POINTER(rv), dir);

        if (g_hash_table_size(mon->dirs) == 1) {
            qemu_set_fd_handler(mon->fd, qemu_file_monitor_watch, NULL, mon);
        }
    }

    watch.id = (((int64_t)dir->inotify_id) << 32) | dir->next_file_id++;
    watch.filename = g_strdup(filename);
    watch.cb = cb;
    watch.opaque = opaque;

    g_array_append_val(dir->watches, watch);

    trace_qemu_file_monitor_add_watch(mon, dirpath,
                                      filename ? filename : "<none>",
                                      cb, opaque, watch.id);

    ret = watch.id;

 cleanup:
    qemu_mutex_unlock(&mon->lock);
    return ret;
}


void qemu_file_monitor_remove_watch(QFileMonitor *mon,
                                    const char *dirpath,
                                    int64_t id)
{
    QFileMonitorDir *dir;
    gsize i;

    qemu_mutex_lock(&mon->lock);

    trace_qemu_file_monitor_remove_watch(mon, dirpath, id);

    dir = g_hash_table_lookup(mon->dirs, dirpath);
    if (!dir) {
        goto cleanup;
    }

    for (i = 0; i < dir->watches->len; i++) {
        QFileMonitorWatch *watch = &g_array_index(dir->watches,
                                                  QFileMonitorWatch, i);
        if (watch->id == id) {
            g_free(watch->filename);
            g_array_remove_index(dir->watches, i);
            break;
        }
    }

    if (dir->watches->len == 0) {
        inotify_rm_watch(mon->fd, dir->inotify_id);
        trace_qemu_file_monitor_disable_watch(mon, dir->path, dir->inotify_id);

        g_hash_table_remove(mon->idmap, GINT_TO_POINTER(dir->inotify_id));
        g_hash_table_remove(mon->dirs, dir->path);

        if (g_hash_table_size(mon->dirs) == 0) {
            qemu_set_fd_handler(mon->fd, NULL, NULL, NULL);
        }
    }

 cleanup:
    qemu_mutex_unlock(&mon->lock);
}
Commit	Line	Data
90e33dfe DB	1	/*
	2	* QEMU file monitor Linux inotify impl
	3	*
	4	* Copyright (c) 2018 Red Hat, Inc.
	5	*
	6	* This library is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2 of the License, or (at your option) any later version.
	10	*
	11	* This library is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	18	*
	19	*/
	20
	21	#include "qemu/osdep.h"
	22	#include "qemu/filemonitor.h"
	23	#include "qemu/main-loop.h"
	24	#include "qemu/error-report.h"
	25	#include "qapi/error.h"
	26	#include "trace.h"
	27
	28	#include <sys/inotify.h>
	29
	30	struct QFileMonitor {
	31	int fd;
90e33dfe DB	32	QemuMutex lock; /* protects dirs & idmap */
	33	GHashTable dirs; / dirname => QFileMonitorDir */
	34	GHashTable idmap; / inotify ID => dirname */
	35	};
	36
	37
	38	typedef struct {
b4682a63	39	int64_t id; /* watch ID */
90e33dfe DB	40	char filename; / optional filter */
	41	QFileMonitorHandler cb;
	42	void *opaque;
	43	} QFileMonitorWatch;
	44
	45
	46	typedef struct {
	47	char *path;
b4682a63 DB	48	int inotify_id; /* inotify ID */
b4682a63 DB	49	int next_file_id; /* file ID counter */
90e33dfe DB	50	GArray watches; / QFileMonitorWatch elements */
	51	} QFileMonitorDir;
	52
	53
	54	static void qemu_file_monitor_watch(void *arg)
	55	{
	56	QFileMonitor *mon = arg;
	57	char buf[4096]
	58	__attribute__ ((aligned(__alignof__(struct inotify_event))));
	59	int used = 0;
	60	int len;
	61
	62	qemu_mutex_lock(&mon->lock);
	63
	64	if (mon->fd == -1) {
	65	qemu_mutex_unlock(&mon->lock);
	66	return;
	67	}
	68
	69	len = read(mon->fd, buf, sizeof(buf));
	70
	71	if (len < 0) {
	72	if (errno != EAGAIN) {
	73	error_report("Failure monitoring inotify FD '%s',"
	74	"disabling events", strerror(errno));
	75	goto cleanup;
	76	}
	77
	78	/* no more events right now */
	79	goto cleanup;
	80	}
	81
	82	/* Loop over all events in the buffer */
	83	while (used < len) {
	84	struct inotify_event *ev =
	85	(struct inotify_event *)(buf + used);
	86	const char *name = ev->len ? ev->name : "";
	87	QFileMonitorDir *dir = g_hash_table_lookup(mon->idmap,
	88	GINT_TO_POINTER(ev->wd));
	89	uint32_t iev = ev->mask &
	90	(IN_CREATE \| IN_MODIFY \| IN_DELETE \| IN_IGNORED \|
	91	IN_MOVED_TO \| IN_MOVED_FROM \| IN_ATTRIB);
	92	int qev;
	93	gsize i;
	94
	95	used += sizeof(struct inotify_event) + ev->len;
	96
	97	if (!dir) {
	98	continue;
	99	}
	100
	101	/*
	102	* During a rename operation, the old name gets
	103	* IN_MOVED_FROM and the new name gets IN_MOVED_TO.
	104	* To simplify life for callers, we turn these into
	105	* DELETED and CREATED events
	106	*/
	107	switch (iev) {
	108	case IN_CREATE:
	109	case IN_MOVED_TO:
	110	qev = QFILE_MONITOR_EVENT_CREATED;
	111	break;
	112	case IN_MODIFY:
	113	qev = QFILE_MONITOR_EVENT_MODIFIED;
114	break;
115	case IN_DELETE:
116	case IN_MOVED_FROM:
117	qev = QFILE_MONITOR_EVENT_DELETED;
118	break;
119	case IN_ATTRIB:
120	qev = QFILE_MONITOR_EVENT_ATTRIBUTES;
121	break;
122	case IN_IGNORED:
123	qev = QFILE_MONITOR_EVENT_IGNORED;
124	break;
125	default:
126	g_assert_not_reached();
127	}
128
b4682a63 DB	129	trace_qemu_file_monitor_event(mon, dir->path, name, ev->mask,
b4682a63 DB	130	dir->inotify_id);
90e33dfe DB	131	for (i = 0; i < dir->watches->len; i++) {
	132	QFileMonitorWatch *watch = &g_array_index(dir->watches,
	133	QFileMonitorWatch,
	134	i);
	135
	136	if (watch->filename == NULL \|\|
	137	(name && g_str_equal(watch->filename, name))) {
	138	trace_qemu_file_monitor_dispatch(mon, dir->path, name,
	139	qev, watch->cb,
	140	watch->opaque, watch->id);
	141	watch->cb(watch->id, qev, name, watch->opaque);
	142	}
	143	}
	144	}
	145
	146	cleanup:
	147	qemu_mutex_unlock(&mon->lock);
	148	}
	149
	150
	151	static void
	152	qemu_file_monitor_dir_free(void *data)
	153	{
	154	QFileMonitorDir *dir = data;
	155	gsize i;
	156
	157	for (i = 0; i < dir->watches->len; i++) {
	158	QFileMonitorWatch *watch = &g_array_index(dir->watches,
	159	QFileMonitorWatch, i);
	160	g_free(watch->filename);
	161	}
	162	g_array_unref(dir->watches);
	163	g_free(dir->path);
	164	g_free(dir);
	165	}
	166
	167
	168	QFileMonitor *
	169	qemu_file_monitor_new(Error **errp)
	170	{
	171	int fd;
	172	QFileMonitor *mon;
	173
	174	fd = inotify_init1(IN_NONBLOCK);
	175	if (fd < 0) {
	176	error_setg_errno(errp, errno,
	177	"Unable to initialize inotify");
	178	return NULL;
	179	}
	180
	181	mon = g_new0(QFileMonitor, 1);
	182	qemu_mutex_init(&mon->lock);
	183	mon->fd = fd;
	184
	185	mon->dirs = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
	186	qemu_file_monitor_dir_free);
	187	mon->idmap = g_hash_table_new(g_direct_hash, g_direct_equal);
	188
	189	trace_qemu_file_monitor_new(mon, mon->fd);
	190
	191	return mon;
	192	}
	193
	194	static gboolean
195	qemu_file_monitor_free_idle(void *opaque)
196	{
197	QFileMonitor *mon = opaque;
198
199	if (!mon) {
200	return G_SOURCE_REMOVE;
201	}
202
203	qemu_mutex_lock(&mon->lock);
204
205	g_hash_table_unref(mon->idmap);
206	g_hash_table_unref(mon->dirs);
207
208	qemu_mutex_unlock(&mon->lock);
209
210	qemu_mutex_destroy(&mon->lock);
211	g_free(mon);
212
213	return G_SOURCE_REMOVE;
214	}
215
216	void
217	qemu_file_monitor_free(QFileMonitor *mon)
218	{
219	if (!mon) {
220	return;
221	}
222
223	qemu_mutex_lock(&mon->lock);
224	if (mon->fd != -1) {
225	qemu_set_fd_handler(mon->fd, NULL, NULL, NULL);
226	close(mon->fd);
227	mon->fd = -1;
228	}
229	qemu_mutex_unlock(&mon->lock);
230
231	/*
232	* Can't free it yet, because another thread
233	* may be running event loop, so the inotify
234	* callback might be pending. Using an idle
235	* source ensures we'll only free after the
236	* pending callback is done
237	*/
238	g_idle_add((GSourceFunc)qemu_file_monitor_free_idle, mon);
239	}
240
b4682a63	241	int64_t
90e33dfe DB	242	qemu_file_monitor_add_watch(QFileMonitor *mon,
	243	const char *dirpath,
	244	const char *filename,
	245	QFileMonitorHandler cb,
	246	void *opaque,
	247	Error **errp)
	248	{
	249	QFileMonitorDir *dir;
	250	QFileMonitorWatch watch;
b4682a63	251	int64_t ret = -1;
90e33dfe DB	252
	253	qemu_mutex_lock(&mon->lock);
	254	dir = g_hash_table_lookup(mon->dirs, dirpath);
	255	if (!dir) {
	256	int rv = inotify_add_watch(mon->fd, dirpath,
	257	IN_CREATE \| IN_DELETE \| IN_MODIFY \|
	258	IN_MOVED_TO \| IN_MOVED_FROM \| IN_ATTRIB);
	259
	260	if (rv < 0) {
	261	error_setg_errno(errp, errno, "Unable to watch '%s'", dirpath);
	262	goto cleanup;
	263	}
	264
	265	trace_qemu_file_monitor_enable_watch(mon, dirpath, rv);
	266
	267	dir = g_new0(QFileMonitorDir, 1);
	268	dir->path = g_strdup(dirpath);
b4682a63	269	dir->inotify_id = rv;
90e33dfe DB	270	dir->watches = g_array_new(FALSE, TRUE, sizeof(QFileMonitorWatch));
	271
	272	g_hash_table_insert(mon->dirs, dir->path, dir);
	273	g_hash_table_insert(mon->idmap, GINT_TO_POINTER(rv), dir);
	274
	275	if (g_hash_table_size(mon->dirs) == 1) {
	276	qemu_set_fd_handler(mon->fd, qemu_file_monitor_watch, NULL, mon);
	277	}
	278	}
	279
b4682a63	280	watch.id = (((int64_t)dir->inotify_id) << 32) \| dir->next_file_id++;
90e33dfe DB	281	watch.filename = g_strdup(filename);
	282	watch.cb = cb;
	283	watch.opaque = opaque;
	284
	285	g_array_append_val(dir->watches, watch);
	286
	287	trace_qemu_file_monitor_add_watch(mon, dirpath,
	288	filename ? filename : "<none>",
	289	cb, opaque, watch.id);
	290
	291	ret = watch.id;
	292
	293	cleanup:
	294	qemu_mutex_unlock(&mon->lock);
	295	return ret;
	296	}
	297
	298
	299	void qemu_file_monitor_remove_watch(QFileMonitor *mon,
	300	const char *dirpath,
b4682a63	301	int64_t id)
90e33dfe DB	302	{
	303	QFileMonitorDir *dir;
	304	gsize i;
	305
	306	qemu_mutex_lock(&mon->lock);
	307
	308	trace_qemu_file_monitor_remove_watch(mon, dirpath, id);
	309
	310	dir = g_hash_table_lookup(mon->dirs, dirpath);
	311	if (!dir) {
	312	goto cleanup;
	313	}
	314
	315	for (i = 0; i < dir->watches->len; i++) {
	316	QFileMonitorWatch *watch = &g_array_index(dir->watches,
	317	QFileMonitorWatch, i);
	318	if (watch->id == id) {
	319	g_free(watch->filename);
	320	g_array_remove_index(dir->watches, i);
	321	break;
	322	}
	323	}
	324
	325	if (dir->watches->len == 0) {
b4682a63 DB	326	inotify_rm_watch(mon->fd, dir->inotify_id);
b4682a63 DB	327	trace_qemu_file_monitor_disable_watch(mon, dir->path, dir->inotify_id);
90e33dfe	328
b4682a63	329	g_hash_table_remove(mon->idmap, GINT_TO_POINTER(dir->inotify_id));
90e33dfe DB	330	g_hash_table_remove(mon->dirs, dir->path);
	331
	332	if (g_hash_table_size(mon->dirs) == 0) {
	333	qemu_set_fd_handler(mon->fd, NULL, NULL, NULL);
	334	}
	335	}
	336
	337	cleanup:
	338	qemu_mutex_unlock(&mon->lock);
	339	}