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