tests/unit/test-aio.c

   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 *ctx, EventNotifier *notifier,
 131                                EventNotifierHandler *handler)
 132 {
 133     aio_set_event_notifier(ctx, notifier, false, 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_aio_external_client(void)
 387 {
 388     int i, j;
 389
 390     for (i = 1; i < 3; i++) {
 391         EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
 392         event_notifier_init(&data.e, false);
 393         aio_set_event_notifier(ctx, &data.e, true, event_ready_cb, NULL, NULL);
 394         event_notifier_set(&data.e);
 395         for (j = 0; j < i; j++) {
 396             aio_disable_external(ctx);
 397         }
 398         for (j = 0; j < i; j++) {
 399             assert(!aio_poll(ctx, false));
 400             assert(event_notifier_test_and_clear(&data.e));
 401             event_notifier_set(&data.e);
 402             aio_enable_external(ctx);
 403         }
 404         assert(aio_poll(ctx, false));
 405         set_event_notifier(ctx, &data.e, NULL);
 406         event_notifier_cleanup(&data.e);
 407     }
 408 }
 409
 410 static void test_wait_event_notifier_noflush(void)
 411 {
 412     EventNotifierTestData data = { .n = 0 };
 413     EventNotifierTestData dummy = { .n = 0, .active = 1 };
 414
 415     event_notifier_init(&data.e, false);
 416     set_event_notifier(ctx, &data.e, event_ready_cb);
 417
 418     g_assert(!aio_poll(ctx, false));
 419     g_assert_cmpint(data.n, ==, 0);
 420
 421     /* Until there is an active descriptor, aio_poll may or may not call
 422      * event_ready_cb.  Still, it must not block.  */
 423     event_notifier_set(&data.e);
 424     g_assert(aio_poll(ctx, true));
 425     data.n = 0;
 426
 427     /* An active event notifier forces aio_poll to look at EventNotifiers.  */
 428     event_notifier_init(&dummy.e, false);
 429     set_event_notifier(ctx, &dummy.e, event_ready_cb);
 430
 431     event_notifier_set(&data.e);
 432     g_assert(aio_poll(ctx, false));
 433     g_assert_cmpint(data.n, ==, 1);
 434     g_assert(!aio_poll(ctx, false));
 435     g_assert_cmpint(data.n, ==, 1);
 436
 437     event_notifier_set(&data.e);
 438     g_assert(aio_poll(ctx, false));
 439     g_assert_cmpint(data.n, ==, 2);
 440     g_assert(!aio_poll(ctx, false));
 441     g_assert_cmpint(data.n, ==, 2);
 442
 443     event_notifier_set(&dummy.e);
 444     wait_until_inactive(&dummy);
 445     g_assert_cmpint(data.n, ==, 2);
 446     g_assert_cmpint(dummy.n, ==, 1);
 447     g_assert_cmpint(dummy.active, ==, 0);
 448
 449     set_event_notifier(ctx, &dummy.e, NULL);
 450     event_notifier_cleanup(&dummy.e);
 451
 452     set_event_notifier(ctx, &data.e, NULL);
 453     g_assert(!aio_poll(ctx, false));
 454     g_assert_cmpint(data.n, ==, 2);
 455
 456     event_notifier_cleanup(&data.e);
 457 }
 458
 459 static void test_timer_schedule(void)
 460 {
 461     TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL,
 462                            .max = 2,
 463                            .clock_type = QEMU_CLOCK_REALTIME };
 464     EventNotifier e;
 465
 466     /* aio_poll will not block to wait for timers to complete unless it has
 467      * an fd to wait on. Fixing this breaks other tests. So create a dummy one.
 468      */
 469     event_notifier_init(&e, false);
 470     set_event_notifier(ctx, &e, dummy_io_handler_read);
 471     aio_poll(ctx, false);
 472
 473     aio_timer_init(ctx, &data.timer, data.clock_type,
 474                    SCALE_NS, timer_test_cb, &data);
 475     timer_mod(&data.timer,
 476               qemu_clock_get_ns(data.clock_type) +
 477               data.ns);
 478
 479     g_assert_cmpint(data.n, ==, 0);
 480
 481     /* timer_mod may well cause an event notifer to have gone off,
 482      * so clear that
 483      */
 484     do {} while (aio_poll(ctx, false));
 485
 486     g_assert(!aio_poll(ctx, false));
 487     g_assert_cmpint(data.n, ==, 0);
 488
 489     g_usleep(1 * G_USEC_PER_SEC);
 490     g_assert_cmpint(data.n, ==, 0);
 491
 492     g_assert(aio_poll(ctx, false));
 493     g_assert_cmpint(data.n, ==, 1);
 494
 495     /* timer_mod called by our callback */
 496     do {} while (aio_poll(ctx, false));
 497
 498     g_assert(!aio_poll(ctx, false));
 499     g_assert_cmpint(data.n, ==, 1);
 500
 501     g_assert(aio_poll(ctx, true));
 502     g_assert_cmpint(data.n, ==, 2);
 503
 504     /* As max is now 2, an event notifier should not have gone off */
 505
 506     g_assert(!aio_poll(ctx, false));
 507     g_assert_cmpint(data.n, ==, 2);
 508
 509     set_event_notifier(ctx, &e, NULL);
 510     event_notifier_cleanup(&e);
 511
 512     timer_del(&data.timer);
 513 }
 514
 515 /* Now the same tests, using the context as a GSource.  They are
 516  * very similar to the ones above, with g_main_context_iteration
 517  * replacing aio_poll.  However:
 518  * - sometimes both the AioContext and the glib main loop wake
 519  *   themselves up.  Hence, some "g_assert(!aio_poll(ctx, false));"
 520  *   are replaced by "while (g_main_context_iteration(NULL, false));".
 521  * - there is no exact replacement for a blocking wait.
 522  *   "while (g_main_context_iteration(NULL, true)" seems to work,
 523  *   but it is not documented _why_ it works.  For these tests a
 524  *   non-blocking loop like "while (g_main_context_iteration(NULL, false)"
 525  *   works well, and that's what I am using.
 526  */
 527
 528 static void test_source_flush(void)
 529 {
 530     g_assert(!g_main_context_iteration(NULL, false));
 531     aio_notify(ctx);
 532     while (g_main_context_iteration(NULL, false));
 533     g_assert(!g_main_context_iteration(NULL, false));
 534 }
 535
 536 static void test_source_bh_schedule(void)
 537 {
 538     BHTestData data = { .n = 0 };
 539     data.bh = aio_bh_new(ctx, bh_test_cb, &data);
 540
 541     qemu_bh_schedule(data.bh);
 542     g_assert_cmpint(data.n, ==, 0);
 543
 544     g_assert(g_main_context_iteration(NULL, true));
 545     g_assert_cmpint(data.n, ==, 1);
 546
 547     g_assert(!g_main_context_iteration(NULL, false));
 548     g_assert_cmpint(data.n, ==, 1);
 549     qemu_bh_delete(data.bh);
 550 }
 551
 552 static void test_source_bh_schedule10(void)
 553 {
 554     BHTestData data = { .n = 0, .max = 10 };
 555     data.bh = aio_bh_new(ctx, bh_test_cb, &data);
 556
 557     qemu_bh_schedule(data.bh);
 558     g_assert_cmpint(data.n, ==, 0);
 559
 560     g_assert(g_main_context_iteration(NULL, false));
 561     g_assert_cmpint(data.n, ==, 1);
 562
 563     g_assert(g_main_context_iteration(NULL, true));
 564     g_assert_cmpint(data.n, ==, 2);
 565
 566     while (g_main_context_iteration(NULL, false));
 567     g_assert_cmpint(data.n, ==, 10);
 568
 569     g_assert(!g_main_context_iteration(NULL, false));
 570     g_assert_cmpint(data.n, ==, 10);
 571     qemu_bh_delete(data.bh);
 572 }
 573
 574 static void test_source_bh_cancel(void)
 575 {
 576     BHTestData data = { .n = 0 };
 577     data.bh = aio_bh_new(ctx, bh_test_cb, &data);
 578
 579     qemu_bh_schedule(data.bh);
 580     g_assert_cmpint(data.n, ==, 0);
 581
 582     qemu_bh_cancel(data.bh);
 583     g_assert_cmpint(data.n, ==, 0);
 584
 585     while (g_main_context_iteration(NULL, false));
 586     g_assert_cmpint(data.n, ==, 0);
 587     qemu_bh_delete(data.bh);
 588 }
 589
 590 static void test_source_bh_delete(void)
 591 {
 592     BHTestData data = { .n = 0 };
 593     data.bh = aio_bh_new(ctx, bh_test_cb, &data);
 594
 595     qemu_bh_schedule(data.bh);
 596     g_assert_cmpint(data.n, ==, 0);
 597
 598     qemu_bh_delete(data.bh);
 599     g_assert_cmpint(data.n, ==, 0);
 600
 601     while (g_main_context_iteration(NULL, false));
 602     g_assert_cmpint(data.n, ==, 0);
 603 }
 604
 605 static void test_source_bh_delete_from_cb(void)
 606 {
 607     BHTestData data1 = { .n = 0, .max = 1 };
 608
 609     data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
 610
 611     qemu_bh_schedule(data1.bh);
 612     g_assert_cmpint(data1.n, ==, 0);
 613
 614     g_main_context_iteration(NULL, true);
 615     g_assert_cmpint(data1.n, ==, data1.max);
 616     g_assert(data1.bh == NULL);
 617
 618     assert(g_main_context_iteration(NULL, false));
 619     assert(!g_main_context_iteration(NULL, false));
 620 }
 621
 622 static void test_source_bh_delete_from_cb_many(void)
 623 {
 624     BHTestData data1 = { .n = 0, .max = 1 };
 625     BHTestData data2 = { .n = 0, .max = 3 };
 626     BHTestData data3 = { .n = 0, .max = 2 };
 627     BHTestData data4 = { .n = 0, .max = 4 };
 628
 629     data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
 630     data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2);
 631     data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3);
 632     data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4);
 633
 634     qemu_bh_schedule(data1.bh);
 635     qemu_bh_schedule(data2.bh);
 636     qemu_bh_schedule(data3.bh);
 637     qemu_bh_schedule(data4.bh);
 638     g_assert_cmpint(data1.n, ==, 0);
 639     g_assert_cmpint(data2.n, ==, 0);
 640     g_assert_cmpint(data3.n, ==, 0);
 641     g_assert_cmpint(data4.n, ==, 0);
 642
 643     g_assert(g_main_context_iteration(NULL, false));
 644     g_assert_cmpint(data1.n, ==, 1);
 645     g_assert_cmpint(data2.n, ==, 1);
 646     g_assert_cmpint(data3.n, ==, 1);
 647     g_assert_cmpint(data4.n, ==, 1);
 648     g_assert(data1.bh == NULL);
 649
 650     while (g_main_context_iteration(NULL, false));
 651     g_assert_cmpint(data1.n, ==, data1.max);
 652     g_assert_cmpint(data2.n, ==, data2.max);
 653     g_assert_cmpint(data3.n, ==, data3.max);
 654     g_assert_cmpint(data4.n, ==, data4.max);
 655     g_assert(data1.bh == NULL);
 656     g_assert(data2.bh == NULL);
 657     g_assert(data3.bh == NULL);
 658     g_assert(data4.bh == NULL);
 659 }
 660
 661 static void test_source_bh_flush(void)
 662 {
 663     BHTestData data = { .n = 0 };
 664     data.bh = aio_bh_new(ctx, bh_test_cb, &data);
 665
 666     qemu_bh_schedule(data.bh);
 667     g_assert_cmpint(data.n, ==, 0);
 668
 669     g_assert(g_main_context_iteration(NULL, true));
 670     g_assert_cmpint(data.n, ==, 1);
 671
 672     g_assert(!g_main_context_iteration(NULL, false));
 673     g_assert_cmpint(data.n, ==, 1);
 674     qemu_bh_delete(data.bh);
 675 }
 676
 677 static void test_source_set_event_notifier(void)
 678 {
 679     EventNotifierTestData data = { .n = 0, .active = 0 };
 680     event_notifier_init(&data.e, false);
 681     set_event_notifier(ctx, &data.e, event_ready_cb);
 682     while (g_main_context_iteration(NULL, false));
 683     g_assert_cmpint(data.n, ==, 0);
 684
 685     set_event_notifier(ctx, &data.e, NULL);
 686     while (g_main_context_iteration(NULL, false));
 687     g_assert_cmpint(data.n, ==, 0);
 688     event_notifier_cleanup(&data.e);
 689 }
 690
 691 static void test_source_wait_event_notifier(void)
 692 {
 693     EventNotifierTestData data = { .n = 0, .active = 1 };
 694     event_notifier_init(&data.e, false);
 695     set_event_notifier(ctx, &data.e, event_ready_cb);
 696     while (g_main_context_iteration(NULL, false));
 697     g_assert_cmpint(data.n, ==, 0);
 698     g_assert_cmpint(data.active, ==, 1);
 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, ==, 0);
 704
 705     while (g_main_context_iteration(NULL, false));
 706     g_assert_cmpint(data.n, ==, 1);
 707     g_assert_cmpint(data.active, ==, 0);
 708
 709     set_event_notifier(ctx, &data.e, NULL);
 710     while (g_main_context_iteration(NULL, false));
 711     g_assert_cmpint(data.n, ==, 1);
 712
 713     event_notifier_cleanup(&data.e);
 714 }
 715
 716 static void test_source_flush_event_notifier(void)
 717 {
 718     EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
 719     event_notifier_init(&data.e, false);
 720     set_event_notifier(ctx, &data.e, event_ready_cb);
 721     while (g_main_context_iteration(NULL, false));
 722     g_assert_cmpint(data.n, ==, 0);
 723     g_assert_cmpint(data.active, ==, 10);
 724
 725     event_notifier_set(&data.e);
 726     g_assert(g_main_context_iteration(NULL, false));
 727     g_assert_cmpint(data.n, ==, 1);
 728     g_assert_cmpint(data.active, ==, 9);
 729     g_assert(g_main_context_iteration(NULL, false));
 730
 731     while (g_main_context_iteration(NULL, false));
 732     g_assert_cmpint(data.n, ==, 10);
 733     g_assert_cmpint(data.active, ==, 0);
 734     g_assert(!g_main_context_iteration(NULL, false));
 735
 736     set_event_notifier(ctx, &data.e, NULL);
 737     while (g_main_context_iteration(NULL, false));
 738     event_notifier_cleanup(&data.e);
 739 }
 740
 741 static void test_source_wait_event_notifier_noflush(void)
 742 {
 743     EventNotifierTestData data = { .n = 0 };
 744     EventNotifierTestData dummy = { .n = 0, .active = 1 };
 745
 746     event_notifier_init(&data.e, false);
 747     set_event_notifier(ctx, &data.e, event_ready_cb);
 748
 749     while (g_main_context_iteration(NULL, false));
 750     g_assert_cmpint(data.n, ==, 0);
 751
 752     /* Until there is an active descriptor, glib may or may not call
 753      * event_ready_cb.  Still, it must not block.  */
 754     event_notifier_set(&data.e);
 755     g_main_context_iteration(NULL, true);
 756     data.n = 0;
 757
 758     /* An active event notifier forces aio_poll to look at EventNotifiers.  */
 759     event_notifier_init(&dummy.e, false);
 760     set_event_notifier(ctx, &dummy.e, event_ready_cb);
 761
 762     event_notifier_set(&data.e);
 763     g_assert(g_main_context_iteration(NULL, false));
 764     g_assert_cmpint(data.n, ==, 1);
 765     g_assert(!g_main_context_iteration(NULL, false));
 766     g_assert_cmpint(data.n, ==, 1);
 767
 768     event_notifier_set(&data.e);
 769     g_assert(g_main_context_iteration(NULL, false));
 770     g_assert_cmpint(data.n, ==, 2);
 771     g_assert(!g_main_context_iteration(NULL, false));
 772     g_assert_cmpint(data.n, ==, 2);
 773
 774     event_notifier_set(&dummy.e);
 775     while (g_main_context_iteration(NULL, false));
 776     g_assert_cmpint(data.n, ==, 2);
 777     g_assert_cmpint(dummy.n, ==, 1);
 778     g_assert_cmpint(dummy.active, ==, 0);
 779
 780     set_event_notifier(ctx, &dummy.e, NULL);
 781     event_notifier_cleanup(&dummy.e);
 782
 783     set_event_notifier(ctx, &data.e, NULL);
 784     while (g_main_context_iteration(NULL, false));
 785     g_assert_cmpint(data.n, ==, 2);
 786
 787     event_notifier_cleanup(&data.e);
 788 }
 789
 790 static void test_source_timer_schedule(void)
 791 {
 792     TimerTestData data = { .n = 0, .ctx = ctx, .ns = SCALE_MS * 750LL,
 793                            .max = 2,
 794                            .clock_type = QEMU_CLOCK_REALTIME };
 795     EventNotifier e;
 796     int64_t expiry;
 797
 798     /* aio_poll will not block to wait for timers to complete unless it has
 799      * an fd to wait on. Fixing this breaks other tests. So create a dummy one.
 800      */
 801     event_notifier_init(&e, false);
 802     set_event_notifier(ctx, &e, dummy_io_handler_read);
 803     do {} while (g_main_context_iteration(NULL, false));
 804
 805     aio_timer_init(ctx, &data.timer, data.clock_type,
 806                    SCALE_NS, timer_test_cb, &data);
 807     expiry = qemu_clock_get_ns(data.clock_type) +
 808         data.ns;
 809     timer_mod(&data.timer, expiry);
 810
 811     g_assert_cmpint(data.n, ==, 0);
 812
 813     g_usleep(1 * G_USEC_PER_SEC);
 814     g_assert_cmpint(data.n, ==, 0);
 815
 816     g_assert(g_main_context_iteration(NULL, true));
 817     g_assert_cmpint(data.n, ==, 1);
 818     expiry += data.ns;
 819
 820     while (data.n < 2) {
 821         g_main_context_iteration(NULL, true);
 822     }
 823
 824     g_assert_cmpint(data.n, ==, 2);
 825     g_assert(qemu_clock_get_ns(data.clock_type) > expiry);
 826
 827     set_event_notifier(ctx, &e, NULL);
 828     event_notifier_cleanup(&e);
 829
 830     timer_del(&data.timer);
 831 }
 832
 833 /*
 834  * Check that aio_co_enter() can chain many times
 835  *
 836  * Two coroutines should be able to invoke each other via aio_co_enter() many
 837  * times without hitting a limit like stack exhaustion.  In other words, the
 838  * calls should be chained instead of nested.
 839  */
 840
 841 typedef struct {
 842     Coroutine *other;
 843     unsigned i;
 844     unsigned max;
 845 } ChainData;
 846
 847 static void coroutine_fn chain(void *opaque)
 848 {
 849     ChainData *data = opaque;
 850
 851     for (data->i = 0; data->i < data->max; data->i++) {
 852         /* Queue up the other coroutine... */
 853         aio_co_enter(ctx, data->other);
 854
 855         /* ...and give control to it */
 856         qemu_coroutine_yield();
 857     }
 858 }
 859
 860 static void test_queue_chaining(void)
 861 {
 862     /* This number of iterations hit stack exhaustion in the past: */
 863     ChainData data_a = { .max = 25000 };
 864     ChainData data_b = { .max = 25000 };
 865
 866     data_b.other = qemu_coroutine_create(chain, &data_a);
 867     data_a.other = qemu_coroutine_create(chain, &data_b);
 868
 869     qemu_coroutine_enter(data_b.other);
 870
 871     g_assert_cmpint(data_a.i, ==, data_a.max);
 872     g_assert_cmpint(data_b.i, ==, data_b.max - 1);
 873
 874     /* Allow the second coroutine to terminate */
 875     qemu_coroutine_enter(data_a.other);
 876
 877     g_assert_cmpint(data_b.i, ==, data_b.max);
 878 }
 879
 880 static void co_check_current_thread(void *opaque)
 881 {
 882     QemuThread *main_thread = opaque;
 883     assert(qemu_thread_is_self(main_thread));
 884 }
 885
 886 static void *test_aio_co_enter(void *co)
 887 {
 888     /*
 889      * qemu_get_current_aio_context() should not to be the main thread
 890      * AioContext, because this is a worker thread that has not taken
 891      * the BQL.  So aio_co_enter will schedule the coroutine in the
 892      * main thread AioContext.
 893      */
 894     aio_co_enter(qemu_get_aio_context(), co);
 895     return NULL;
 896 }
 897
 898 static void test_worker_thread_co_enter(void)
 899 {
 900     QemuThread this_thread, worker_thread;
 901     Coroutine *co;
 902
 903     qemu_thread_get_self(&this_thread);
 904     co = qemu_coroutine_create(co_check_current_thread, &this_thread);
 905
 906     qemu_thread_create(&worker_thread, "test_acquire_thread",
 907                        test_aio_co_enter,
 908                        co, QEMU_THREAD_JOINABLE);
 909
 910     /* Test aio_co_enter from a worker thread.  */
 911     qemu_thread_join(&worker_thread);
 912     g_assert(aio_poll(ctx, true));
 913     g_assert(!aio_poll(ctx, false));
 914 }
 915
 916 /* End of tests.  */
 917
 918 int main(int argc, char **argv)
 919 {
 920     qemu_init_main_loop(&error_fatal);
 921     ctx = qemu_get_aio_context();
 922
 923     while (g_main_context_iteration(NULL, false));
 924
 925     g_test_init(&argc, &argv, NULL);
 926     g_test_add_func("/aio/acquire",                 test_acquire);
 927     g_test_add_func("/aio/bh/schedule",             test_bh_schedule);
 928     g_test_add_func("/aio/bh/schedule10",           test_bh_schedule10);
 929     g_test_add_func("/aio/bh/cancel",               test_bh_cancel);
 930     g_test_add_func("/aio/bh/delete",               test_bh_delete);
 931     g_test_add_func("/aio/bh/callback-delete/one",  test_bh_delete_from_cb);
 932     g_test_add_func("/aio/bh/callback-delete/many", test_bh_delete_from_cb_many);
 933     g_test_add_func("/aio/bh/flush",                test_bh_flush);
 934     g_test_add_func("/aio/event/add-remove",        test_set_event_notifier);
 935     g_test_add_func("/aio/event/wait",              test_wait_event_notifier);
 936     g_test_add_func("/aio/event/wait/no-flush-cb",  test_wait_event_notifier_noflush);
 937     g_test_add_func("/aio/event/flush",             test_flush_event_notifier);
 938     g_test_add_func("/aio/external-client",         test_aio_external_client);
 939     g_test_add_func("/aio/timer/schedule",          test_timer_schedule);
 940
 941     g_test_add_func("/aio/coroutine/queue-chaining", test_queue_chaining);
 942     g_test_add_func("/aio/coroutine/worker-thread-co-enter", test_worker_thread_co_enter);
 943
 944     g_test_add_func("/aio-gsource/flush",                   test_source_flush);
 945     g_test_add_func("/aio-gsource/bh/schedule",             test_source_bh_schedule);
 946     g_test_add_func("/aio-gsource/bh/schedule10",           test_source_bh_schedule10);
 947     g_test_add_func("/aio-gsource/bh/cancel",               test_source_bh_cancel);
 948     g_test_add_func("/aio-gsource/bh/delete",               test_source_bh_delete);
 949     g_test_add_func("/aio-gsource/bh/callback-delete/one",  test_source_bh_delete_from_cb);
 950     g_test_add_func("/aio-gsource/bh/callback-delete/many", test_source_bh_delete_from_cb_many);
 951     g_test_add_func("/aio-gsource/bh/flush",                test_source_bh_flush);
 952     g_test_add_func("/aio-gsource/event/add-remove",        test_source_set_event_notifier);
 953     g_test_add_func("/aio-gsource/event/wait",              test_source_wait_event_notifier);
 954     g_test_add_func("/aio-gsource/event/wait/no-flush-cb",  test_source_wait_event_notifier_noflush);
 955     g_test_add_func("/aio-gsource/event/flush",             test_source_flush_event_notifier);
 956     g_test_add_func("/aio-gsource/timer/schedule",          test_source_timer_schedule);
 957     return g_test_run();
 958 }