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 "qemu/osdep.h" 14 #include "block/aio.h" 15 #include "qapi/error.h" 16 #include "qemu/timer.h" 17 #include "qemu/sockets.h" 18 #include "qemu/error-report.h" 19 #include "qemu/coroutine-core.h" 20 #include "qemu/main-loop.h" 21 22 static AioContext *ctx; 23 24 typedef struct { 25 EventNotifier e; 26 int n; 27 int active; 28 bool auto_set; 29 } EventNotifierTestData; 30 31 /* Wait until event notifier becomes inactive */ 32 static void wait_until_inactive(EventNotifierTestData *data) 33 { 34 while (data->active > 0) { 35 aio_poll(ctx, true); 36 } 37 } 38 39 /* Simple callbacks for testing. */ 40 41 typedef struct { 42 QEMUBH *bh; 43 int n; 44 int max; 45 } BHTestData; 46 47 typedef struct { 48 QEMUTimer timer; 49 QEMUClockType clock_type; 50 int n; 51 int max; 52 int64_t ns; 53 AioContext *ctx; 54 } TimerTestData; 55 56 static void bh_test_cb(void *opaque) 57 { 58 BHTestData *data = opaque; 59 if (++data->n < data->max) { 60 qemu_bh_schedule(data->bh); 61 } 62 } 63 64 static void timer_test_cb(void *opaque) 65 { 66 TimerTestData *data = opaque; 67 if (++data->n < data->max) { 68 timer_mod(&data->timer, 69 qemu_clock_get_ns(data->clock_type) + data->ns); 70 } 71 } 72 73 static void dummy_io_handler_read(EventNotifier *e) 74 { 75 } 76 77 static void bh_delete_cb(void *opaque) 78 { 79 BHTestData *data = opaque; 80 if (++data->n < data->max) { 81 qemu_bh_schedule(data->bh); 82 } else { 83 qemu_bh_delete(data->bh); 84 data->bh = NULL; 85 } 86 } 87 88 static void event_ready_cb(EventNotifier *e) 89 { 90 EventNotifierTestData *data = container_of(e, EventNotifierTestData, e); 91 g_assert(event_notifier_test_and_clear(e)); 92 data->n++; 93 if (data->active > 0) { 94 data->active--; 95 } 96 if (data->auto_set && data->active) { 97 event_notifier_set(e); 98 } 99 } 100 101 /* Tests using aio_*. */ 102 103 typedef struct { 104 QemuMutex start_lock; 105 EventNotifier notifier; 106 bool thread_acquired; 107 } AcquireTestData; 108 109 static void *test_acquire_thread(void *opaque) 110 { 111 AcquireTestData *data = opaque; 112 113 /* Wait for other thread to let us start */ 114 qemu_mutex_lock(&data->start_lock); 115 qemu_mutex_unlock(&data->start_lock); 116 117 /* event_notifier_set might be called either before or after 118 * the main thread's call to poll(). The test case's outcome 119 * should be the same in either case. 120 */ 121 event_notifier_set(&data->notifier); 122 aio_context_acquire(ctx); 123 aio_context_release(ctx); 124 125 data->thread_acquired = true; /* success, we got here */ 126 127 return NULL; 128 } 129 130 static void set_event_notifier(AioContext *nctx, EventNotifier *notifier, 131 EventNotifierHandler *handler) 132 { 133 aio_set_event_notifier(nctx, notifier, handler, NULL, NULL); 134 } 135 136 static void dummy_notifier_read(EventNotifier *n) 137 { 138 event_notifier_test_and_clear(n); 139 } 140 141 static void test_acquire(void) 142 { 143 QemuThread thread; 144 AcquireTestData data; 145 146 /* Dummy event notifier ensures aio_poll() will block */ 147 event_notifier_init(&data.notifier, false); 148 set_event_notifier(ctx, &data.notifier, dummy_notifier_read); 149 g_assert(!aio_poll(ctx, false)); /* consume aio_notify() */ 150 151 qemu_mutex_init(&data.start_lock); 152 qemu_mutex_lock(&data.start_lock); 153 data.thread_acquired = false; 154 155 qemu_thread_create(&thread, "test_acquire_thread", 156 test_acquire_thread, 157 &data, QEMU_THREAD_JOINABLE); 158 159 /* Block in aio_poll(), let other thread kick us and acquire context */ 160 aio_context_acquire(ctx); 161 qemu_mutex_unlock(&data.start_lock); /* let the thread run */ 162 g_assert(aio_poll(ctx, true)); 163 g_assert(!data.thread_acquired); 164 aio_context_release(ctx); 165 166 qemu_thread_join(&thread); 167 set_event_notifier(ctx, &data.notifier, NULL); 168 event_notifier_cleanup(&data.notifier); 169 170 g_assert(data.thread_acquired); 171 } 172 173 static void test_bh_schedule(void) 174 { 175 BHTestData data = { .n = 0 }; 176 data.bh = aio_bh_new(ctx, bh_test_cb, &data); 177 178 qemu_bh_schedule(data.bh); 179 g_assert_cmpint(data.n, ==, 0); 180 181 g_assert(aio_poll(ctx, true)); 182 g_assert_cmpint(data.n, ==, 1); 183 184 g_assert(!aio_poll(ctx, false)); 185 g_assert_cmpint(data.n, ==, 1); 186 qemu_bh_delete(data.bh); 187 } 188 189 static void test_bh_schedule10(void) 190 { 191 BHTestData data = { .n = 0, .max = 10 }; 192 data.bh = aio_bh_new(ctx, bh_test_cb, &data); 193 194 qemu_bh_schedule(data.bh); 195 g_assert_cmpint(data.n, ==, 0); 196 197 g_assert(aio_poll(ctx, false)); 198 g_assert_cmpint(data.n, ==, 1); 199 200 g_assert(aio_poll(ctx, true)); 201 g_assert_cmpint(data.n, ==, 2); 202 203 while (data.n < 10) { 204 aio_poll(ctx, true); 205 } 206 g_assert_cmpint(data.n, ==, 10); 207 208 g_assert(!aio_poll(ctx, false)); 209 g_assert_cmpint(data.n, ==, 10); 210 qemu_bh_delete(data.bh); 211 } 212 213 static void test_bh_cancel(void) 214 { 215 BHTestData data = { .n = 0 }; 216 data.bh = aio_bh_new(ctx, bh_test_cb, &data); 217 218 qemu_bh_schedule(data.bh); 219 g_assert_cmpint(data.n, ==, 0); 220 221 qemu_bh_cancel(data.bh); 222 g_assert_cmpint(data.n, ==, 0); 223 224 g_assert(!aio_poll(ctx, false)); 225 g_assert_cmpint(data.n, ==, 0); 226 qemu_bh_delete(data.bh); 227 } 228 229 static void test_bh_delete(void) 230 { 231 BHTestData data = { .n = 0 }; 232 data.bh = aio_bh_new(ctx, bh_test_cb, &data); 233 234 qemu_bh_schedule(data.bh); 235 g_assert_cmpint(data.n, ==, 0); 236 237 qemu_bh_delete(data.bh); 238 g_assert_cmpint(data.n, ==, 0); 239 240 g_assert(!aio_poll(ctx, false)); 241 g_assert_cmpint(data.n, ==, 0); 242 } 243 244 static void test_bh_delete_from_cb(void) 245 { 246 BHTestData data1 = { .n = 0, .max = 1 }; 247 248 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1); 249 250 qemu_bh_schedule(data1.bh); 251 g_assert_cmpint(data1.n, ==, 0); 252 253 while (data1.n < data1.max) { 254 aio_poll(ctx, true); 255 } 256 g_assert_cmpint(data1.n, ==, data1.max); 257 g_assert(data1.bh == NULL); 258 259 g_assert(!aio_poll(ctx, false)); 260 } 261 262 static void test_bh_delete_from_cb_many(void) 263 { 264 BHTestData data1 = { .n = 0, .max = 1 }; 265 BHTestData data2 = { .n = 0, .max = 3 }; 266 BHTestData data3 = { .n = 0, .max = 2 }; 267 BHTestData data4 = { .n = 0, .max = 4 }; 268 269 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1); 270 data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2); 271 data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3); 272 data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4); 273 274 qemu_bh_schedule(data1.bh); 275 qemu_bh_schedule(data2.bh); 276 qemu_bh_schedule(data3.bh); 277 qemu_bh_schedule(data4.bh); 278 g_assert_cmpint(data1.n, ==, 0); 279 g_assert_cmpint(data2.n, ==, 0); 280 g_assert_cmpint(data3.n, ==, 0); 281 g_assert_cmpint(data4.n, ==, 0); 282 283 g_assert(aio_poll(ctx, false)); 284 g_assert_cmpint(data1.n, ==, 1); 285 g_assert_cmpint(data2.n, ==, 1); 286 g_assert_cmpint(data3.n, ==, 1); 287 g_assert_cmpint(data4.n, ==, 1); 288 g_assert(data1.bh == NULL); 289 290 while (data1.n < data1.max || 291 data2.n < data2.max || 292 data3.n < data3.max || 293 data4.n < data4.max) { 294 aio_poll(ctx, true); 295 } 296 g_assert_cmpint(data1.n, ==, data1.max); 297 g_assert_cmpint(data2.n, ==, data2.max); 298 g_assert_cmpint(data3.n, ==, data3.max); 299 g_assert_cmpint(data4.n, ==, data4.max); 300 g_assert(data1.bh == NULL); 301 g_assert(data2.bh == NULL); 302 g_assert(data3.bh == NULL); 303 g_assert(data4.bh == NULL); 304 } 305 306 static void test_bh_flush(void) 307 { 308 BHTestData data = { .n = 0 }; 309 data.bh = aio_bh_new(ctx, bh_test_cb, &data); 310 311 qemu_bh_schedule(data.bh); 312 g_assert_cmpint(data.n, ==, 0); 313 314 g_assert(aio_poll(ctx, true)); 315 g_assert_cmpint(data.n, ==, 1); 316 317 g_assert(!aio_poll(ctx, false)); 318 g_assert_cmpint(data.n, ==, 1); 319 qemu_bh_delete(data.bh); 320 } 321 322 static void test_set_event_notifier(void) 323 { 324 EventNotifierTestData data = { .n = 0, .active = 0 }; 325 event_notifier_init(&data.e, false); 326 set_event_notifier(ctx, &data.e, event_ready_cb); 327 g_assert(!aio_poll(ctx, false)); 328 g_assert_cmpint(data.n, ==, 0); 329 330 set_event_notifier(ctx, &data.e, NULL); 331 g_assert(!aio_poll(ctx, false)); 332 g_assert_cmpint(data.n, ==, 0); 333 event_notifier_cleanup(&data.e); 334 } 335 336 static void test_wait_event_notifier(void) 337 { 338 EventNotifierTestData data = { .n = 0, .active = 1 }; 339 event_notifier_init(&data.e, false); 340 set_event_notifier(ctx, &data.e, event_ready_cb); 341 while (aio_poll(ctx, false)); 342 g_assert_cmpint(data.n, ==, 0); 343 g_assert_cmpint(data.active, ==, 1); 344 345 event_notifier_set(&data.e); 346 g_assert(aio_poll(ctx, false)); 347 g_assert_cmpint(data.n, ==, 1); 348 g_assert_cmpint(data.active, ==, 0); 349 350 g_assert(!aio_poll(ctx, false)); 351 g_assert_cmpint(data.n, ==, 1); 352 g_assert_cmpint(data.active, ==, 0); 353 354 set_event_notifier(ctx, &data.e, NULL); 355 g_assert(!aio_poll(ctx, false)); 356 g_assert_cmpint(data.n, ==, 1); 357 358 event_notifier_cleanup(&data.e); 359 } 360 361 static void test_flush_event_notifier(void) 362 { 363 EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true }; 364 event_notifier_init(&data.e, false); 365 set_event_notifier(ctx, &data.e, event_ready_cb); 366 while (aio_poll(ctx, false)); 367 g_assert_cmpint(data.n, ==, 0); 368 g_assert_cmpint(data.active, ==, 10); 369 370 event_notifier_set(&data.e); 371 g_assert(aio_poll(ctx, false)); 372 g_assert_cmpint(data.n, ==, 1); 373 g_assert_cmpint(data.active, ==, 9); 374 g_assert(aio_poll(ctx, false)); 375 376 wait_until_inactive(&data); 377 g_assert_cmpint(data.n, ==, 10); 378 g_assert_cmpint(data.active, ==, 0); 379 g_assert(!aio_poll(ctx, false)); 380 381 set_event_notifier(ctx, &data.e, NULL); 382 g_assert(!aio_poll(ctx, false)); 383 event_notifier_cleanup(&data.e); 384 } 385 386 static void test_wait_event_notifier_noflush(void) 387 { 388 EventNotifierTestData data = { .n = 0 }; 389 EventNotifierTestData dummy = { .n = 0, .active = 1 }; 390 391 event_notifier_init(&data.e, false); 392 set_event_notifier(ctx, &data.e, event_ready_cb); 393 394 g_assert(!aio_poll(ctx, false)); 395 g_assert_cmpint(data.n, ==, 0); 396 397 /* Until there is an active descriptor, aio_poll may or may not call 398 * event_ready_cb. Still, it must not block. */ 399 event_notifier_set(&data.e); 400 g_assert(aio_poll(ctx, true)); 401 data.n = 0; 402 403 /* An active event notifier forces aio_poll to look at EventNotifiers. */ 404 event_notifier_init(&dummy.e, false); 405 set_event_notifier(ctx, &dummy.e, event_ready_cb); 406 407 event_notifier_set(&data.e); 408 g_assert(aio_poll(ctx, false)); 409 g_assert_cmpint(data.n, ==, 1); 410 g_assert(!aio_poll(ctx, false)); 411 g_assert_cmpint(data.n, ==, 1); 412 413 event_notifier_set(&data.e); 414 g_assert(aio_poll(ctx, false)); 415 g_assert_cmpint(data.n, ==, 2); 416 g_assert(!aio_poll(ctx, false)); 417 g_assert_cmpint(data.n, ==, 2); 418 419 event_notifier_set(&dummy.e); 420 wait_until_inactive(&dummy); 421 g_assert_cmpint(data.n, ==, 2); 422 g_assert_cmpint(dummy.n, ==, 1); 423 g_assert_cmpint(dummy.active, ==, 0); 424 425 set_event_notifier(ctx, &dummy.e, NULL); 426 event_notifier_cleanup(&dummy.e); 427 428 set_event_notifier(ctx, &data.e, NULL); 429 g_assert(!aio_poll(ctx, false)); 430 g_assert_cmpint(data.n, ==, 2); 431 432 event_notifier_cleanup(&data.e); 433 } 434 435 static void test_timer_schedule(void) 436 { 437 TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL, 438 .max = 2, 439 .clock_type = QEMU_CLOCK_REALTIME }; 440 EventNotifier e; 441 442 /* aio_poll will not block to wait for timers to complete unless it has 443 * an fd to wait on. Fixing this breaks other tests. So create a dummy one. 444 */ 445 event_notifier_init(&e, false); 446 set_event_notifier(ctx, &e, dummy_io_handler_read); 447 aio_poll(ctx, false); 448 449 aio_timer_init(ctx, &data.timer, data.clock_type, 450 SCALE_NS, timer_test_cb, &data); 451 timer_mod(&data.timer, 452 qemu_clock_get_ns(data.clock_type) + 453 data.ns); 454 455 g_assert_cmpint(data.n, ==, 0); 456 457 /* timer_mod may well cause an event notifier to have gone off, 458 * so clear that 459 */ 460 do {} while (aio_poll(ctx, false)); 461 462 g_assert(!aio_poll(ctx, false)); 463 g_assert_cmpint(data.n, ==, 0); 464 465 g_usleep(1 * G_USEC_PER_SEC); 466 g_assert_cmpint(data.n, ==, 0); 467 468 g_assert(aio_poll(ctx, false)); 469 g_assert_cmpint(data.n, ==, 1); 470 471 /* timer_mod called by our callback */ 472 do {} while (aio_poll(ctx, false)); 473 474 g_assert(!aio_poll(ctx, false)); 475 g_assert_cmpint(data.n, ==, 1); 476 477 g_assert(aio_poll(ctx, true)); 478 g_assert_cmpint(data.n, ==, 2); 479 480 /* As max is now 2, an event notifier should not have gone off */ 481 482 g_assert(!aio_poll(ctx, false)); 483 g_assert_cmpint(data.n, ==, 2); 484 485 set_event_notifier(ctx, &e, NULL); 486 event_notifier_cleanup(&e); 487 488 timer_del(&data.timer); 489 } 490 491 /* Now the same tests, using the context as a GSource. They are 492 * very similar to the ones above, with g_main_context_iteration 493 * replacing aio_poll. However: 494 * - sometimes both the AioContext and the glib main loop wake 495 * themselves up. Hence, some "g_assert(!aio_poll(ctx, false));" 496 * are replaced by "while (g_main_context_iteration(NULL, false));". 497 * - there is no exact replacement for a blocking wait. 498 * "while (g_main_context_iteration(NULL, true)" seems to work, 499 * but it is not documented _why_ it works. For these tests a 500 * non-blocking loop like "while (g_main_context_iteration(NULL, false)" 501 * works well, and that's what I am using. 502 */ 503 504 static 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 512 static 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 528 static 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 550 static 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 566 static 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 581 static 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 assert(g_main_context_iteration(NULL, false)); 595 assert(!g_main_context_iteration(NULL, false)); 596 } 597 598 static void test_source_bh_delete_from_cb_many(void) 599 { 600 BHTestData data1 = { .n = 0, .max = 1 }; 601 BHTestData data2 = { .n = 0, .max = 3 }; 602 BHTestData data3 = { .n = 0, .max = 2 }; 603 BHTestData data4 = { .n = 0, .max = 4 }; 604 605 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1); 606 data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2); 607 data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3); 608 data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4); 609 610 qemu_bh_schedule(data1.bh); 611 qemu_bh_schedule(data2.bh); 612 qemu_bh_schedule(data3.bh); 613 qemu_bh_schedule(data4.bh); 614 g_assert_cmpint(data1.n, ==, 0); 615 g_assert_cmpint(data2.n, ==, 0); 616 g_assert_cmpint(data3.n, ==, 0); 617 g_assert_cmpint(data4.n, ==, 0); 618 619 g_assert(g_main_context_iteration(NULL, false)); 620 g_assert_cmpint(data1.n, ==, 1); 621 g_assert_cmpint(data2.n, ==, 1); 622 g_assert_cmpint(data3.n, ==, 1); 623 g_assert_cmpint(data4.n, ==, 1); 624 g_assert(data1.bh == NULL); 625 626 while (g_main_context_iteration(NULL, false)); 627 g_assert_cmpint(data1.n, ==, data1.max); 628 g_assert_cmpint(data2.n, ==, data2.max); 629 g_assert_cmpint(data3.n, ==, data3.max); 630 g_assert_cmpint(data4.n, ==, data4.max); 631 g_assert(data1.bh == NULL); 632 g_assert(data2.bh == NULL); 633 g_assert(data3.bh == NULL); 634 g_assert(data4.bh == NULL); 635 } 636 637 static void test_source_bh_flush(void) 638 { 639 BHTestData data = { .n = 0 }; 640 data.bh = aio_bh_new(ctx, bh_test_cb, &data); 641 642 qemu_bh_schedule(data.bh); 643 g_assert_cmpint(data.n, ==, 0); 644 645 g_assert(g_main_context_iteration(NULL, true)); 646 g_assert_cmpint(data.n, ==, 1); 647 648 g_assert(!g_main_context_iteration(NULL, false)); 649 g_assert_cmpint(data.n, ==, 1); 650 qemu_bh_delete(data.bh); 651 } 652 653 static void test_source_set_event_notifier(void) 654 { 655 EventNotifierTestData data = { .n = 0, .active = 0 }; 656 event_notifier_init(&data.e, false); 657 set_event_notifier(ctx, &data.e, event_ready_cb); 658 while (g_main_context_iteration(NULL, false)); 659 g_assert_cmpint(data.n, ==, 0); 660 661 set_event_notifier(ctx, &data.e, NULL); 662 while (g_main_context_iteration(NULL, false)); 663 g_assert_cmpint(data.n, ==, 0); 664 event_notifier_cleanup(&data.e); 665 } 666 667 static void test_source_wait_event_notifier(void) 668 { 669 EventNotifierTestData data = { .n = 0, .active = 1 }; 670 event_notifier_init(&data.e, false); 671 set_event_notifier(ctx, &data.e, event_ready_cb); 672 while (g_main_context_iteration(NULL, false)); 673 g_assert_cmpint(data.n, ==, 0); 674 g_assert_cmpint(data.active, ==, 1); 675 676 event_notifier_set(&data.e); 677 g_assert(g_main_context_iteration(NULL, false)); 678 g_assert_cmpint(data.n, ==, 1); 679 g_assert_cmpint(data.active, ==, 0); 680 681 while (g_main_context_iteration(NULL, false)); 682 g_assert_cmpint(data.n, ==, 1); 683 g_assert_cmpint(data.active, ==, 0); 684 685 set_event_notifier(ctx, &data.e, NULL); 686 while (g_main_context_iteration(NULL, false)); 687 g_assert_cmpint(data.n, ==, 1); 688 689 event_notifier_cleanup(&data.e); 690 } 691 692 static void test_source_flush_event_notifier(void) 693 { 694 EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true }; 695 event_notifier_init(&data.e, false); 696 set_event_notifier(ctx, &data.e, event_ready_cb); 697 while (g_main_context_iteration(NULL, false)); 698 g_assert_cmpint(data.n, ==, 0); 699 g_assert_cmpint(data.active, ==, 10); 700 701 event_notifier_set(&data.e); 702 g_assert(g_main_context_iteration(NULL, false)); 703 g_assert_cmpint(data.n, ==, 1); 704 g_assert_cmpint(data.active, ==, 9); 705 g_assert(g_main_context_iteration(NULL, false)); 706 707 while (g_main_context_iteration(NULL, false)); 708 g_assert_cmpint(data.n, ==, 10); 709 g_assert_cmpint(data.active, ==, 0); 710 g_assert(!g_main_context_iteration(NULL, false)); 711 712 set_event_notifier(ctx, &data.e, NULL); 713 while (g_main_context_iteration(NULL, false)); 714 event_notifier_cleanup(&data.e); 715 } 716 717 static void test_source_wait_event_notifier_noflush(void) 718 { 719 EventNotifierTestData data = { .n = 0 }; 720 EventNotifierTestData dummy = { .n = 0, .active = 1 }; 721 722 event_notifier_init(&data.e, false); 723 set_event_notifier(ctx, &data.e, event_ready_cb); 724 725 while (g_main_context_iteration(NULL, false)); 726 g_assert_cmpint(data.n, ==, 0); 727 728 /* Until there is an active descriptor, glib may or may not call 729 * event_ready_cb. Still, it must not block. */ 730 event_notifier_set(&data.e); 731 g_main_context_iteration(NULL, true); 732 data.n = 0; 733 734 /* An active event notifier forces aio_poll to look at EventNotifiers. */ 735 event_notifier_init(&dummy.e, false); 736 set_event_notifier(ctx, &dummy.e, event_ready_cb); 737 738 event_notifier_set(&data.e); 739 g_assert(g_main_context_iteration(NULL, false)); 740 g_assert_cmpint(data.n, ==, 1); 741 g_assert(!g_main_context_iteration(NULL, false)); 742 g_assert_cmpint(data.n, ==, 1); 743 744 event_notifier_set(&data.e); 745 g_assert(g_main_context_iteration(NULL, false)); 746 g_assert_cmpint(data.n, ==, 2); 747 g_assert(!g_main_context_iteration(NULL, false)); 748 g_assert_cmpint(data.n, ==, 2); 749 750 event_notifier_set(&dummy.e); 751 while (g_main_context_iteration(NULL, false)); 752 g_assert_cmpint(data.n, ==, 2); 753 g_assert_cmpint(dummy.n, ==, 1); 754 g_assert_cmpint(dummy.active, ==, 0); 755 756 set_event_notifier(ctx, &dummy.e, NULL); 757 event_notifier_cleanup(&dummy.e); 758 759 set_event_notifier(ctx, &data.e, NULL); 760 while (g_main_context_iteration(NULL, false)); 761 g_assert_cmpint(data.n, ==, 2); 762 763 event_notifier_cleanup(&data.e); 764 } 765 766 static void test_source_timer_schedule(void) 767 { 768 TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL, 769 .max = 2, 770 .clock_type = QEMU_CLOCK_REALTIME }; 771 EventNotifier e; 772 int64_t expiry; 773 774 /* aio_poll will not block to wait for timers to complete unless it has 775 * an fd to wait on. Fixing this breaks other tests. So create a dummy one. 776 */ 777 event_notifier_init(&e, false); 778 set_event_notifier(ctx, &e, dummy_io_handler_read); 779 do {} while (g_main_context_iteration(NULL, false)); 780 781 aio_timer_init(ctx, &data.timer, data.clock_type, 782 SCALE_NS, timer_test_cb, &data); 783 expiry = qemu_clock_get_ns(data.clock_type) + 784 data.ns; 785 timer_mod(&data.timer, expiry); 786 787 g_assert_cmpint(data.n, ==, 0); 788 789 g_usleep(1 * G_USEC_PER_SEC); 790 g_assert_cmpint(data.n, ==, 0); 791 792 g_assert(g_main_context_iteration(NULL, true)); 793 g_assert_cmpint(data.n, ==, 1); 794 expiry += data.ns; 795 796 while (data.n < 2) { 797 g_main_context_iteration(NULL, true); 798 } 799 800 g_assert_cmpint(data.n, ==, 2); 801 g_assert(qemu_clock_get_ns(data.clock_type) > expiry); 802 803 set_event_notifier(ctx, &e, NULL); 804 event_notifier_cleanup(&e); 805 806 timer_del(&data.timer); 807 } 808 809 /* 810 * Check that aio_co_enter() can chain many times 811 * 812 * Two coroutines should be able to invoke each other via aio_co_enter() many 813 * times without hitting a limit like stack exhaustion. In other words, the 814 * calls should be chained instead of nested. 815 */ 816 817 typedef struct { 818 Coroutine *other; 819 unsigned i; 820 unsigned max; 821 } ChainData; 822 823 static void coroutine_fn chain(void *opaque) 824 { 825 ChainData *data = opaque; 826 827 for (data->i = 0; data->i < data->max; data->i++) { 828 /* Queue up the other coroutine... */ 829 aio_co_enter(ctx, data->other); 830 831 /* ...and give control to it */ 832 qemu_coroutine_yield(); 833 } 834 } 835 836 static void test_queue_chaining(void) 837 { 838 /* This number of iterations hit stack exhaustion in the past: */ 839 ChainData data_a = { .max = 25000 }; 840 ChainData data_b = { .max = 25000 }; 841 842 data_b.other = qemu_coroutine_create(chain, &data_a); 843 data_a.other = qemu_coroutine_create(chain, &data_b); 844 845 qemu_coroutine_enter(data_b.other); 846 847 g_assert_cmpint(data_a.i, ==, data_a.max); 848 g_assert_cmpint(data_b.i, ==, data_b.max - 1); 849 850 /* Allow the second coroutine to terminate */ 851 qemu_coroutine_enter(data_a.other); 852 853 g_assert_cmpint(data_b.i, ==, data_b.max); 854 } 855 856 static void co_check_current_thread(void *opaque) 857 { 858 QemuThread *main_thread = opaque; 859 assert(qemu_thread_is_self(main_thread)); 860 } 861 862 static void *test_aio_co_enter(void *co) 863 { 864 /* 865 * qemu_get_current_aio_context() should not to be the main thread 866 * AioContext, because this is a worker thread that has not taken 867 * the BQL. So aio_co_enter will schedule the coroutine in the 868 * main thread AioContext. 869 */ 870 aio_co_enter(qemu_get_aio_context(), co); 871 return NULL; 872 } 873 874 static void test_worker_thread_co_enter(void) 875 { 876 QemuThread this_thread, worker_thread; 877 Coroutine *co; 878 879 qemu_thread_get_self(&this_thread); 880 co = qemu_coroutine_create(co_check_current_thread, &this_thread); 881 882 qemu_thread_create(&worker_thread, "test_acquire_thread", 883 test_aio_co_enter, 884 co, QEMU_THREAD_JOINABLE); 885 886 /* Test aio_co_enter from a worker thread. */ 887 qemu_thread_join(&worker_thread); 888 g_assert(aio_poll(ctx, true)); 889 g_assert(!aio_poll(ctx, false)); 890 } 891 892 /* End of tests. */ 893 894 int main(int argc, char **argv) 895 { 896 qemu_init_main_loop(&error_fatal); 897 ctx = qemu_get_aio_context(); 898 899 while (g_main_context_iteration(NULL, false)); 900 901 g_test_init(&argc, &argv, NULL); 902 g_test_add_func("/aio/acquire", test_acquire); 903 g_test_add_func("/aio/bh/schedule", test_bh_schedule); 904 g_test_add_func("/aio/bh/schedule10", test_bh_schedule10); 905 g_test_add_func("/aio/bh/cancel", test_bh_cancel); 906 g_test_add_func("/aio/bh/delete", test_bh_delete); 907 g_test_add_func("/aio/bh/callback-delete/one", test_bh_delete_from_cb); 908 g_test_add_func("/aio/bh/callback-delete/many", test_bh_delete_from_cb_many); 909 g_test_add_func("/aio/bh/flush", test_bh_flush); 910 g_test_add_func("/aio/event/add-remove", test_set_event_notifier); 911 g_test_add_func("/aio/event/wait", test_wait_event_notifier); 912 g_test_add_func("/aio/event/wait/no-flush-cb", test_wait_event_notifier_noflush); 913 g_test_add_func("/aio/event/flush", test_flush_event_notifier); 914 g_test_add_func("/aio/timer/schedule", test_timer_schedule); 915 916 g_test_add_func("/aio/coroutine/queue-chaining", test_queue_chaining); 917 g_test_add_func("/aio/coroutine/worker-thread-co-enter", test_worker_thread_co_enter); 918 919 g_test_add_func("/aio-gsource/flush", test_source_flush); 920 g_test_add_func("/aio-gsource/bh/schedule", test_source_bh_schedule); 921 g_test_add_func("/aio-gsource/bh/schedule10", test_source_bh_schedule10); 922 g_test_add_func("/aio-gsource/bh/cancel", test_source_bh_cancel); 923 g_test_add_func("/aio-gsource/bh/delete", test_source_bh_delete); 924 g_test_add_func("/aio-gsource/bh/callback-delete/one", test_source_bh_delete_from_cb); 925 g_test_add_func("/aio-gsource/bh/callback-delete/many", test_source_bh_delete_from_cb_many); 926 g_test_add_func("/aio-gsource/bh/flush", test_source_bh_flush); 927 g_test_add_func("/aio-gsource/event/add-remove", test_source_set_event_notifier); 928 g_test_add_func("/aio-gsource/event/wait", test_source_wait_event_notifier); 929 g_test_add_func("/aio-gsource/event/wait/no-flush-cb", test_source_wait_event_notifier_noflush); 930 g_test_add_func("/aio-gsource/event/flush", test_source_flush_event_notifier); 931 g_test_add_func("/aio-gsource/timer/schedule", test_source_timer_schedule); 932 return g_test_run(); 933 } 934