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