1 /*
2  * Tests for util/filemonitor-*.c
3  *
4  * Copyright 2018 Red Hat, Inc.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program 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
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this library; if not, see <http://www.gnu.org/licenses/>.
18  *
19  */
20 
21 #include "qemu/osdep.h"
22 #include "qemu/main-loop.h"
23 #include "qapi/error.h"
24 #include "qemu/filemonitor.h"
25 
26 #include <glib/gstdio.h>
27 
28 #include <utime.h>
29 
30 enum {
31     QFILE_MONITOR_TEST_OP_ADD_WATCH,
32     QFILE_MONITOR_TEST_OP_DEL_WATCH,
33     QFILE_MONITOR_TEST_OP_EVENT,
34     QFILE_MONITOR_TEST_OP_CREATE,
35     QFILE_MONITOR_TEST_OP_APPEND,
36     QFILE_MONITOR_TEST_OP_TRUNC,
37     QFILE_MONITOR_TEST_OP_RENAME,
38     QFILE_MONITOR_TEST_OP_TOUCH,
39     QFILE_MONITOR_TEST_OP_UNLINK,
40     QFILE_MONITOR_TEST_OP_MKDIR,
41     QFILE_MONITOR_TEST_OP_RMDIR,
42 };
43 
44 typedef struct {
45     int type;
46     const char *filesrc;
47     const char *filedst;
48     int64_t *watchid;
49     int eventid;
50     /*
51      * Only valid with OP_EVENT - this event might be
52      * swapped with the next OP_EVENT
53      */
54     bool swapnext;
55 } QFileMonitorTestOp;
56 
57 typedef struct {
58     int64_t id;
59     QFileMonitorEvent event;
60     char *filename;
61 } QFileMonitorTestRecord;
62 
63 
64 typedef struct {
65     QemuMutex lock;
66     GList *records;
67 } QFileMonitorTestData;
68 
69 static QemuMutex evlock;
70 static bool evstopping;
71 static bool evrunning;
72 static bool debug;
73 
74 /*
75  * Main function for a background thread that is
76  * running the event loop during the test
77  */
78 static void *
79 qemu_file_monitor_test_event_loop(void *opaque G_GNUC_UNUSED)
80 {
81     qemu_mutex_lock(&evlock);
82 
83     while (!evstopping) {
84         qemu_mutex_unlock(&evlock);
85         main_loop_wait(true);
86         qemu_mutex_lock(&evlock);
87     }
88 
89     evrunning = false;
90     qemu_mutex_unlock(&evlock);
91     return NULL;
92 }
93 
94 
95 /*
96  * File monitor event handler which simply maintains
97  * an ordered list of all events that it receives
98  */
99 static void
100 qemu_file_monitor_test_handler(int64_t id,
101                                QFileMonitorEvent event,
102                                const char *filename,
103                                void *opaque)
104 {
105     QFileMonitorTestData *data = opaque;
106     QFileMonitorTestRecord *rec = g_new0(QFileMonitorTestRecord, 1);
107 
108     if (debug) {
109         g_printerr("Queue event id %" PRIx64 " event %d file %s\n",
110                    id, event, filename);
111     }
112     rec->id = id;
113     rec->event = event;
114     rec->filename = g_strdup(filename);
115 
116     qemu_mutex_lock(&data->lock);
117     data->records = g_list_append(data->records, rec);
118     qemu_mutex_unlock(&data->lock);
119 }
120 
121 
122 static void
123 qemu_file_monitor_test_record_free(QFileMonitorTestRecord *rec)
124 {
125     g_free(rec->filename);
126     g_free(rec);
127 }
128 
129 
130 /*
131  * Get the next event record that has been received by
132  * the file monitor event handler. Since events are
133  * emitted in the background thread running the event
134  * loop, we can't assume there is a record available
135  * immediately. Thus we will sleep for up to 5 seconds
136  * to wait for the event to be queued for us.
137  */
138 static QFileMonitorTestRecord *
139 qemu_file_monitor_test_next_record(QFileMonitorTestData *data,
140                                    QFileMonitorTestRecord *pushback)
141 {
142     GTimer *timer = g_timer_new();
143     QFileMonitorTestRecord *record = NULL;
144     GList *tmp;
145 
146     qemu_mutex_lock(&data->lock);
147     while (!data->records && g_timer_elapsed(timer, NULL) < 5) {
148         qemu_mutex_unlock(&data->lock);
149         usleep(10 * 1000);
150         qemu_mutex_lock(&data->lock);
151     }
152     if (data->records) {
153         record = data->records->data;
154         if (pushback) {
155             data->records->data = pushback;
156         } else {
157             tmp = data->records;
158             data->records = g_list_remove_link(data->records, tmp);
159             g_list_free(tmp);
160         }
161     } else if (pushback) {
162         qemu_file_monitor_test_record_free(pushback);
163     }
164     qemu_mutex_unlock(&data->lock);
165 
166     g_timer_destroy(timer);
167     return record;
168 }
169 
170 
171 /*
172  * Check whether the event record we retrieved matches
173  * data we were expecting to see for the event
174  */
175 static bool
176 qemu_file_monitor_test_expect(QFileMonitorTestData *data,
177                               int64_t id,
178                               QFileMonitorEvent event,
179                               const char *filename,
180                               bool swapnext)
181 {
182     QFileMonitorTestRecord *rec;
183     bool ret = false;
184 
185     rec = qemu_file_monitor_test_next_record(data, NULL);
186 
187  retry:
188     if (!rec) {
189         g_printerr("Missing event watch id %" PRIx64 " event %d file %s\n",
190                    id, event, filename);
191         return false;
192     }
193 
194     if (id != rec->id) {
195         if (swapnext) {
196             rec = qemu_file_monitor_test_next_record(data, rec);
197             swapnext = false;
198             goto retry;
199         }
200         g_printerr("Expected watch id %" PRIx64 " but got %" PRIx64 "\n",
201                    id, rec->id);
202         goto cleanup;
203     }
204 
205     if (event != rec->event) {
206         g_printerr("Expected event %d but got %d\n", event, rec->event);
207         goto cleanup;
208     }
209 
210     if (!g_str_equal(filename, rec->filename)) {
211         g_printerr("Expected filename %s but got %s\n",
212                    filename, rec->filename);
213         goto cleanup;
214     }
215 
216     ret = true;
217 
218  cleanup:
219     qemu_file_monitor_test_record_free(rec);
220     return ret;
221 }
222 
223 
224 static void
225 test_file_monitor_events(void)
226 {
227     int64_t watch0 = 0;
228     int64_t watch1 = 0;
229     int64_t watch2 = 0;
230     int64_t watch3 = 0;
231     int64_t watch4 = 0;
232     int64_t watch5 = 0;
233     QFileMonitorTestOp ops[] = {
234         { .type = QFILE_MONITOR_TEST_OP_ADD_WATCH,
235           .filesrc = NULL, .watchid = &watch0 },
236         { .type = QFILE_MONITOR_TEST_OP_ADD_WATCH,
237           .filesrc = "one.txt", .watchid = &watch1 },
238         { .type = QFILE_MONITOR_TEST_OP_ADD_WATCH,
239           .filesrc = "two.txt", .watchid = &watch2 },
240 
241 
242         { .type = QFILE_MONITOR_TEST_OP_CREATE,
243           .filesrc = "one.txt", },
244         { .type = QFILE_MONITOR_TEST_OP_EVENT,
245           .filesrc = "one.txt", .watchid = &watch0,
246           .eventid = QFILE_MONITOR_EVENT_CREATED },
247         { .type = QFILE_MONITOR_TEST_OP_EVENT,
248           .filesrc = "one.txt", .watchid = &watch1,
249           .eventid = QFILE_MONITOR_EVENT_CREATED },
250 
251 
252         { .type = QFILE_MONITOR_TEST_OP_CREATE,
253           .filesrc = "two.txt", },
254         { .type = QFILE_MONITOR_TEST_OP_EVENT,
255           .filesrc = "two.txt", .watchid = &watch0,
256           .eventid = QFILE_MONITOR_EVENT_CREATED },
257         { .type = QFILE_MONITOR_TEST_OP_EVENT,
258           .filesrc = "two.txt", .watchid = &watch2,
259           .eventid = QFILE_MONITOR_EVENT_CREATED },
260 
261 
262         { .type = QFILE_MONITOR_TEST_OP_CREATE,
263           .filesrc = "three.txt", },
264         { .type = QFILE_MONITOR_TEST_OP_EVENT,
265           .filesrc = "three.txt", .watchid = &watch0,
266           .eventid = QFILE_MONITOR_EVENT_CREATED },
267 
268 
269         { .type = QFILE_MONITOR_TEST_OP_UNLINK,
270           .filesrc = "three.txt", },
271         { .type = QFILE_MONITOR_TEST_OP_EVENT,
272           .filesrc = "three.txt", .watchid = &watch0,
273           .eventid = QFILE_MONITOR_EVENT_DELETED },
274 
275 
276         { .type = QFILE_MONITOR_TEST_OP_RENAME,
277           .filesrc = "one.txt", .filedst = "two.txt" },
278         { .type = QFILE_MONITOR_TEST_OP_EVENT,
279           .filesrc = "one.txt", .watchid = &watch0,
280           .eventid = QFILE_MONITOR_EVENT_DELETED },
281         { .type = QFILE_MONITOR_TEST_OP_EVENT,
282           .filesrc = "one.txt", .watchid = &watch1,
283           .eventid = QFILE_MONITOR_EVENT_DELETED },
284         { .type = QFILE_MONITOR_TEST_OP_EVENT,
285           .filesrc = "two.txt", .watchid = &watch0,
286           .eventid = QFILE_MONITOR_EVENT_CREATED },
287         { .type = QFILE_MONITOR_TEST_OP_EVENT,
288           .filesrc = "two.txt", .watchid = &watch2,
289           .eventid = QFILE_MONITOR_EVENT_CREATED },
290 
291 
292         { .type = QFILE_MONITOR_TEST_OP_APPEND,
293           .filesrc = "two.txt", },
294         { .type = QFILE_MONITOR_TEST_OP_EVENT,
295           .filesrc = "two.txt", .watchid = &watch0,
296           .eventid = QFILE_MONITOR_EVENT_MODIFIED },
297         { .type = QFILE_MONITOR_TEST_OP_EVENT,
298           .filesrc = "two.txt", .watchid = &watch2,
299           .eventid = QFILE_MONITOR_EVENT_MODIFIED },
300 
301 
302         { .type = QFILE_MONITOR_TEST_OP_TOUCH,
303           .filesrc = "two.txt", },
304         { .type = QFILE_MONITOR_TEST_OP_EVENT,
305           .filesrc = "two.txt", .watchid = &watch0,
306           .eventid = QFILE_MONITOR_EVENT_ATTRIBUTES },
307         { .type = QFILE_MONITOR_TEST_OP_EVENT,
308           .filesrc = "two.txt", .watchid = &watch2,
309           .eventid = QFILE_MONITOR_EVENT_ATTRIBUTES },
310 
311 
312         { .type = QFILE_MONITOR_TEST_OP_DEL_WATCH,
313           .filesrc = "one.txt", .watchid = &watch1 },
314         { .type = QFILE_MONITOR_TEST_OP_ADD_WATCH,
315           .filesrc = "one.txt", .watchid = &watch3 },
316         { .type = QFILE_MONITOR_TEST_OP_CREATE,
317           .filesrc = "one.txt", },
318         { .type = QFILE_MONITOR_TEST_OP_EVENT,
319           .filesrc = "one.txt", .watchid = &watch0,
320           .eventid = QFILE_MONITOR_EVENT_CREATED },
321         { .type = QFILE_MONITOR_TEST_OP_EVENT,
322           .filesrc = "one.txt", .watchid = &watch3,
323           .eventid = QFILE_MONITOR_EVENT_CREATED },
324 
325 
326         { .type = QFILE_MONITOR_TEST_OP_DEL_WATCH,
327           .filesrc = "one.txt", .watchid = &watch3 },
328         { .type = QFILE_MONITOR_TEST_OP_UNLINK,
329           .filesrc = "one.txt", },
330         { .type = QFILE_MONITOR_TEST_OP_EVENT,
331           .filesrc = "one.txt", .watchid = &watch0,
332           .eventid = QFILE_MONITOR_EVENT_DELETED },
333 
334 
335         { .type = QFILE_MONITOR_TEST_OP_MKDIR,
336           .filesrc = "fish", },
337         { .type = QFILE_MONITOR_TEST_OP_EVENT,
338           .filesrc = "fish", .watchid = &watch0,
339           .eventid = QFILE_MONITOR_EVENT_CREATED },
340 
341 
342         { .type = QFILE_MONITOR_TEST_OP_ADD_WATCH,
343           .filesrc = "fish/", .watchid = &watch4 },
344         { .type = QFILE_MONITOR_TEST_OP_ADD_WATCH,
345           .filesrc = "fish/one.txt", .watchid = &watch5 },
346         { .type = QFILE_MONITOR_TEST_OP_CREATE,
347           .filesrc = "fish/one.txt", },
348         { .type = QFILE_MONITOR_TEST_OP_EVENT,
349           .filesrc = "one.txt", .watchid = &watch4,
350           .eventid = QFILE_MONITOR_EVENT_CREATED },
351         { .type = QFILE_MONITOR_TEST_OP_EVENT,
352           .filesrc = "one.txt", .watchid = &watch5,
353           .eventid = QFILE_MONITOR_EVENT_CREATED },
354 
355 
356         { .type = QFILE_MONITOR_TEST_OP_DEL_WATCH,
357           .filesrc = "fish/one.txt", .watchid = &watch5 },
358         { .type = QFILE_MONITOR_TEST_OP_RENAME,
359           .filesrc = "fish/one.txt", .filedst = "two.txt", },
360         { .type = QFILE_MONITOR_TEST_OP_EVENT,
361           .filesrc = "one.txt", .watchid = &watch4,
362           .eventid = QFILE_MONITOR_EVENT_DELETED },
363 #ifdef __FreeBSD__
364         { .type = QFILE_MONITOR_TEST_OP_EVENT,
365           .filesrc = "two.txt", .watchid = &watch0,
366           .eventid = QFILE_MONITOR_EVENT_DELETED },
367         { .type = QFILE_MONITOR_TEST_OP_EVENT,
368           .filesrc = "two.txt", .watchid = &watch2,
369           .eventid = QFILE_MONITOR_EVENT_DELETED },
370 #endif
371         { .type = QFILE_MONITOR_TEST_OP_EVENT,
372           .filesrc = "two.txt", .watchid = &watch0,
373           .eventid = QFILE_MONITOR_EVENT_CREATED },
374         { .type = QFILE_MONITOR_TEST_OP_EVENT,
375           .filesrc = "two.txt", .watchid = &watch2,
376           .eventid = QFILE_MONITOR_EVENT_CREATED },
377 
378 
379         { .type = QFILE_MONITOR_TEST_OP_RMDIR,
380           .filesrc = "fish", },
381         { .type = QFILE_MONITOR_TEST_OP_EVENT,
382           .filesrc = "", .watchid = &watch4,
383           .eventid = QFILE_MONITOR_EVENT_IGNORED,
384           .swapnext = true },
385         { .type = QFILE_MONITOR_TEST_OP_EVENT,
386           .filesrc = "fish", .watchid = &watch0,
387           .eventid = QFILE_MONITOR_EVENT_DELETED },
388         { .type = QFILE_MONITOR_TEST_OP_DEL_WATCH,
389           .filesrc = "fish", .watchid = &watch4 },
390 
391 
392         { .type = QFILE_MONITOR_TEST_OP_UNLINK,
393           .filesrc = "two.txt", },
394         { .type = QFILE_MONITOR_TEST_OP_EVENT,
395           .filesrc = "two.txt", .watchid = &watch0,
396           .eventid = QFILE_MONITOR_EVENT_DELETED },
397         { .type = QFILE_MONITOR_TEST_OP_EVENT,
398           .filesrc = "two.txt", .watchid = &watch2,
399           .eventid = QFILE_MONITOR_EVENT_DELETED },
400 
401 
402         { .type = QFILE_MONITOR_TEST_OP_DEL_WATCH,
403           .filesrc = "two.txt", .watchid = &watch2 },
404         { .type = QFILE_MONITOR_TEST_OP_DEL_WATCH,
405           .filesrc = NULL, .watchid = &watch0 },
406     };
407     Error *local_err = NULL;
408     GError *gerr = NULL;
409     QFileMonitor *mon = qemu_file_monitor_new(&local_err);
410     QemuThread th;
411     GTimer *timer;
412     gchar *dir = NULL;
413     int err = -1;
414     gsize i;
415     char *pathsrc = NULL;
416     char *pathdst = NULL;
417     QFileMonitorTestData data;
418     GHashTable *ids = g_hash_table_new(g_int64_hash, g_int64_equal);
419     char *travis_arch;
420 
421     qemu_mutex_init(&data.lock);
422     data.records = NULL;
423 
424     /*
425      * This test does not work on Travis LXD containers since some
426      * syscalls are blocked in that environment.
427      */
428     travis_arch = getenv("TRAVIS_ARCH");
429     if (travis_arch && !g_str_equal(travis_arch, "x86_64")) {
430         g_test_skip("Test does not work on non-x86 Travis containers.");
431         return;
432     }
433 
434     /*
435      * The file monitor needs the main loop running in
436      * order to receive events from inotify. We must
437      * thus spawn a background thread to run an event
438      * loop impl, while this thread triggers the
439      * actual file operations we're testing
440      */
441     evrunning = 1;
442     evstopping = 0;
443     qemu_thread_create(&th, "event-loop",
444                        qemu_file_monitor_test_event_loop, NULL,
445                        QEMU_THREAD_JOINABLE);
446 
447     if (local_err) {
448         g_printerr("File monitoring not available: %s",
449                    error_get_pretty(local_err));
450         error_free(local_err);
451         return;
452     }
453 
454     dir = g_dir_make_tmp("test-util-filemonitor-XXXXXX",
455                          &gerr);
456     if (!dir) {
457         g_printerr("Unable to create tmp dir %s",
458                    gerr->message);
459         g_error_free(gerr);
460         abort();
461     }
462 
463     /*
464      * Run through the operation sequence validating events
465      * as we go
466      */
467     for (i = 0; i < G_N_ELEMENTS(ops); i++) {
468         const QFileMonitorTestOp *op = &(ops[i]);
469         int fd;
470         struct utimbuf ubuf;
471         char *watchdir;
472         const char *watchfile;
473 
474         pathsrc = g_strdup_printf("%s/%s", dir, op->filesrc);
475         if (op->filedst) {
476             pathdst = g_strdup_printf("%s/%s", dir, op->filedst);
477         }
478 
479         switch (op->type) {
480         case QFILE_MONITOR_TEST_OP_ADD_WATCH:
481             if (debug) {
482                 g_printerr("Add watch %s %s\n",
483                            dir, op->filesrc);
484             }
485             if (op->filesrc && strchr(op->filesrc, '/')) {
486                 watchdir = g_strdup_printf("%s/%s", dir, op->filesrc);
487                 watchfile = strrchr(watchdir, '/');
488                 *(char *)watchfile = '\0';
489                 watchfile++;
490                 if (*watchfile == '\0') {
491                     watchfile = NULL;
492                 }
493             } else {
494                 watchdir = g_strdup(dir);
495                 watchfile = op->filesrc;
496             }
497             *op->watchid =
498                 qemu_file_monitor_add_watch(mon,
499                                             watchdir,
500                                             watchfile,
501                                             qemu_file_monitor_test_handler,
502                                             &data,
503                                             &local_err);
504             g_free(watchdir);
505             if (*op->watchid < 0) {
506                 g_printerr("Unable to add watch %s",
507                            error_get_pretty(local_err));
508                 error_free(local_err);
509                 goto cleanup;
510             }
511             if (debug) {
512                 g_printerr("Watch ID %" PRIx64 "\n", *op->watchid);
513             }
514             if (g_hash_table_contains(ids, op->watchid)) {
515                 g_printerr("Watch ID %" PRIx64 "already exists", *op->watchid);
516                 goto cleanup;
517             }
518             g_hash_table_add(ids, op->watchid);
519             break;
520         case QFILE_MONITOR_TEST_OP_DEL_WATCH:
521             if (debug) {
522                 g_printerr("Del watch %s %" PRIx64 "\n", dir, *op->watchid);
523             }
524             if (op->filesrc && strchr(op->filesrc, '/')) {
525                 watchdir = g_strdup_printf("%s/%s", dir, op->filesrc);
526                 watchfile = strrchr(watchdir, '/');
527                 *(char *)watchfile = '\0';
528             } else {
529                 watchdir = g_strdup(dir);
530             }
531             g_hash_table_remove(ids, op->watchid);
532             qemu_file_monitor_remove_watch(mon,
533                                            watchdir,
534                                            *op->watchid);
535             g_free(watchdir);
536             break;
537         case QFILE_MONITOR_TEST_OP_EVENT:
538             if (debug) {
539                 g_printerr("Event id=%" PRIx64 " event=%d file=%s\n",
540                            *op->watchid, op->eventid, op->filesrc);
541             }
542             if (!qemu_file_monitor_test_expect(&data, *op->watchid,
543                                                op->eventid, op->filesrc,
544                                                op->swapnext))
545                 goto cleanup;
546             break;
547         case QFILE_MONITOR_TEST_OP_CREATE:
548             if (debug) {
549                 g_printerr("Create %s\n", pathsrc);
550             }
551             fd = open(pathsrc, O_WRONLY | O_CREAT, 0700);
552             if (fd < 0) {
553                 g_printerr("Unable to create %s: %s",
554                            pathsrc, strerror(errno));
555                 goto cleanup;
556             }
557             close(fd);
558             break;
559 
560         case QFILE_MONITOR_TEST_OP_APPEND:
561             if (debug) {
562                 g_printerr("Append %s\n", pathsrc);
563             }
564             fd = open(pathsrc, O_WRONLY | O_APPEND, 0700);
565             if (fd < 0) {
566                 g_printerr("Unable to open %s: %s",
567                            pathsrc, strerror(errno));
568                 goto cleanup;
569             }
570 
571             if (write(fd, "Hello World", 10) != 10) {
572                 g_printerr("Unable to write %s: %s",
573                            pathsrc, strerror(errno));
574                 close(fd);
575                 goto cleanup;
576             }
577             close(fd);
578             break;
579 
580         case QFILE_MONITOR_TEST_OP_TRUNC:
581             if (debug) {
582                 g_printerr("Truncate %s\n", pathsrc);
583             }
584             if (truncate(pathsrc, 4) < 0) {
585                 g_printerr("Unable to truncate %s: %s",
586                            pathsrc, strerror(errno));
587                 goto cleanup;
588             }
589             break;
590 
591         case QFILE_MONITOR_TEST_OP_RENAME:
592             if (debug) {
593                 g_printerr("Rename %s -> %s\n", pathsrc, pathdst);
594             }
595             if (rename(pathsrc, pathdst) < 0) {
596                 g_printerr("Unable to rename %s to %s: %s",
597                            pathsrc, pathdst, strerror(errno));
598                 goto cleanup;
599             }
600             break;
601 
602         case QFILE_MONITOR_TEST_OP_UNLINK:
603             if (debug) {
604                 g_printerr("Unlink %s\n", pathsrc);
605             }
606             if (unlink(pathsrc) < 0) {
607                 g_printerr("Unable to unlink %s: %s",
608                            pathsrc, strerror(errno));
609                 goto cleanup;
610             }
611             break;
612 
613         case QFILE_MONITOR_TEST_OP_TOUCH:
614             if (debug) {
615                 g_printerr("Touch %s\n", pathsrc);
616             }
617             ubuf.actime = 1024;
618             ubuf.modtime = 1025;
619             if (utime(pathsrc, &ubuf) < 0) {
620                 g_printerr("Unable to touch %s: %s",
621                            pathsrc, strerror(errno));
622                 goto cleanup;
623             }
624             break;
625 
626         case QFILE_MONITOR_TEST_OP_MKDIR:
627             if (debug) {
628                 g_printerr("Mkdir %s\n", pathsrc);
629             }
630             if (g_mkdir_with_parents(pathsrc, 0700) < 0) {
631                 g_printerr("Unable to mkdir %s: %s",
632                            pathsrc, strerror(errno));
633                 goto cleanup;
634             }
635             break;
636 
637         case QFILE_MONITOR_TEST_OP_RMDIR:
638             if (debug) {
639                 g_printerr("Rmdir %s\n", pathsrc);
640             }
641             if (rmdir(pathsrc) < 0) {
642                 g_printerr("Unable to rmdir %s: %s",
643                            pathsrc, strerror(errno));
644                 goto cleanup;
645             }
646             break;
647 
648         default:
649             g_assert_not_reached();
650         }
651 
652         g_free(pathsrc);
653         g_free(pathdst);
654         pathsrc = pathdst = NULL;
655     }
656 
657     g_assert_cmpint(g_hash_table_size(ids), ==, 0);
658 
659     err = 0;
660 
661  cleanup:
662     g_free(pathsrc);
663     g_free(pathdst);
664 
665     qemu_mutex_lock(&evlock);
666     evstopping = 1;
667     timer = g_timer_new();
668     while (evrunning && g_timer_elapsed(timer, NULL) < 5) {
669         qemu_mutex_unlock(&evlock);
670         usleep(10 * 1000);
671         qemu_mutex_lock(&evlock);
672     }
673     qemu_mutex_unlock(&evlock);
674 
675     if (g_timer_elapsed(timer, NULL) >= 5) {
676         g_printerr("Event loop failed to quit after 5 seconds\n");
677     }
678     g_timer_destroy(timer);
679 
680     qemu_file_monitor_free(mon);
681     g_list_foreach(data.records,
682                    (GFunc)qemu_file_monitor_test_record_free, NULL);
683     g_list_free(data.records);
684     qemu_mutex_destroy(&data.lock);
685     if (dir) {
686         for (i = 0; i < G_N_ELEMENTS(ops); i++) {
687             const QFileMonitorTestOp *op = &(ops[i]);
688             char *path = g_strdup_printf("%s/%s",
689                                          dir, op->filesrc);
690             if (op->type == QFILE_MONITOR_TEST_OP_MKDIR) {
691                 rmdir(path);
692                 g_free(path);
693             } else {
694                 unlink(path);
695                 g_free(path);
696                 if (op->filedst) {
697                     path = g_strdup_printf("%s/%s",
698                                            dir, op->filedst);
699                     unlink(path);
700                     g_free(path);
701                 }
702             }
703         }
704         if (rmdir(dir) < 0) {
705             g_printerr("Failed to remove %s: %s\n",
706                        dir, strerror(errno));
707             abort();
708         }
709     }
710     g_hash_table_unref(ids);
711     g_free(dir);
712     g_assert(err == 0);
713 }
714 
715 
716 int main(int argc, char **argv)
717 {
718     g_test_init(&argc, &argv, NULL);
719 
720     qemu_init_main_loop(&error_abort);
721 
722     qemu_mutex_init(&evlock);
723 
724     debug = getenv("FILEMONITOR_DEBUG") != NULL;
725     g_test_add_func("/util/filemonitor", test_file_monitor_events);
726 
727     return g_test_run();
728 }
729