]> git.proxmox.com Git - mirror_qemu.git/blame - tests/test-aio.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
virtio-balloon: convert VMSTATE_VIRTIO_DEVICE
[mirror_qemu.git] / tests / test-aio.c
CommitLineData
b2ea25d7
PB		 1/*
2 * AioContext tests
3 *
4 * Copyright Red Hat, Inc. 2012
5 *
6 * Authors:
7 * Paolo Bonzini <pbonzini@redhat.com>
8 *
9 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
10 * See the COPYING.LIB file in the top-level directory.
11 */
12
681c28a3 13#include "qemu/osdep.h"
737e150e 14#include "block/aio.h"
da34e65c 15#include "qapi/error.h"
dae21b98 16#include "qemu/timer.h"
a94a3fac 17#include "qemu/sockets.h"
2f78e491 18#include "qemu/error-report.h"
b2ea25d7 19
748bfb4e 20static AioContext *ctx;
b2ea25d7 21
24d1a6d9
SH		 22typedef struct {
23 EventNotifier e;
24 int n;
25 int active;
26 bool auto_set;
27} EventNotifierTestData;
28
24d1a6d9
SH		 29/* Wait until event notifier becomes inactive */
30static void wait_until_inactive(EventNotifierTestData *data)
31{
32 while (data->active > 0) {
33 aio_poll(ctx, true);
34 }
35}
36
b2ea25d7
PB		 37/* Simple callbacks for testing. */
38
39typedef struct {
40 QEMUBH *bh;
41 int n;
42 int max;
43} BHTestData;
44
b53edf97
AB		 45typedef struct {
46 QEMUTimer timer;
47 QEMUClockType clock_type;
48 int n;
49 int max;
50 int64_t ns;
51 AioContext *ctx;
52} TimerTestData;
53
b2ea25d7
PB		 54static void bh_test_cb(void *opaque)
55{
56 BHTestData *data = opaque;
57 if (++data->n < data->max) {
58 qemu_bh_schedule(data->bh);
59 }
60}
61
b53edf97
AB		 62static void timer_test_cb(void *opaque)
63{
64 TimerTestData *data = opaque;
65 if (++data->n < data->max) {
66 timer_mod(&data->timer,
67 qemu_clock_get_ns(data->clock_type) + data->ns);
68 }
69}
70
363285d4 71static void dummy_io_handler_read(EventNotifier *e)
b53edf97
AB		 72{
73}
74
b2ea25d7
PB		 75static void bh_delete_cb(void *opaque)
76{
77 BHTestData *data = opaque;
78 if (++data->n < data->max) {
79 qemu_bh_schedule(data->bh);
80 } else {
81 qemu_bh_delete(data->bh);
82 data->bh = NULL;
83 }
84}
85
b2ea25d7
PB		 86static void event_ready_cb(EventNotifier *e)
87{
88 EventNotifierTestData *data = container_of(e, EventNotifierTestData, e);
89 g_assert(event_notifier_test_and_clear(e));
90 data->n++;
91 if (data->active > 0) {
92 data->active--;
93 }
94 if (data->auto_set && data->active) {
95 event_notifier_set(e);
96 }
97}
98
99/* Tests using aio_*. */
100
98563fc3
SH		 101typedef struct {
102 QemuMutex start_lock;
103 bool thread_acquired;
104} AcquireTestData;
105
106static void *test_acquire_thread(void *opaque)
107{
108 AcquireTestData *data = opaque;
109
110 /* Wait for other thread to let us start */
111 qemu_mutex_lock(&data->start_lock);
112 qemu_mutex_unlock(&data->start_lock);
113
114 aio_context_acquire(ctx);
115 aio_context_release(ctx);
116
117 data->thread_acquired = true; /* success, we got here */
118
119 return NULL;
120}
121
dca21ef2
FZ		 122static void set_event_notifier(AioContext *ctx, EventNotifier *notifier,
123 EventNotifierHandler *handler)
124{
125 aio_set_event_notifier(ctx, notifier, false, handler);
126}
127
da5e1de9 128static void dummy_notifier_read(EventNotifier *unused)
98563fc3 129{
da5e1de9 130 g_assert(false); /* should never be invoked */
98563fc3
SH		 131}
132
133static void test_acquire(void)
134{
135 QemuThread thread;
da5e1de9 136 EventNotifier notifier;
98563fc3
SH		 137 AcquireTestData data;
138
139 /* Dummy event notifier ensures aio_poll() will block */
da5e1de9 140 event_notifier_init(&notifier, false);
dca21ef2 141 set_event_notifier(ctx, &notifier, dummy_notifier_read);
98563fc3
SH		 142 g_assert(!aio_poll(ctx, false)); /* consume aio_notify() */
143
144 qemu_mutex_init(&data.start_lock);
145 qemu_mutex_lock(&data.start_lock);
146 data.thread_acquired = false;
147
148 qemu_thread_create(&thread, "test_acquire_thread",
149 test_acquire_thread,
150 &data, QEMU_THREAD_JOINABLE);
151
152 /* Block in aio_poll(), let other thread kick us and acquire context */
153 aio_context_acquire(ctx);
154 qemu_mutex_unlock(&data.start_lock); /* let the thread run */
da5e1de9 155 g_assert(!aio_poll(ctx, true));
98563fc3
SH		 156 aio_context_release(ctx);
157
158 qemu_thread_join(&thread);
dca21ef2 159 set_event_notifier(ctx, &notifier, NULL);
da5e1de9 160 event_notifier_cleanup(&notifier);
98563fc3
SH		 161
162 g_assert(data.thread_acquired);
163}
164
b2ea25d7
PB		 165static void test_bh_schedule(void)
166{
167 BHTestData data = { .n = 0 };
168 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
169
170 qemu_bh_schedule(data.bh);
171 g_assert_cmpint(data.n, ==, 0);
172
173 g_assert(aio_poll(ctx, true));
174 g_assert_cmpint(data.n, ==, 1);
175
176 g_assert(!aio_poll(ctx, false));
177 g_assert_cmpint(data.n, ==, 1);
178 qemu_bh_delete(data.bh);
179}
180
181static void test_bh_schedule10(void)
182{
183 BHTestData data = { .n = 0, .max = 10 };
184 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
185
186 qemu_bh_schedule(data.bh);
187 g_assert_cmpint(data.n, ==, 0);
188
189 g_assert(aio_poll(ctx, false));
190 g_assert_cmpint(data.n, ==, 1);
191
192 g_assert(aio_poll(ctx, true));
193 g_assert_cmpint(data.n, ==, 2);
194
acfb23ad
PB		 195 while (data.n < 10) {
196 aio_poll(ctx, true);
197 }
b2ea25d7
PB		 198 g_assert_cmpint(data.n, ==, 10);
199
200 g_assert(!aio_poll(ctx, false));
201 g_assert_cmpint(data.n, ==, 10);
202 qemu_bh_delete(data.bh);
203}
204
205static void test_bh_cancel(void)
206{
207 BHTestData data = { .n = 0 };
208 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
209
210 qemu_bh_schedule(data.bh);
211 g_assert_cmpint(data.n, ==, 0);
212
213 qemu_bh_cancel(data.bh);
214 g_assert_cmpint(data.n, ==, 0);
215
216 g_assert(!aio_poll(ctx, false));
217 g_assert_cmpint(data.n, ==, 0);
218 qemu_bh_delete(data.bh);
219}
220
221static void test_bh_delete(void)
222{
223 BHTestData data = { .n = 0 };
224 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
225
226 qemu_bh_schedule(data.bh);
227 g_assert_cmpint(data.n, ==, 0);
228
229 qemu_bh_delete(data.bh);
230 g_assert_cmpint(data.n, ==, 0);
231
232 g_assert(!aio_poll(ctx, false));
233 g_assert_cmpint(data.n, ==, 0);
234}
235
236static void test_bh_delete_from_cb(void)
237{
238 BHTestData data1 = { .n = 0, .max = 1 };
239
240 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
241
242 qemu_bh_schedule(data1.bh);
243 g_assert_cmpint(data1.n, ==, 0);
244
acfb23ad
PB		 245 while (data1.n < data1.max) {
246 aio_poll(ctx, true);
247 }
b2ea25d7
PB		 248 g_assert_cmpint(data1.n, ==, data1.max);
249 g_assert(data1.bh == NULL);
250
251 g_assert(!aio_poll(ctx, false));
b2ea25d7
PB		 252}
253
254static void test_bh_delete_from_cb_many(void)
255{
256 BHTestData data1 = { .n = 0, .max = 1 };
257 BHTestData data2 = { .n = 0, .max = 3 };
258 BHTestData data3 = { .n = 0, .max = 2 };
259 BHTestData data4 = { .n = 0, .max = 4 };
260
261 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
262 data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2);
263 data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3);
264 data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4);
265
266 qemu_bh_schedule(data1.bh);
267 qemu_bh_schedule(data2.bh);
268 qemu_bh_schedule(data3.bh);
269 qemu_bh_schedule(data4.bh);
270 g_assert_cmpint(data1.n, ==, 0);
271 g_assert_cmpint(data2.n, ==, 0);
272 g_assert_cmpint(data3.n, ==, 0);
273 g_assert_cmpint(data4.n, ==, 0);
274
275 g_assert(aio_poll(ctx, false));
276 g_assert_cmpint(data1.n, ==, 1);
277 g_assert_cmpint(data2.n, ==, 1);
278 g_assert_cmpint(data3.n, ==, 1);
279 g_assert_cmpint(data4.n, ==, 1);
280 g_assert(data1.bh == NULL);
281
acfb23ad
PB		 282 while (data1.n < data1.max ||
283 data2.n < data2.max ||
284 data3.n < data3.max ||
285 data4.n < data4.max) {
286 aio_poll(ctx, true);
287 }
b2ea25d7
PB		 288 g_assert_cmpint(data1.n, ==, data1.max);
289 g_assert_cmpint(data2.n, ==, data2.max);
290 g_assert_cmpint(data3.n, ==, data3.max);
291 g_assert_cmpint(data4.n, ==, data4.max);
292 g_assert(data1.bh == NULL);
293 g_assert(data2.bh == NULL);
294 g_assert(data3.bh == NULL);
295 g_assert(data4.bh == NULL);
296}
297
298static void test_bh_flush(void)
299{
300 BHTestData data = { .n = 0 };
301 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
302
303 qemu_bh_schedule(data.bh);
304 g_assert_cmpint(data.n, ==, 0);
305
acfb23ad 306 g_assert(aio_poll(ctx, true));
b2ea25d7
PB		 307 g_assert_cmpint(data.n, ==, 1);
308
309 g_assert(!aio_poll(ctx, false));
310 g_assert_cmpint(data.n, ==, 1);
311 qemu_bh_delete(data.bh);
312}
313
314static void test_set_event_notifier(void)
315{
316 EventNotifierTestData data = { .n = 0, .active = 0 };
317 event_notifier_init(&data.e, false);
dca21ef2 318 set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 319 g_assert(!aio_poll(ctx, false));
320 g_assert_cmpint(data.n, ==, 0);
321
dca21ef2 322 set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 323 g_assert(!aio_poll(ctx, false));
324 g_assert_cmpint(data.n, ==, 0);
325 event_notifier_cleanup(&data.e);
326}
327
328static void test_wait_event_notifier(void)
329{
330 EventNotifierTestData data = { .n = 0, .active = 1 };
331 event_notifier_init(&data.e, false);
dca21ef2 332 set_event_notifier(ctx, &data.e, event_ready_cb);
12d69ac0 333 while (aio_poll(ctx, false));
b2ea25d7
PB		 334 g_assert_cmpint(data.n, ==, 0);
335 g_assert_cmpint(data.active, ==, 1);
336
337 event_notifier_set(&data.e);
338 g_assert(aio_poll(ctx, false));
339 g_assert_cmpint(data.n, ==, 1);
340 g_assert_cmpint(data.active, ==, 0);
341
342 g_assert(!aio_poll(ctx, false));
343 g_assert_cmpint(data.n, ==, 1);
344 g_assert_cmpint(data.active, ==, 0);
345
dca21ef2 346 set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 347 g_assert(!aio_poll(ctx, false));
348 g_assert_cmpint(data.n, ==, 1);
349
350 event_notifier_cleanup(&data.e);
351}
352
353static void test_flush_event_notifier(void)
354{
355 EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
356 event_notifier_init(&data.e, false);
dca21ef2 357 set_event_notifier(ctx, &data.e, event_ready_cb);
12d69ac0 358 while (aio_poll(ctx, false));
b2ea25d7
PB		 359 g_assert_cmpint(data.n, ==, 0);
360 g_assert_cmpint(data.active, ==, 10);
361
362 event_notifier_set(&data.e);
363 g_assert(aio_poll(ctx, false));
364 g_assert_cmpint(data.n, ==, 1);
365 g_assert_cmpint(data.active, ==, 9);
366 g_assert(aio_poll(ctx, false));
367
24d1a6d9 368 wait_until_inactive(&data);
b2ea25d7
PB		 369 g_assert_cmpint(data.n, ==, 10);
370 g_assert_cmpint(data.active, ==, 0);
371 g_assert(!aio_poll(ctx, false));
372
dca21ef2 373 set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 374 g_assert(!aio_poll(ctx, false));
375 event_notifier_cleanup(&data.e);
376}
377
c07bc2c1
FZ		 378static void test_aio_external_client(void)
379{
380 int i, j;
381
382 for (i = 1; i < 3; i++) {
383 EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
384 event_notifier_init(&data.e, false);
385 aio_set_event_notifier(ctx, &data.e, true, event_ready_cb);
386 event_notifier_set(&data.e);
387 for (j = 0; j < i; j++) {
388 aio_disable_external(ctx);
389 }
390 for (j = 0; j < i; j++) {
391 assert(!aio_poll(ctx, false));
392 assert(event_notifier_test_and_clear(&data.e));
393 event_notifier_set(&data.e);
394 aio_enable_external(ctx);
395 }
396 assert(aio_poll(ctx, false));
7595ed74 397 set_event_notifier(ctx, &data.e, NULL);
c07bc2c1
FZ		 398 event_notifier_cleanup(&data.e);
399 }
400}
401
b2ea25d7
PB		 402static void test_wait_event_notifier_noflush(void)
403{
404 EventNotifierTestData data = { .n = 0 };
405 EventNotifierTestData dummy = { .n = 0, .active = 1 };
406
407 event_notifier_init(&data.e, false);
dca21ef2 408 set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 409
410 g_assert(!aio_poll(ctx, false));
411 g_assert_cmpint(data.n, ==, 0);
412
413 /* Until there is an active descriptor, aio_poll may or may not call
414 * event_ready_cb. Still, it must not block. */
415 event_notifier_set(&data.e);
164a101f 416 g_assert(aio_poll(ctx, true));
b2ea25d7
PB		 417 data.n = 0;
418
419 /* An active event notifier forces aio_poll to look at EventNotifiers. */
420 event_notifier_init(&dummy.e, false);
dca21ef2 421 set_event_notifier(ctx, &dummy.e, event_ready_cb);
b2ea25d7
PB		 422
423 event_notifier_set(&data.e);
424 g_assert(aio_poll(ctx, false));
425 g_assert_cmpint(data.n, ==, 1);
164a101f 426 g_assert(!aio_poll(ctx, false));
b2ea25d7
PB		 427 g_assert_cmpint(data.n, ==, 1);
428
429 event_notifier_set(&data.e);
430 g_assert(aio_poll(ctx, false));
431 g_assert_cmpint(data.n, ==, 2);
164a101f 432 g_assert(!aio_poll(ctx, false));
b2ea25d7
PB		 433 g_assert_cmpint(data.n, ==, 2);
434
435 event_notifier_set(&dummy.e);
24d1a6d9 436 wait_until_inactive(&dummy);
b2ea25d7
PB		 437 g_assert_cmpint(data.n, ==, 2);
438 g_assert_cmpint(dummy.n, ==, 1);
439 g_assert_cmpint(dummy.active, ==, 0);
440
dca21ef2 441 set_event_notifier(ctx, &dummy.e, NULL);
b2ea25d7
PB		 442 event_notifier_cleanup(&dummy.e);
443
dca21ef2 444 set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 445 g_assert(!aio_poll(ctx, false));
446 g_assert_cmpint(data.n, ==, 2);
447
448 event_notifier_cleanup(&data.e);
449}
450
b53edf97
AB		 451static void test_timer_schedule(void)
452{
453 TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL,
454 .max = 2,
3fdd0ee3 455 .clock_type = QEMU_CLOCK_REALTIME };
363285d4 456 EventNotifier e;
b53edf97
AB		 457
458 /* aio_poll will not block to wait for timers to complete unless it has
459 * an fd to wait on. Fixing this breaks other tests. So create a dummy one.
460 */
363285d4 461 event_notifier_init(&e, false);
dca21ef2 462 set_event_notifier(ctx, &e, dummy_io_handler_read);
b53edf97
AB		 463 aio_poll(ctx, false);
464
465 aio_timer_init(ctx, &data.timer, data.clock_type,
466 SCALE_NS, timer_test_cb, &data);
467 timer_mod(&data.timer,
468 qemu_clock_get_ns(data.clock_type) +
469 data.ns);
470
471 g_assert_cmpint(data.n, ==, 0);
472
473 /* timer_mod may well cause an event notifer to have gone off,
474 * so clear that
475 */
476 do {} while (aio_poll(ctx, false));
477
478 g_assert(!aio_poll(ctx, false));
479 g_assert_cmpint(data.n, ==, 0);
480
fcdda211 481 g_usleep(1 * G_USEC_PER_SEC);
b53edf97
AB		 482 g_assert_cmpint(data.n, ==, 0);
483
484 g_assert(aio_poll(ctx, false));
485 g_assert_cmpint(data.n, ==, 1);
486
487 /* timer_mod called by our callback */
488 do {} while (aio_poll(ctx, false));
489
490 g_assert(!aio_poll(ctx, false));
491 g_assert_cmpint(data.n, ==, 1);
492
493 g_assert(aio_poll(ctx, true));
494 g_assert_cmpint(data.n, ==, 2);
495
496 /* As max is now 2, an event notifier should not have gone off */
497
498 g_assert(!aio_poll(ctx, false));
499 g_assert_cmpint(data.n, ==, 2);
500
dca21ef2 501 set_event_notifier(ctx, &e, NULL);
363285d4 502 event_notifier_cleanup(&e);
b53edf97
AB		 503
504 timer_del(&data.timer);
505}
506
b2ea25d7
PB		 507/* Now the same tests, using the context as a GSource. They are
508 * very similar to the ones above, with g_main_context_iteration
509 * replacing aio_poll. However:
510 * - sometimes both the AioContext and the glib main loop wake
511 * themselves up. Hence, some "g_assert(!aio_poll(ctx, false));"
512 * are replaced by "while (g_main_context_iteration(NULL, false));".
9fe3781f 513 * - there is no exact replacement for a blocking wait.
b2ea25d7
PB		 514 * "while (g_main_context_iteration(NULL, true)" seems to work,
515 * but it is not documented _why_ it works. For these tests a
516 * non-blocking loop like "while (g_main_context_iteration(NULL, false)"
517 * works well, and that's what I am using.
518 */
519
b2ea25d7
PB		 520static void test_source_flush(void)
521{
522 g_assert(!g_main_context_iteration(NULL, false));
523 aio_notify(ctx);
524 while (g_main_context_iteration(NULL, false));
525 g_assert(!g_main_context_iteration(NULL, false));
526}
527
528static void test_source_bh_schedule(void)
529{
530 BHTestData data = { .n = 0 };
531 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
532
533 qemu_bh_schedule(data.bh);
534 g_assert_cmpint(data.n, ==, 0);
535
536 g_assert(g_main_context_iteration(NULL, true));
537 g_assert_cmpint(data.n, ==, 1);
538
539 g_assert(!g_main_context_iteration(NULL, false));
540 g_assert_cmpint(data.n, ==, 1);
541 qemu_bh_delete(data.bh);
542}
543
544static void test_source_bh_schedule10(void)
545{
546 BHTestData data = { .n = 0, .max = 10 };
547 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
548
549 qemu_bh_schedule(data.bh);
550 g_assert_cmpint(data.n, ==, 0);
551
552 g_assert(g_main_context_iteration(NULL, false));
553 g_assert_cmpint(data.n, ==, 1);
554
555 g_assert(g_main_context_iteration(NULL, true));
556 g_assert_cmpint(data.n, ==, 2);
557
558 while (g_main_context_iteration(NULL, false));
559 g_assert_cmpint(data.n, ==, 10);
560
561 g_assert(!g_main_context_iteration(NULL, false));
562 g_assert_cmpint(data.n, ==, 10);
563 qemu_bh_delete(data.bh);
564}
565
566static void test_source_bh_cancel(void)
567{
568 BHTestData data = { .n = 0 };
569 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
570
571 qemu_bh_schedule(data.bh);
572 g_assert_cmpint(data.n, ==, 0);
573
574 qemu_bh_cancel(data.bh);
575 g_assert_cmpint(data.n, ==, 0);
576
577 while (g_main_context_iteration(NULL, false));
578 g_assert_cmpint(data.n, ==, 0);
579 qemu_bh_delete(data.bh);
580}
581
582static void test_source_bh_delete(void)
583{
584 BHTestData data = { .n = 0 };
585 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
586
587 qemu_bh_schedule(data.bh);
588 g_assert_cmpint(data.n, ==, 0);
589
590 qemu_bh_delete(data.bh);
591 g_assert_cmpint(data.n, ==, 0);
592
593 while (g_main_context_iteration(NULL, false));
594 g_assert_cmpint(data.n, ==, 0);
595}
596
597static void test_source_bh_delete_from_cb(void)
598{
599 BHTestData data1 = { .n = 0, .max = 1 };
600
601 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
602
603 qemu_bh_schedule(data1.bh);
604 g_assert_cmpint(data1.n, ==, 0);
605
606 g_main_context_iteration(NULL, true);
607 g_assert_cmpint(data1.n, ==, data1.max);
608 g_assert(data1.bh == NULL);
609
610 g_assert(!g_main_context_iteration(NULL, false));
611}
612
613static void test_source_bh_delete_from_cb_many(void)
614{
615 BHTestData data1 = { .n = 0, .max = 1 };
616 BHTestData data2 = { .n = 0, .max = 3 };
617 BHTestData data3 = { .n = 0, .max = 2 };
618 BHTestData data4 = { .n = 0, .max = 4 };
619
620 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
621 data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2);
622 data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3);
623 data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4);
624
625 qemu_bh_schedule(data1.bh);
626 qemu_bh_schedule(data2.bh);
627 qemu_bh_schedule(data3.bh);
628 qemu_bh_schedule(data4.bh);
629 g_assert_cmpint(data1.n, ==, 0);
630 g_assert_cmpint(data2.n, ==, 0);
631 g_assert_cmpint(data3.n, ==, 0);
632 g_assert_cmpint(data4.n, ==, 0);
633
634 g_assert(g_main_context_iteration(NULL, false));
635 g_assert_cmpint(data1.n, ==, 1);
636 g_assert_cmpint(data2.n, ==, 1);
637 g_assert_cmpint(data3.n, ==, 1);
638 g_assert_cmpint(data4.n, ==, 1);
639 g_assert(data1.bh == NULL);
640
641 while (g_main_context_iteration(NULL, false));
642 g_assert_cmpint(data1.n, ==, data1.max);
643 g_assert_cmpint(data2.n, ==, data2.max);
644 g_assert_cmpint(data3.n, ==, data3.max);
645 g_assert_cmpint(data4.n, ==, data4.max);
646 g_assert(data1.bh == NULL);
647 g_assert(data2.bh == NULL);
648 g_assert(data3.bh == NULL);
649 g_assert(data4.bh == NULL);
650}
651
652static void test_source_bh_flush(void)
653{
654 BHTestData data = { .n = 0 };
655 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
656
657 qemu_bh_schedule(data.bh);
658 g_assert_cmpint(data.n, ==, 0);
659
660 g_assert(g_main_context_iteration(NULL, true));
661 g_assert_cmpint(data.n, ==, 1);
662
663 g_assert(!g_main_context_iteration(NULL, false));
664 g_assert_cmpint(data.n, ==, 1);
665 qemu_bh_delete(data.bh);
666}
667
668static void test_source_set_event_notifier(void)
669{
670 EventNotifierTestData data = { .n = 0, .active = 0 };
671 event_notifier_init(&data.e, false);
dca21ef2 672 set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 673 while (g_main_context_iteration(NULL, false));
674 g_assert_cmpint(data.n, ==, 0);
675
dca21ef2 676 set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 677 while (g_main_context_iteration(NULL, false));
678 g_assert_cmpint(data.n, ==, 0);
679 event_notifier_cleanup(&data.e);
680}
681
682static void test_source_wait_event_notifier(void)
683{
684 EventNotifierTestData data = { .n = 0, .active = 1 };
685 event_notifier_init(&data.e, false);
dca21ef2 686 set_event_notifier(ctx, &data.e, event_ready_cb);
12d69ac0 687 while (g_main_context_iteration(NULL, false));
b2ea25d7
PB		 688 g_assert_cmpint(data.n, ==, 0);
689 g_assert_cmpint(data.active, ==, 1);
690
691 event_notifier_set(&data.e);
692 g_assert(g_main_context_iteration(NULL, false));
693 g_assert_cmpint(data.n, ==, 1);
694 g_assert_cmpint(data.active, ==, 0);
695
696 while (g_main_context_iteration(NULL, false));
697 g_assert_cmpint(data.n, ==, 1);
698 g_assert_cmpint(data.active, ==, 0);
699
dca21ef2 700 set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 701 while (g_main_context_iteration(NULL, false));
702 g_assert_cmpint(data.n, ==, 1);
703
704 event_notifier_cleanup(&data.e);
705}
706
707static void test_source_flush_event_notifier(void)
708{
709 EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
710 event_notifier_init(&data.e, false);
dca21ef2 711 set_event_notifier(ctx, &data.e, event_ready_cb);
12d69ac0 712 while (g_main_context_iteration(NULL, false));
b2ea25d7
PB		 713 g_assert_cmpint(data.n, ==, 0);
714 g_assert_cmpint(data.active, ==, 10);
715
716 event_notifier_set(&data.e);
717 g_assert(g_main_context_iteration(NULL, false));
718 g_assert_cmpint(data.n, ==, 1);
719 g_assert_cmpint(data.active, ==, 9);
720 g_assert(g_main_context_iteration(NULL, false));
721
722 while (g_main_context_iteration(NULL, false));
723 g_assert_cmpint(data.n, ==, 10);
724 g_assert_cmpint(data.active, ==, 0);
725 g_assert(!g_main_context_iteration(NULL, false));
726
dca21ef2 727 set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 728 while (g_main_context_iteration(NULL, false));
729 event_notifier_cleanup(&data.e);
730}
731
732static void test_source_wait_event_notifier_noflush(void)
733{
734 EventNotifierTestData data = { .n = 0 };
735 EventNotifierTestData dummy = { .n = 0, .active = 1 };
736
737 event_notifier_init(&data.e, false);
dca21ef2 738 set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 739
740 while (g_main_context_iteration(NULL, false));
741 g_assert_cmpint(data.n, ==, 0);
742
743 /* Until there is an active descriptor, glib may or may not call
744 * event_ready_cb. Still, it must not block. */
745 event_notifier_set(&data.e);
746 g_main_context_iteration(NULL, true);
747 data.n = 0;
748
749 /* An active event notifier forces aio_poll to look at EventNotifiers. */
750 event_notifier_init(&dummy.e, false);
dca21ef2 751 set_event_notifier(ctx, &dummy.e, event_ready_cb);
b2ea25d7
PB		 752
753 event_notifier_set(&data.e);
754 g_assert(g_main_context_iteration(NULL, false));
755 g_assert_cmpint(data.n, ==, 1);
756 g_assert(!g_main_context_iteration(NULL, false));
757 g_assert_cmpint(data.n, ==, 1);
758
759 event_notifier_set(&data.e);
760 g_assert(g_main_context_iteration(NULL, false));
761 g_assert_cmpint(data.n, ==, 2);
762 g_assert(!g_main_context_iteration(NULL, false));
763 g_assert_cmpint(data.n, ==, 2);
764
765 event_notifier_set(&dummy.e);
766 while (g_main_context_iteration(NULL, false));
767 g_assert_cmpint(data.n, ==, 2);
768 g_assert_cmpint(dummy.n, ==, 1);
769 g_assert_cmpint(dummy.active, ==, 0);
770
dca21ef2 771 set_event_notifier(ctx, &dummy.e, NULL);
b2ea25d7
PB		 772 event_notifier_cleanup(&dummy.e);
773
dca21ef2 774 set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 775 while (g_main_context_iteration(NULL, false));
776 g_assert_cmpint(data.n, ==, 2);
777
778 event_notifier_cleanup(&data.e);
779}
780
b53edf97
AB		 781static void test_source_timer_schedule(void)
782{
783 TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL,
784 .max = 2,
3fdd0ee3 785 .clock_type = QEMU_CLOCK_REALTIME };
363285d4 786 EventNotifier e;
b53edf97
AB		 787 int64_t expiry;
788
789 /* aio_poll will not block to wait for timers to complete unless it has
790 * an fd to wait on. Fixing this breaks other tests. So create a dummy one.
791 */
363285d4 792 event_notifier_init(&e, false);
dca21ef2 793 set_event_notifier(ctx, &e, dummy_io_handler_read);
b53edf97
AB		 794 do {} while (g_main_context_iteration(NULL, false));
795
796 aio_timer_init(ctx, &data.timer, data.clock_type,
797 SCALE_NS, timer_test_cb, &data);
798 expiry = qemu_clock_get_ns(data.clock_type) +
799 data.ns;
800 timer_mod(&data.timer, expiry);
801
802 g_assert_cmpint(data.n, ==, 0);
803
fcdda211 804 g_usleep(1 * G_USEC_PER_SEC);
b53edf97
AB		 805 g_assert_cmpint(data.n, ==, 0);
806
ef508f42 807 g_assert(g_main_context_iteration(NULL, true));
b53edf97 808 g_assert_cmpint(data.n, ==, 1);
ef508f42 809 expiry += data.ns;
b53edf97 810
ef508f42
PB		 811 while (data.n < 2) {
812 g_main_context_iteration(NULL, true);
813 }
b53edf97
AB		 814
815 g_assert_cmpint(data.n, ==, 2);
ef508f42 816 g_assert(qemu_clock_get_ns(data.clock_type) > expiry);
b53edf97 817
dca21ef2 818 set_event_notifier(ctx, &e, NULL);
363285d4 819 event_notifier_cleanup(&e);
b53edf97
AB		 820
821 timer_del(&data.timer);
822}
823
824
b2ea25d7
PB		 825/* End of tests. */
826
827int main(int argc, char **argv)
828{
2f78e491 829 Error *local_error = NULL;
b2ea25d7
PB		 830 GSource *src;
831
dae21b98
AB		 832 init_clocks();
833
2f78e491
CN		 834 ctx = aio_context_new(&local_error);
835 if (!ctx) {
c29b77f9 836 error_reportf_err(local_error, "Failed to create AIO Context: ");
2f78e491
CN		 837 exit(1);
838 }
b2ea25d7
PB		 839 src = aio_get_g_source(ctx);
840 g_source_attach(src, NULL);
841 g_source_unref(src);
842
843 while (g_main_context_iteration(NULL, false));
844
845 g_test_init(&argc, &argv, NULL);
98563fc3 846 g_test_add_func("/aio/acquire", test_acquire);
b2ea25d7
PB		 847 g_test_add_func("/aio/bh/schedule", test_bh_schedule);
848 g_test_add_func("/aio/bh/schedule10", test_bh_schedule10);
849 g_test_add_func("/aio/bh/cancel", test_bh_cancel);
850 g_test_add_func("/aio/bh/delete", test_bh_delete);
851 g_test_add_func("/aio/bh/callback-delete/one", test_bh_delete_from_cb);
852 g_test_add_func("/aio/bh/callback-delete/many", test_bh_delete_from_cb_many);
853 g_test_add_func("/aio/bh/flush", test_bh_flush);
854 g_test_add_func("/aio/event/add-remove", test_set_event_notifier);
855 g_test_add_func("/aio/event/wait", test_wait_event_notifier);
856 g_test_add_func("/aio/event/wait/no-flush-cb", test_wait_event_notifier_noflush);
857 g_test_add_func("/aio/event/flush", test_flush_event_notifier);
c07bc2c1 858 g_test_add_func("/aio/external-client", test_aio_external_client);
b53edf97 859 g_test_add_func("/aio/timer/schedule", test_timer_schedule);
b2ea25d7 860
b2ea25d7
PB		 861 g_test_add_func("/aio-gsource/flush", test_source_flush);
862 g_test_add_func("/aio-gsource/bh/schedule", test_source_bh_schedule);
863 g_test_add_func("/aio-gsource/bh/schedule10", test_source_bh_schedule10);
864 g_test_add_func("/aio-gsource/bh/cancel", test_source_bh_cancel);
865 g_test_add_func("/aio-gsource/bh/delete", test_source_bh_delete);
866 g_test_add_func("/aio-gsource/bh/callback-delete/one", test_source_bh_delete_from_cb);
867 g_test_add_func("/aio-gsource/bh/callback-delete/many", test_source_bh_delete_from_cb_many);
868 g_test_add_func("/aio-gsource/bh/flush", test_source_bh_flush);
869 g_test_add_func("/aio-gsource/event/add-remove", test_source_set_event_notifier);
870 g_test_add_func("/aio-gsource/event/wait", test_source_wait_event_notifier);
871 g_test_add_func("/aio-gsource/event/wait/no-flush-cb", test_source_wait_event_notifier_noflush);
872 g_test_add_func("/aio-gsource/event/flush", test_source_flush_event_notifier);
b53edf97 873 g_test_add_func("/aio-gsource/timer/schedule", test_source_timer_schedule);
b2ea25d7
PB		 874 return g_test_run();
875}
QEMU mirror