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.1 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; 32 QemuMutex lock; /* protects dirs & idmap */ 33 GHashTable *dirs; /* dirname => QFileMonitorDir */ 34 GHashTable *idmap; /* inotify ID => dirname */ 35 }; 36 37 38 typedef struct { 39 int64_t id; /* watch ID */ 40 char *filename; /* optional filter */ 41 QFileMonitorHandler cb; 42 void *opaque; 43 } QFileMonitorWatch; 44 45 46 typedef struct { 47 char *path; 48 int inotify_id; /* inotify ID */ 49 int next_file_id; /* file ID counter */ 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 const char *name; 85 QFileMonitorDir *dir; 86 uint32_t iev; 87 int qev; 88 gsize i; 89 struct inotify_event *ev = (struct inotify_event *)(buf + used); 90 91 /* 92 * We trust the kernel to provide valid buffer with complete event 93 * records. 94 */ 95 assert(len - used >= sizeof(struct inotify_event)); 96 assert(len - used - sizeof(struct inotify_event) >= ev->len); 97 98 name = ev->len ? ev->name : ""; 99 dir = g_hash_table_lookup(mon->idmap, GINT_TO_POINTER(ev->wd)); 100 iev = ev->mask & 101 (IN_CREATE | IN_MODIFY | IN_DELETE | IN_IGNORED | 102 IN_MOVED_TO | IN_MOVED_FROM | IN_ATTRIB); 103 104 used += sizeof(struct inotify_event) + ev->len; 105 106 if (!dir) { 107 continue; 108 } 109 110 /* 111 * During a rename operation, the old name gets 112 * IN_MOVED_FROM and the new name gets IN_MOVED_TO. 113 * To simplify life for callers, we turn these into 114 * DELETED and CREATED events 115 */ 116 switch (iev) { 117 case IN_CREATE: 118 case IN_MOVED_TO: 119 qev = QFILE_MONITOR_EVENT_CREATED; 120 break; 121 case IN_MODIFY: 122 qev = QFILE_MONITOR_EVENT_MODIFIED; 123 break; 124 case IN_DELETE: 125 case IN_MOVED_FROM: 126 qev = QFILE_MONITOR_EVENT_DELETED; 127 break; 128 case IN_ATTRIB: 129 qev = QFILE_MONITOR_EVENT_ATTRIBUTES; 130 break; 131 case IN_IGNORED: 132 qev = QFILE_MONITOR_EVENT_IGNORED; 133 break; 134 default: 135 g_assert_not_reached(); 136 } 137 138 trace_qemu_file_monitor_event(mon, dir->path, name, ev->mask, 139 dir->inotify_id); 140 for (i = 0; i < dir->watches->len; i++) { 141 QFileMonitorWatch *watch = &g_array_index(dir->watches, 142 QFileMonitorWatch, 143 i); 144 145 if (watch->filename == NULL || 146 (name && g_str_equal(watch->filename, name))) { 147 trace_qemu_file_monitor_dispatch(mon, dir->path, name, 148 qev, watch->cb, 149 watch->opaque, watch->id); 150 watch->cb(watch->id, qev, name, watch->opaque); 151 } 152 } 153 } 154 155 cleanup: 156 qemu_mutex_unlock(&mon->lock); 157 } 158 159 160 static void 161 qemu_file_monitor_dir_free(void *data) 162 { 163 QFileMonitorDir *dir = data; 164 gsize i; 165 166 for (i = 0; i < dir->watches->len; i++) { 167 QFileMonitorWatch *watch = &g_array_index(dir->watches, 168 QFileMonitorWatch, i); 169 g_free(watch->filename); 170 } 171 g_array_unref(dir->watches); 172 g_free(dir->path); 173 g_free(dir); 174 } 175 176 177 QFileMonitor * 178 qemu_file_monitor_new(Error **errp) 179 { 180 int fd; 181 QFileMonitor *mon; 182 183 fd = inotify_init1(IN_NONBLOCK); 184 if (fd < 0) { 185 error_setg_errno(errp, errno, 186 "Unable to initialize inotify"); 187 return NULL; 188 } 189 190 mon = g_new0(QFileMonitor, 1); 191 qemu_mutex_init(&mon->lock); 192 mon->fd = fd; 193 194 mon->dirs = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, 195 qemu_file_monitor_dir_free); 196 mon->idmap = g_hash_table_new(g_direct_hash, g_direct_equal); 197 198 trace_qemu_file_monitor_new(mon, mon->fd); 199 200 return mon; 201 } 202 203 static gboolean 204 qemu_file_monitor_free_idle(void *opaque) 205 { 206 QFileMonitor *mon = opaque; 207 208 if (!mon) { 209 return G_SOURCE_REMOVE; 210 } 211 212 qemu_mutex_lock(&mon->lock); 213 214 g_hash_table_unref(mon->idmap); 215 g_hash_table_unref(mon->dirs); 216 217 qemu_mutex_unlock(&mon->lock); 218 219 qemu_mutex_destroy(&mon->lock); 220 g_free(mon); 221 222 return G_SOURCE_REMOVE; 223 } 224 225 void 226 qemu_file_monitor_free(QFileMonitor *mon) 227 { 228 if (!mon) { 229 return; 230 } 231 232 qemu_mutex_lock(&mon->lock); 233 if (mon->fd != -1) { 234 qemu_set_fd_handler(mon->fd, NULL, NULL, NULL); 235 close(mon->fd); 236 mon->fd = -1; 237 } 238 qemu_mutex_unlock(&mon->lock); 239 240 /* 241 * Can't free it yet, because another thread 242 * may be running event loop, so the inotify 243 * callback might be pending. Using an idle 244 * source ensures we'll only free after the 245 * pending callback is done 246 */ 247 g_idle_add((GSourceFunc)qemu_file_monitor_free_idle, mon); 248 } 249 250 int64_t 251 qemu_file_monitor_add_watch(QFileMonitor *mon, 252 const char *dirpath, 253 const char *filename, 254 QFileMonitorHandler cb, 255 void *opaque, 256 Error **errp) 257 { 258 QFileMonitorDir *dir; 259 QFileMonitorWatch watch; 260 int64_t ret = -1; 261 262 qemu_mutex_lock(&mon->lock); 263 dir = g_hash_table_lookup(mon->dirs, dirpath); 264 if (!dir) { 265 int rv = inotify_add_watch(mon->fd, dirpath, 266 IN_CREATE | IN_DELETE | IN_MODIFY | 267 IN_MOVED_TO | IN_MOVED_FROM | IN_ATTRIB); 268 269 if (rv < 0) { 270 error_setg_errno(errp, errno, "Unable to watch '%s'", dirpath); 271 goto cleanup; 272 } 273 274 trace_qemu_file_monitor_enable_watch(mon, dirpath, rv); 275 276 dir = g_new0(QFileMonitorDir, 1); 277 dir->path = g_strdup(dirpath); 278 dir->inotify_id = rv; 279 dir->watches = g_array_new(FALSE, TRUE, sizeof(QFileMonitorWatch)); 280 281 g_hash_table_insert(mon->dirs, dir->path, dir); 282 g_hash_table_insert(mon->idmap, GINT_TO_POINTER(rv), dir); 283 284 if (g_hash_table_size(mon->dirs) == 1) { 285 qemu_set_fd_handler(mon->fd, qemu_file_monitor_watch, NULL, mon); 286 } 287 } 288 289 watch.id = (((int64_t)dir->inotify_id) << 32) | dir->next_file_id++; 290 watch.filename = g_strdup(filename); 291 watch.cb = cb; 292 watch.opaque = opaque; 293 294 g_array_append_val(dir->watches, watch); 295 296 trace_qemu_file_monitor_add_watch(mon, dirpath, 297 filename ? filename : "<none>", 298 cb, opaque, watch.id); 299 300 ret = watch.id; 301 302 cleanup: 303 qemu_mutex_unlock(&mon->lock); 304 return ret; 305 } 306 307 308 void qemu_file_monitor_remove_watch(QFileMonitor *mon, 309 const char *dirpath, 310 int64_t id) 311 { 312 QFileMonitorDir *dir; 313 gsize i; 314 315 qemu_mutex_lock(&mon->lock); 316 317 trace_qemu_file_monitor_remove_watch(mon, dirpath, id); 318 319 dir = g_hash_table_lookup(mon->dirs, dirpath); 320 if (!dir) { 321 goto cleanup; 322 } 323 324 for (i = 0; i < dir->watches->len; i++) { 325 QFileMonitorWatch *watch = &g_array_index(dir->watches, 326 QFileMonitorWatch, i); 327 if (watch->id == id) { 328 g_free(watch->filename); 329 g_array_remove_index(dir->watches, i); 330 break; 331 } 332 } 333 334 if (dir->watches->len == 0) { 335 inotify_rm_watch(mon->fd, dir->inotify_id); 336 trace_qemu_file_monitor_disable_watch(mon, dir->path, dir->inotify_id); 337 338 g_hash_table_remove(mon->idmap, GINT_TO_POINTER(dir->inotify_id)); 339 g_hash_table_remove(mon->dirs, dir->path); 340 341 if (g_hash_table_size(mon->dirs) == 0) { 342 qemu_set_fd_handler(mon->fd, NULL, NULL, NULL); 343 } 344 } 345 346 cleanup: 347 qemu_mutex_unlock(&mon->lock); 348 } 349