]> 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
block: vhdx - fix reading beyond pointer during image creation
[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
13#include <glib.h>
737e150e 14#include "block/aio.h"
dae21b98 15#include "qemu/timer.h"
a94a3fac 16#include "qemu/sockets.h"
b2ea25d7 17
748bfb4e 18static AioContext *ctx;
b2ea25d7 19
24d1a6d9
SH		 20typedef struct {
21 EventNotifier e;
22 int n;
23 int active;
24 bool auto_set;
25} EventNotifierTestData;
26
24d1a6d9
SH		 27/* Wait until event notifier becomes inactive */
28static void wait_until_inactive(EventNotifierTestData *data)
29{
30 while (data->active > 0) {
31 aio_poll(ctx, true);
32 }
33}
34
b2ea25d7
PB		 35/* Simple callbacks for testing. */
36
37typedef struct {
38 QEMUBH *bh;
39 int n;
40 int max;
41} BHTestData;
42
b53edf97
AB		 43typedef struct {
44 QEMUTimer timer;
45 QEMUClockType clock_type;
46 int n;
47 int max;
48 int64_t ns;
49 AioContext *ctx;
50} TimerTestData;
51
b2ea25d7
PB		 52static void bh_test_cb(void *opaque)
53{
54 BHTestData *data = opaque;
55 if (++data->n < data->max) {
56 qemu_bh_schedule(data->bh);
57 }
58}
59
b53edf97
AB		 60static void timer_test_cb(void *opaque)
61{
62 TimerTestData *data = opaque;
63 if (++data->n < data->max) {
64 timer_mod(&data->timer,
65 qemu_clock_get_ns(data->clock_type) + data->ns);
66 }
67}
68
363285d4 69static void dummy_io_handler_read(EventNotifier *e)
b53edf97
AB		 70{
71}
72
b2ea25d7
PB		 73static void bh_delete_cb(void *opaque)
74{
75 BHTestData *data = opaque;
76 if (++data->n < data->max) {
77 qemu_bh_schedule(data->bh);
78 } else {
79 qemu_bh_delete(data->bh);
80 data->bh = NULL;
81 }
82}
83
b2ea25d7
PB		 84static void event_ready_cb(EventNotifier *e)
85{
86 EventNotifierTestData *data = container_of(e, EventNotifierTestData, e);
87 g_assert(event_notifier_test_and_clear(e));
88 data->n++;
89 if (data->active > 0) {
90 data->active--;
91 }
92 if (data->auto_set && data->active) {
93 event_notifier_set(e);
94 }
95}
96
97/* Tests using aio_*. */
98
99static void test_notify(void)
100{
101 g_assert(!aio_poll(ctx, false));
102 aio_notify(ctx);
103 g_assert(!aio_poll(ctx, true));
104 g_assert(!aio_poll(ctx, false));
105}
106
98563fc3
SH		 107typedef struct {
108 QemuMutex start_lock;
109 bool thread_acquired;
110} AcquireTestData;
111
112static void *test_acquire_thread(void *opaque)
113{
114 AcquireTestData *data = opaque;
115
116 /* Wait for other thread to let us start */
117 qemu_mutex_lock(&data->start_lock);
118 qemu_mutex_unlock(&data->start_lock);
119
120 aio_context_acquire(ctx);
121 aio_context_release(ctx);
122
123 data->thread_acquired = true; /* success, we got here */
124
125 return NULL;
126}
127
128static void dummy_notifier_read(EventNotifier *unused)
129{
130 g_assert(false); /* should never be invoked */
131}
132
133static void test_acquire(void)
134{
135 QemuThread thread;
136 EventNotifier notifier;
137 AcquireTestData data;
138
139 /* Dummy event notifier ensures aio_poll() will block */
140 event_notifier_init(&notifier, false);
141 aio_set_event_notifier(ctx, &notifier, dummy_notifier_read);
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 */
155 g_assert(!aio_poll(ctx, true));
156 aio_context_release(ctx);
157
158 qemu_thread_join(&thread);
159 aio_set_event_notifier(ctx, &notifier, NULL);
160 event_notifier_cleanup(&notifier);
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);
f2e5dca4 318 aio_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
f2e5dca4 322 aio_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);
f2e5dca4 332 aio_set_event_notifier(ctx, &data.e, event_ready_cb);
164a101f 333 g_assert(!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
f2e5dca4 346 aio_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);
f2e5dca4 357 aio_set_event_notifier(ctx, &data.e, event_ready_cb);
164a101f 358 g_assert(!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
f2e5dca4 373 aio_set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 374 g_assert(!aio_poll(ctx, false));
375 event_notifier_cleanup(&data.e);
376}
377
378static void test_wait_event_notifier_noflush(void)
379{
380 EventNotifierTestData data = { .n = 0 };
381 EventNotifierTestData dummy = { .n = 0, .active = 1 };
382
383 event_notifier_init(&data.e, false);
f2e5dca4 384 aio_set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 385
386 g_assert(!aio_poll(ctx, false));
387 g_assert_cmpint(data.n, ==, 0);
388
389 /* Until there is an active descriptor, aio_poll may or may not call
390 * event_ready_cb. Still, it must not block. */
391 event_notifier_set(&data.e);
164a101f 392 g_assert(aio_poll(ctx, true));
b2ea25d7
PB		 393 data.n = 0;
394
395 /* An active event notifier forces aio_poll to look at EventNotifiers. */
396 event_notifier_init(&dummy.e, false);
f2e5dca4 397 aio_set_event_notifier(ctx, &dummy.e, event_ready_cb);
b2ea25d7
PB		 398
399 event_notifier_set(&data.e);
400 g_assert(aio_poll(ctx, false));
401 g_assert_cmpint(data.n, ==, 1);
164a101f 402 g_assert(!aio_poll(ctx, false));
b2ea25d7
PB		 403 g_assert_cmpint(data.n, ==, 1);
404
405 event_notifier_set(&data.e);
406 g_assert(aio_poll(ctx, false));
407 g_assert_cmpint(data.n, ==, 2);
164a101f 408 g_assert(!aio_poll(ctx, false));
b2ea25d7
PB		 409 g_assert_cmpint(data.n, ==, 2);
410
411 event_notifier_set(&dummy.e);
24d1a6d9 412 wait_until_inactive(&dummy);
b2ea25d7
PB		 413 g_assert_cmpint(data.n, ==, 2);
414 g_assert_cmpint(dummy.n, ==, 1);
415 g_assert_cmpint(dummy.active, ==, 0);
416
f2e5dca4 417 aio_set_event_notifier(ctx, &dummy.e, NULL);
b2ea25d7
PB		 418 event_notifier_cleanup(&dummy.e);
419
f2e5dca4 420 aio_set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 421 g_assert(!aio_poll(ctx, false));
422 g_assert_cmpint(data.n, ==, 2);
423
424 event_notifier_cleanup(&data.e);
425}
426
b53edf97
AB		 427static void test_timer_schedule(void)
428{
429 TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL,
430 .max = 2,
431 .clock_type = QEMU_CLOCK_VIRTUAL };
363285d4 432 EventNotifier e;
b53edf97
AB		 433
434 /* aio_poll will not block to wait for timers to complete unless it has
435 * an fd to wait on. Fixing this breaks other tests. So create a dummy one.
436 */
363285d4
PB		 437 event_notifier_init(&e, false);
438 aio_set_event_notifier(ctx, &e, dummy_io_handler_read);
b53edf97
AB		 439 aio_poll(ctx, false);
440
441 aio_timer_init(ctx, &data.timer, data.clock_type,
442 SCALE_NS, timer_test_cb, &data);
443 timer_mod(&data.timer,
444 qemu_clock_get_ns(data.clock_type) +
445 data.ns);
446
447 g_assert_cmpint(data.n, ==, 0);
448
449 /* timer_mod may well cause an event notifer to have gone off,
450 * so clear that
451 */
452 do {} while (aio_poll(ctx, false));
453
454 g_assert(!aio_poll(ctx, false));
455 g_assert_cmpint(data.n, ==, 0);
456
fcdda211 457 g_usleep(1 * G_USEC_PER_SEC);
b53edf97
AB		 458 g_assert_cmpint(data.n, ==, 0);
459
460 g_assert(aio_poll(ctx, false));
461 g_assert_cmpint(data.n, ==, 1);
462
463 /* timer_mod called by our callback */
464 do {} while (aio_poll(ctx, false));
465
466 g_assert(!aio_poll(ctx, false));
467 g_assert_cmpint(data.n, ==, 1);
468
469 g_assert(aio_poll(ctx, true));
470 g_assert_cmpint(data.n, ==, 2);
471
472 /* As max is now 2, an event notifier should not have gone off */
473
474 g_assert(!aio_poll(ctx, false));
475 g_assert_cmpint(data.n, ==, 2);
476
363285d4
PB		 477 aio_set_event_notifier(ctx, &e, NULL);
478 event_notifier_cleanup(&e);
b53edf97
AB		 479
480 timer_del(&data.timer);
481}
482
b2ea25d7
PB		 483/* Now the same tests, using the context as a GSource. They are
484 * very similar to the ones above, with g_main_context_iteration
485 * replacing aio_poll. However:
486 * - sometimes both the AioContext and the glib main loop wake
487 * themselves up. Hence, some "g_assert(!aio_poll(ctx, false));"
488 * are replaced by "while (g_main_context_iteration(NULL, false));".
9fe3781f 489 * - there is no exact replacement for a blocking wait.
b2ea25d7
PB		 490 * "while (g_main_context_iteration(NULL, true)" seems to work,
491 * but it is not documented _why_ it works. For these tests a
492 * non-blocking loop like "while (g_main_context_iteration(NULL, false)"
493 * works well, and that's what I am using.
494 */
495
496static void test_source_notify(void)
497{
498 while (g_main_context_iteration(NULL, false));
499 aio_notify(ctx);
500 g_assert(g_main_context_iteration(NULL, true));
501 g_assert(!g_main_context_iteration(NULL, false));
502}
503
504static void test_source_flush(void)
505{
506 g_assert(!g_main_context_iteration(NULL, false));
507 aio_notify(ctx);
508 while (g_main_context_iteration(NULL, false));
509 g_assert(!g_main_context_iteration(NULL, false));
510}
511
512static void test_source_bh_schedule(void)
513{
514 BHTestData data = { .n = 0 };
515 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
516
517 qemu_bh_schedule(data.bh);
518 g_assert_cmpint(data.n, ==, 0);
519
520 g_assert(g_main_context_iteration(NULL, true));
521 g_assert_cmpint(data.n, ==, 1);
522
523 g_assert(!g_main_context_iteration(NULL, false));
524 g_assert_cmpint(data.n, ==, 1);
525 qemu_bh_delete(data.bh);
526}
527
528static void test_source_bh_schedule10(void)
529{
530 BHTestData data = { .n = 0, .max = 10 };
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, false));
537 g_assert_cmpint(data.n, ==, 1);
538
539 g_assert(g_main_context_iteration(NULL, true));
540 g_assert_cmpint(data.n, ==, 2);
541
542 while (g_main_context_iteration(NULL, false));
543 g_assert_cmpint(data.n, ==, 10);
544
545 g_assert(!g_main_context_iteration(NULL, false));
546 g_assert_cmpint(data.n, ==, 10);
547 qemu_bh_delete(data.bh);
548}
549
550static void test_source_bh_cancel(void)
551{
552 BHTestData data = { .n = 0 };
553 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
554
555 qemu_bh_schedule(data.bh);
556 g_assert_cmpint(data.n, ==, 0);
557
558 qemu_bh_cancel(data.bh);
559 g_assert_cmpint(data.n, ==, 0);
560
561 while (g_main_context_iteration(NULL, false));
562 g_assert_cmpint(data.n, ==, 0);
563 qemu_bh_delete(data.bh);
564}
565
566static void test_source_bh_delete(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_delete(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}
580
581static void test_source_bh_delete_from_cb(void)
582{
583 BHTestData data1 = { .n = 0, .max = 1 };
584
585 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
586
587 qemu_bh_schedule(data1.bh);
588 g_assert_cmpint(data1.n, ==, 0);
589
590 g_main_context_iteration(NULL, true);
591 g_assert_cmpint(data1.n, ==, data1.max);
592 g_assert(data1.bh == NULL);
593
594 g_assert(!g_main_context_iteration(NULL, false));
595}
596
597static void test_source_bh_delete_from_cb_many(void)
598{
599 BHTestData data1 = { .n = 0, .max = 1 };
600 BHTestData data2 = { .n = 0, .max = 3 };
601 BHTestData data3 = { .n = 0, .max = 2 };
602 BHTestData data4 = { .n = 0, .max = 4 };
603
604 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
605 data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2);
606 data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3);
607 data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4);
608
609 qemu_bh_schedule(data1.bh);
610 qemu_bh_schedule(data2.bh);
611 qemu_bh_schedule(data3.bh);
612 qemu_bh_schedule(data4.bh);
613 g_assert_cmpint(data1.n, ==, 0);
614 g_assert_cmpint(data2.n, ==, 0);
615 g_assert_cmpint(data3.n, ==, 0);
616 g_assert_cmpint(data4.n, ==, 0);
617
618 g_assert(g_main_context_iteration(NULL, false));
619 g_assert_cmpint(data1.n, ==, 1);
620 g_assert_cmpint(data2.n, ==, 1);
621 g_assert_cmpint(data3.n, ==, 1);
622 g_assert_cmpint(data4.n, ==, 1);
623 g_assert(data1.bh == NULL);
624
625 while (g_main_context_iteration(NULL, false));
626 g_assert_cmpint(data1.n, ==, data1.max);
627 g_assert_cmpint(data2.n, ==, data2.max);
628 g_assert_cmpint(data3.n, ==, data3.max);
629 g_assert_cmpint(data4.n, ==, data4.max);
630 g_assert(data1.bh == NULL);
631 g_assert(data2.bh == NULL);
632 g_assert(data3.bh == NULL);
633 g_assert(data4.bh == NULL);
634}
635
636static void test_source_bh_flush(void)
637{
638 BHTestData data = { .n = 0 };
639 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
640
641 qemu_bh_schedule(data.bh);
642 g_assert_cmpint(data.n, ==, 0);
643
644 g_assert(g_main_context_iteration(NULL, true));
645 g_assert_cmpint(data.n, ==, 1);
646
647 g_assert(!g_main_context_iteration(NULL, false));
648 g_assert_cmpint(data.n, ==, 1);
649 qemu_bh_delete(data.bh);
650}
651
652static void test_source_set_event_notifier(void)
653{
654 EventNotifierTestData data = { .n = 0, .active = 0 };
655 event_notifier_init(&data.e, false);
f2e5dca4 656 aio_set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 657 while (g_main_context_iteration(NULL, false));
658 g_assert_cmpint(data.n, ==, 0);
659
f2e5dca4 660 aio_set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 661 while (g_main_context_iteration(NULL, false));
662 g_assert_cmpint(data.n, ==, 0);
663 event_notifier_cleanup(&data.e);
664}
665
666static void test_source_wait_event_notifier(void)
667{
668 EventNotifierTestData data = { .n = 0, .active = 1 };
669 event_notifier_init(&data.e, false);
f2e5dca4 670 aio_set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 671 g_assert(g_main_context_iteration(NULL, false));
672 g_assert_cmpint(data.n, ==, 0);
673 g_assert_cmpint(data.active, ==, 1);
674
675 event_notifier_set(&data.e);
676 g_assert(g_main_context_iteration(NULL, false));
677 g_assert_cmpint(data.n, ==, 1);
678 g_assert_cmpint(data.active, ==, 0);
679
680 while (g_main_context_iteration(NULL, false));
681 g_assert_cmpint(data.n, ==, 1);
682 g_assert_cmpint(data.active, ==, 0);
683
f2e5dca4 684 aio_set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 685 while (g_main_context_iteration(NULL, false));
686 g_assert_cmpint(data.n, ==, 1);
687
688 event_notifier_cleanup(&data.e);
689}
690
691static void test_source_flush_event_notifier(void)
692{
693 EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
694 event_notifier_init(&data.e, false);
f2e5dca4 695 aio_set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 696 g_assert(g_main_context_iteration(NULL, false));
697 g_assert_cmpint(data.n, ==, 0);
698 g_assert_cmpint(data.active, ==, 10);
699
700 event_notifier_set(&data.e);
701 g_assert(g_main_context_iteration(NULL, false));
702 g_assert_cmpint(data.n, ==, 1);
703 g_assert_cmpint(data.active, ==, 9);
704 g_assert(g_main_context_iteration(NULL, false));
705
706 while (g_main_context_iteration(NULL, false));
707 g_assert_cmpint(data.n, ==, 10);
708 g_assert_cmpint(data.active, ==, 0);
709 g_assert(!g_main_context_iteration(NULL, false));
710
f2e5dca4 711 aio_set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 712 while (g_main_context_iteration(NULL, false));
713 event_notifier_cleanup(&data.e);
714}
715
716static void test_source_wait_event_notifier_noflush(void)
717{
718 EventNotifierTestData data = { .n = 0 };
719 EventNotifierTestData dummy = { .n = 0, .active = 1 };
720
721 event_notifier_init(&data.e, false);
f2e5dca4 722 aio_set_event_notifier(ctx, &data.e, event_ready_cb);
b2ea25d7
PB		 723
724 while (g_main_context_iteration(NULL, false));
725 g_assert_cmpint(data.n, ==, 0);
726
727 /* Until there is an active descriptor, glib may or may not call
728 * event_ready_cb. Still, it must not block. */
729 event_notifier_set(&data.e);
730 g_main_context_iteration(NULL, true);
731 data.n = 0;
732
733 /* An active event notifier forces aio_poll to look at EventNotifiers. */
734 event_notifier_init(&dummy.e, false);
f2e5dca4 735 aio_set_event_notifier(ctx, &dummy.e, event_ready_cb);
b2ea25d7
PB		 736
737 event_notifier_set(&data.e);
738 g_assert(g_main_context_iteration(NULL, false));
739 g_assert_cmpint(data.n, ==, 1);
740 g_assert(!g_main_context_iteration(NULL, false));
741 g_assert_cmpint(data.n, ==, 1);
742
743 event_notifier_set(&data.e);
744 g_assert(g_main_context_iteration(NULL, false));
745 g_assert_cmpint(data.n, ==, 2);
746 g_assert(!g_main_context_iteration(NULL, false));
747 g_assert_cmpint(data.n, ==, 2);
748
749 event_notifier_set(&dummy.e);
750 while (g_main_context_iteration(NULL, false));
751 g_assert_cmpint(data.n, ==, 2);
752 g_assert_cmpint(dummy.n, ==, 1);
753 g_assert_cmpint(dummy.active, ==, 0);
754
f2e5dca4 755 aio_set_event_notifier(ctx, &dummy.e, NULL);
b2ea25d7
PB		 756 event_notifier_cleanup(&dummy.e);
757
f2e5dca4 758 aio_set_event_notifier(ctx, &data.e, NULL);
b2ea25d7
PB		 759 while (g_main_context_iteration(NULL, false));
760 g_assert_cmpint(data.n, ==, 2);
761
762 event_notifier_cleanup(&data.e);
763}
764
b53edf97
AB		 765static void test_source_timer_schedule(void)
766{
767 TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL,
768 .max = 2,
769 .clock_type = QEMU_CLOCK_VIRTUAL };
363285d4 770 EventNotifier e;
b53edf97
AB		 771 int64_t expiry;
772
773 /* aio_poll will not block to wait for timers to complete unless it has
774 * an fd to wait on. Fixing this breaks other tests. So create a dummy one.
775 */
363285d4
PB		 776 event_notifier_init(&e, false);
777 aio_set_event_notifier(ctx, &e, dummy_io_handler_read);
b53edf97
AB		 778 do {} while (g_main_context_iteration(NULL, false));
779
780 aio_timer_init(ctx, &data.timer, data.clock_type,
781 SCALE_NS, timer_test_cb, &data);
782 expiry = qemu_clock_get_ns(data.clock_type) +
783 data.ns;
784 timer_mod(&data.timer, expiry);
785
786 g_assert_cmpint(data.n, ==, 0);
787
fcdda211 788 g_usleep(1 * G_USEC_PER_SEC);
b53edf97
AB		 789 g_assert_cmpint(data.n, ==, 0);
790
ef508f42 791 g_assert(g_main_context_iteration(NULL, true));
b53edf97 792 g_assert_cmpint(data.n, ==, 1);
ef508f42 793 expiry += data.ns;
b53edf97 794
ef508f42
PB		 795 while (data.n < 2) {
796 g_main_context_iteration(NULL, true);
797 }
b53edf97
AB		 798
799 g_assert_cmpint(data.n, ==, 2);
ef508f42 800 g_assert(qemu_clock_get_ns(data.clock_type) > expiry);
b53edf97 801
363285d4
PB		 802 aio_set_event_notifier(ctx, &e, NULL);
803 event_notifier_cleanup(&e);
b53edf97
AB		 804
805 timer_del(&data.timer);
806}
807
808
b2ea25d7
PB		 809/* End of tests. */
810
811int main(int argc, char **argv)
812{
813 GSource *src;
814
dae21b98
AB		 815 init_clocks();
816
b2ea25d7
PB		 817 ctx = aio_context_new();
818 src = aio_get_g_source(ctx);
819 g_source_attach(src, NULL);
820 g_source_unref(src);
821
822 while (g_main_context_iteration(NULL, false));
823
824 g_test_init(&argc, &argv, NULL);
825 g_test_add_func("/aio/notify", test_notify);
98563fc3 826 g_test_add_func("/aio/acquire", test_acquire);
b2ea25d7
PB		 827 g_test_add_func("/aio/bh/schedule", test_bh_schedule);
828 g_test_add_func("/aio/bh/schedule10", test_bh_schedule10);
829 g_test_add_func("/aio/bh/cancel", test_bh_cancel);
830 g_test_add_func("/aio/bh/delete", test_bh_delete);
831 g_test_add_func("/aio/bh/callback-delete/one", test_bh_delete_from_cb);
832 g_test_add_func("/aio/bh/callback-delete/many", test_bh_delete_from_cb_many);
833 g_test_add_func("/aio/bh/flush", test_bh_flush);
834 g_test_add_func("/aio/event/add-remove", test_set_event_notifier);
835 g_test_add_func("/aio/event/wait", test_wait_event_notifier);
836 g_test_add_func("/aio/event/wait/no-flush-cb", test_wait_event_notifier_noflush);
837 g_test_add_func("/aio/event/flush", test_flush_event_notifier);
b53edf97 838 g_test_add_func("/aio/timer/schedule", test_timer_schedule);
b2ea25d7
PB		 839
840 g_test_add_func("/aio-gsource/notify", test_source_notify);
841 g_test_add_func("/aio-gsource/flush", test_source_flush);
842 g_test_add_func("/aio-gsource/bh/schedule", test_source_bh_schedule);
843 g_test_add_func("/aio-gsource/bh/schedule10", test_source_bh_schedule10);
844 g_test_add_func("/aio-gsource/bh/cancel", test_source_bh_cancel);
845 g_test_add_func("/aio-gsource/bh/delete", test_source_bh_delete);
846 g_test_add_func("/aio-gsource/bh/callback-delete/one", test_source_bh_delete_from_cb);
847 g_test_add_func("/aio-gsource/bh/callback-delete/many", test_source_bh_delete_from_cb_many);
848 g_test_add_func("/aio-gsource/bh/flush", test_source_bh_flush);
849 g_test_add_func("/aio-gsource/event/add-remove", test_source_set_event_notifier);
850 g_test_add_func("/aio-gsource/event/wait", test_source_wait_event_notifier);
851 g_test_add_func("/aio-gsource/event/wait/no-flush-cb", test_source_wait_event_notifier_noflush);
852 g_test_add_func("/aio-gsource/event/flush", test_source_flush_event_notifier);
b53edf97 853 g_test_add_func("/aio-gsource/timer/schedule", test_source_timer_schedule);
b2ea25d7
PB		 854 return g_test_run();
855}
QEMU mirror