tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #define _GNU_SOURCE
   4 #include <asm/unistd.h>
   5 #include <linux/time_types.h>
   6 #include <poll.h>
   7 #include <unistd.h>
   8 #include <assert.h>
   9 #include <signal.h>
  10 #include <pthread.h>
  11 #include <sys/epoll.h>
  12 #include <sys/socket.h>
  13 #include <sys/eventfd.h>
  14 #include "../../kselftest_harness.h"
  15
  16 struct epoll_mtcontext
  17 {
  18         int efd[3];
  19         int sfd[4];
  20         volatile int count;
  21
  22         pthread_t main;
  23         pthread_t waiter;
  24 };
  25
  26 #ifndef __NR_epoll_pwait2
  27 #define __NR_epoll_pwait2 -1
  28 #endif
  29
  30 static inline int sys_epoll_pwait2(int fd, struct epoll_event *events,
  31                                    int maxevents,
  32                                    const struct __kernel_timespec *timeout,
  33                                    const sigset_t *sigset, size_t sigsetsize)
  34 {
  35         return syscall(__NR_epoll_pwait2, fd, events, maxevents, timeout,
  36                        sigset, sigsetsize);
  37 }
  38
  39 static void signal_handler(int signum)
  40 {
  41 }
  42
  43 static void kill_timeout(struct epoll_mtcontext *ctx)
  44 {
  45         usleep(1000000);
  46         pthread_kill(ctx->main, SIGUSR1);
  47         pthread_kill(ctx->waiter, SIGUSR1);
  48 }
  49
  50 static void *waiter_entry1a(void *data)
  51 {
  52         struct epoll_event e;
  53         struct epoll_mtcontext *ctx = data;
  54
  55         if (epoll_wait(ctx->efd[0], &e, 1, -1) > 0)
  56                 __sync_fetch_and_add(&ctx->count, 1);
  57
  58         return NULL;
  59 }
  60
  61 static void *waiter_entry1ap(void *data)
  62 {
  63         struct pollfd pfd;
  64         struct epoll_event e;
  65         struct epoll_mtcontext *ctx = data;
  66
  67         pfd.fd = ctx->efd[0];
  68         pfd.events = POLLIN;
  69         if (poll(&pfd, 1, -1) > 0) {
  70                 if (epoll_wait(ctx->efd[0], &e, 1, 0) > 0)
  71                         __sync_fetch_and_add(&ctx->count, 1);
  72         }
  73
  74         return NULL;
  75 }
  76
  77 static void *waiter_entry1o(void *data)
  78 {
  79         struct epoll_event e;
  80         struct epoll_mtcontext *ctx = data;
  81
  82         if (epoll_wait(ctx->efd[0], &e, 1, -1) > 0)
  83                 __sync_fetch_and_or(&ctx->count, 1);
  84
  85         return NULL;
  86 }
  87
  88 static void *waiter_entry1op(void *data)
  89 {
  90         struct pollfd pfd;
  91         struct epoll_event e;
  92         struct epoll_mtcontext *ctx = data;
  93
  94         pfd.fd = ctx->efd[0];
  95         pfd.events = POLLIN;
  96         if (poll(&pfd, 1, -1) > 0) {
  97                 if (epoll_wait(ctx->efd[0], &e, 1, 0) > 0)
  98                         __sync_fetch_and_or(&ctx->count, 1);
  99         }
 100
 101         return NULL;
 102 }
 103
 104 static void *waiter_entry2a(void *data)
 105 {
 106         struct epoll_event events[2];
 107         struct epoll_mtcontext *ctx = data;
 108
 109         if (epoll_wait(ctx->efd[0], events, 2, -1) > 0)
 110                 __sync_fetch_and_add(&ctx->count, 1);
 111
 112         return NULL;
 113 }
 114
 115 static void *waiter_entry2ap(void *data)
 116 {
 117         struct pollfd pfd;
 118         struct epoll_event events[2];
 119         struct epoll_mtcontext *ctx = data;
 120
 121         pfd.fd = ctx->efd[0];
 122         pfd.events = POLLIN;
 123         if (poll(&pfd, 1, -1) > 0) {
 124                 if (epoll_wait(ctx->efd[0], events, 2, 0) > 0)
 125                         __sync_fetch_and_add(&ctx->count, 1);
 126         }
 127
 128         return NULL;
 129 }
 130
 131 static void *emitter_entry1(void *data)
 132 {
 133         struct epoll_mtcontext *ctx = data;
 134
 135         usleep(100000);
 136         write(ctx->sfd[1], "w", 1);
 137
 138         kill_timeout(ctx);
 139
 140         return NULL;
 141 }
 142
 143 static void *emitter_entry2(void *data)
 144 {
 145         struct epoll_mtcontext *ctx = data;
 146
 147         usleep(100000);
 148         write(ctx->sfd[1], "w", 1);
 149         write(ctx->sfd[3], "w", 1);
 150
 151         kill_timeout(ctx);
 152
 153         return NULL;
 154 }
 155
 156 /*
 157  *          t0
 158  *           | (ew)
 159  *          e0
 160  *           | (lt)
 161  *          s0
 162  */
 163 TEST(epoll1)
 164 {
 165         int efd;
 166         int sfd[2];
 167         struct epoll_event e;
 168
 169         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
 170
 171         efd = epoll_create(1);
 172         ASSERT_GE(efd, 0);
 173
 174         e.events = EPOLLIN;
 175         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], &e), 0);
 176
 177         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 178
 179         EXPECT_EQ(epoll_wait(efd, &e, 1, 0), 1);
 180         EXPECT_EQ(epoll_wait(efd, &e, 1, 0), 1);
 181
 182         close(efd);
 183         close(sfd[0]);
 184         close(sfd[1]);
 185 }
 186
 187 /*
 188  *          t0
 189  *           | (ew)
 190  *          e0
 191  *           | (et)
 192  *          s0
 193  */
 194 TEST(epoll2)
 195 {
 196         int efd;
 197         int sfd[2];
 198         struct epoll_event e;
 199
 200         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
 201
 202         efd = epoll_create(1);
 203         ASSERT_GE(efd, 0);
 204
 205         e.events = EPOLLIN | EPOLLET;
 206         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], &e), 0);
 207
 208         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 209
 210         EXPECT_EQ(epoll_wait(efd, &e, 1, 0), 1);
 211         EXPECT_EQ(epoll_wait(efd, &e, 1, 0), 0);
 212
 213         close(efd);
 214         close(sfd[0]);
 215         close(sfd[1]);
 216 }
 217
 218 /*
 219  *           t0
 220  *            | (ew)
 221  *           e0
 222  *     (lt) /  \ (lt)
 223  *        s0    s2
 224  */
 225 TEST(epoll3)
 226 {
 227         int efd;
 228         int sfd[4];
 229         struct epoll_event events[2];
 230
 231         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
 232         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[2]), 0);
 233
 234         efd = epoll_create(1);
 235         ASSERT_GE(efd, 0);
 236
 237         events[0].events = EPOLLIN;
 238         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], events), 0);
 239
 240         events[0].events = EPOLLIN;
 241         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[2], events), 0);
 242
 243         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 244         ASSERT_EQ(write(sfd[3], "w", 1), 1);
 245
 246         EXPECT_EQ(epoll_wait(efd, events, 2, 0), 2);
 247         EXPECT_EQ(epoll_wait(efd, events, 2, 0), 2);
 248
 249         close(efd);
 250         close(sfd[0]);
 251         close(sfd[1]);
 252         close(sfd[2]);
 253         close(sfd[3]);
 254 }
 255
 256 /*
 257  *           t0
 258  *            | (ew)
 259  *           e0
 260  *     (et) /  \ (et)
 261  *        s0    s2
 262  */
 263 TEST(epoll4)
 264 {
 265         int efd;
 266         int sfd[4];
 267         struct epoll_event events[2];
 268
 269         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
 270         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[2]), 0);
 271
 272         efd = epoll_create(1);
 273         ASSERT_GE(efd, 0);
 274
 275         events[0].events = EPOLLIN | EPOLLET;
 276         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], events), 0);
 277
 278         events[0].events = EPOLLIN | EPOLLET;
 279         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[2], events), 0);
 280
 281         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 282         ASSERT_EQ(write(sfd[3], "w", 1), 1);
 283
 284         EXPECT_EQ(epoll_wait(efd, events, 2, 0), 2);
 285         EXPECT_EQ(epoll_wait(efd, events, 2, 0), 0);
 286
 287         close(efd);
 288         close(sfd[0]);
 289         close(sfd[1]);
 290         close(sfd[2]);
 291         close(sfd[3]);
 292 }
 293
 294 /*
 295  *          t0
 296  *           | (p)
 297  *          e0
 298  *           | (lt)
 299  *          s0
 300  */
 301 TEST(epoll5)
 302 {
 303         int efd;
 304         int sfd[2];
 305         struct pollfd pfd;
 306         struct epoll_event e;
 307
 308         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
 309
 310         efd = epoll_create(1);
 311         ASSERT_GE(efd, 0);
 312
 313         e.events = EPOLLIN;
 314         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], &e), 0);
 315
 316         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 317
 318         pfd.fd = efd;
 319         pfd.events = POLLIN;
 320         ASSERT_EQ(poll(&pfd, 1, 0), 1);
 321         ASSERT_EQ(epoll_wait(efd, &e, 1, 0), 1);
 322
 323         pfd.fd = efd;
 324         pfd.events = POLLIN;
 325         ASSERT_EQ(poll(&pfd, 1, 0), 1);
 326         ASSERT_EQ(epoll_wait(efd, &e, 1, 0), 1);
 327
 328         close(efd);
 329         close(sfd[0]);
 330         close(sfd[1]);
 331 }
 332
 333 /*
 334  *          t0
 335  *           | (p)
 336  *          e0
 337  *           | (et)
 338  *          s0
 339  */
 340 TEST(epoll6)
 341 {
 342         int efd;
 343         int sfd[2];
 344         struct pollfd pfd;
 345         struct epoll_event e;
 346
 347         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
 348
 349         efd = epoll_create(1);
 350         ASSERT_GE(efd, 0);
 351
 352         e.events = EPOLLIN | EPOLLET;
 353         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], &e), 0);
 354
 355         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 356
 357         pfd.fd = efd;
 358         pfd.events = POLLIN;
 359         ASSERT_EQ(poll(&pfd, 1, 0), 1);
 360         ASSERT_EQ(epoll_wait(efd, &e, 1, 0), 1);
 361
 362         pfd.fd = efd;
 363         pfd.events = POLLIN;
 364         ASSERT_EQ(poll(&pfd, 1, 0), 0);
 365         ASSERT_EQ(epoll_wait(efd, &e, 1, 0), 0);
 366
 367         close(efd);
 368         close(sfd[0]);
 369         close(sfd[1]);
 370 }
 371
 372 /*
 373  *           t0
 374  *            | (p)
 375  *           e0
 376  *     (lt) /  \ (lt)
 377  *        s0    s2
 378  */
 379
 380 TEST(epoll7)
 381 {
 382         int efd;
 383         int sfd[4];
 384         struct pollfd pfd;
 385         struct epoll_event events[2];
 386
 387         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
 388         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[2]), 0);
 389
 390         efd = epoll_create(1);
 391         ASSERT_GE(efd, 0);
 392
 393         events[0].events = EPOLLIN;
 394         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], events), 0);
 395
 396         events[0].events = EPOLLIN;
 397         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[2], events), 0);
 398
 399         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 400         ASSERT_EQ(write(sfd[3], "w", 1), 1);
 401
 402         pfd.fd = efd;
 403         pfd.events = POLLIN;
 404         EXPECT_EQ(poll(&pfd, 1, 0), 1);
 405         EXPECT_EQ(epoll_wait(efd, events, 2, 0), 2);
 406
 407         pfd.fd = efd;
 408         pfd.events = POLLIN;
 409         EXPECT_EQ(poll(&pfd, 1, 0), 1);
 410         EXPECT_EQ(epoll_wait(efd, events, 2, 0), 2);
 411
 412         close(efd);
 413         close(sfd[0]);
 414         close(sfd[1]);
 415         close(sfd[2]);
 416         close(sfd[3]);
 417 }
 418
 419 /*
 420  *           t0
 421  *            | (p)
 422  *           e0
 423  *     (et) /  \ (et)
 424  *        s0    s2
 425  */
 426 TEST(epoll8)
 427 {
 428         int efd;
 429         int sfd[4];
 430         struct pollfd pfd;
 431         struct epoll_event events[2];
 432
 433         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
 434         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[2]), 0);
 435
 436         efd = epoll_create(1);
 437         ASSERT_GE(efd, 0);
 438
 439         events[0].events = EPOLLIN | EPOLLET;
 440         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], events), 0);
 441
 442         events[0].events = EPOLLIN | EPOLLET;
 443         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[2], events), 0);
 444
 445         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 446         ASSERT_EQ(write(sfd[3], "w", 1), 1);
 447
 448         pfd.fd = efd;
 449         pfd.events = POLLIN;
 450         EXPECT_EQ(poll(&pfd, 1, 0), 1);
 451         EXPECT_EQ(epoll_wait(efd, events, 2, 0), 2);
 452
 453         pfd.fd = efd;
 454         pfd.events = POLLIN;
 455         EXPECT_EQ(poll(&pfd, 1, 0), 0);
 456         EXPECT_EQ(epoll_wait(efd, events, 2, 0), 0);
 457
 458         close(efd);
 459         close(sfd[0]);
 460         close(sfd[1]);
 461         close(sfd[2]);
 462         close(sfd[3]);
 463 }
 464
 465 /*
 466  *        t0    t1
 467  *     (ew) \  / (ew)
 468  *           e0
 469  *            | (lt)
 470  *           s0
 471  */
 472 TEST(epoll9)
 473 {
 474         pthread_t emitter;
 475         struct epoll_event e;
 476         struct epoll_mtcontext ctx = { 0 };
 477
 478         signal(SIGUSR1, signal_handler);
 479
 480         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
 481
 482         ctx.efd[0] = epoll_create(1);
 483         ASSERT_GE(ctx.efd[0], 0);
 484
 485         e.events = EPOLLIN;
 486         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
 487
 488         ctx.main = pthread_self();
 489         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
 490         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
 491
 492         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
 493                 __sync_fetch_and_add(&ctx.count, 1);
 494
 495         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
 496         EXPECT_EQ(ctx.count, 2);
 497
 498         if (pthread_tryjoin_np(emitter, NULL) < 0) {
 499                 pthread_kill(emitter, SIGUSR1);
 500                 pthread_join(emitter, NULL);
 501         }
 502
 503         close(ctx.efd[0]);
 504         close(ctx.sfd[0]);
 505         close(ctx.sfd[1]);
 506 }
 507
 508 /*
 509  *        t0    t1
 510  *     (ew) \  / (ew)
 511  *           e0
 512  *            | (et)
 513  *           s0
 514  */
 515 TEST(epoll10)
 516 {
 517         pthread_t emitter;
 518         struct epoll_event e;
 519         struct epoll_mtcontext ctx = { 0 };
 520
 521         signal(SIGUSR1, signal_handler);
 522
 523         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
 524
 525         ctx.efd[0] = epoll_create(1);
 526         ASSERT_GE(ctx.efd[0], 0);
 527
 528         e.events = EPOLLIN | EPOLLET;
 529         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
 530
 531         ctx.main = pthread_self();
 532         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
 533         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
 534
 535         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
 536                 __sync_fetch_and_add(&ctx.count, 1);
 537
 538         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
 539         EXPECT_EQ(ctx.count, 1);
 540
 541         if (pthread_tryjoin_np(emitter, NULL) < 0) {
 542                 pthread_kill(emitter, SIGUSR1);
 543                 pthread_join(emitter, NULL);
 544         }
 545
 546         close(ctx.efd[0]);
 547         close(ctx.sfd[0]);
 548         close(ctx.sfd[1]);
 549 }
 550
 551 /*
 552  *        t0    t1
 553  *     (ew) \  / (ew)
 554  *           e0
 555  *     (lt) /  \ (lt)
 556  *        s0    s2
 557  */
 558 TEST(epoll11)
 559 {
 560         pthread_t emitter;
 561         struct epoll_event events[2];
 562         struct epoll_mtcontext ctx = { 0 };
 563
 564         signal(SIGUSR1, signal_handler);
 565
 566         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
 567         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
 568
 569         ctx.efd[0] = epoll_create(1);
 570         ASSERT_GE(ctx.efd[0], 0);
 571
 572         events[0].events = EPOLLIN;
 573         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], events), 0);
 574
 575         events[0].events = EPOLLIN;
 576         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[2], events), 0);
 577
 578         ctx.main = pthread_self();
 579         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry2a, &ctx), 0);
 580         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
 581
 582         if (epoll_wait(ctx.efd[0], events, 2, -1) > 0)
 583                 __sync_fetch_and_add(&ctx.count, 1);
 584
 585         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
 586         EXPECT_EQ(ctx.count, 2);
 587
 588         if (pthread_tryjoin_np(emitter, NULL) < 0) {
 589                 pthread_kill(emitter, SIGUSR1);
 590                 pthread_join(emitter, NULL);
 591         }
 592
 593         close(ctx.efd[0]);
 594         close(ctx.sfd[0]);
 595         close(ctx.sfd[1]);
 596         close(ctx.sfd[2]);
 597         close(ctx.sfd[3]);
 598 }
 599
 600 /*
 601  *        t0    t1
 602  *     (ew) \  / (ew)
 603  *           e0
 604  *     (et) /  \ (et)
 605  *        s0    s2
 606  */
 607 TEST(epoll12)
 608 {
 609         pthread_t emitter;
 610         struct epoll_event events[2];
 611         struct epoll_mtcontext ctx = { 0 };
 612
 613         signal(SIGUSR1, signal_handler);
 614
 615         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
 616         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
 617
 618         ctx.efd[0] = epoll_create(1);
 619         ASSERT_GE(ctx.efd[0], 0);
 620
 621         events[0].events = EPOLLIN | EPOLLET;
 622         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], events), 0);
 623
 624         events[0].events = EPOLLIN | EPOLLET;
 625         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[2], events), 0);
 626
 627         ctx.main = pthread_self();
 628         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
 629         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
 630
 631         if (epoll_wait(ctx.efd[0], events, 1, -1) > 0)
 632                 __sync_fetch_and_add(&ctx.count, 1);
 633
 634         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
 635         EXPECT_EQ(ctx.count, 2);
 636
 637         if (pthread_tryjoin_np(emitter, NULL) < 0) {
 638                 pthread_kill(emitter, SIGUSR1);
 639                 pthread_join(emitter, NULL);
 640         }
 641
 642         close(ctx.efd[0]);
 643         close(ctx.sfd[0]);
 644         close(ctx.sfd[1]);
 645         close(ctx.sfd[2]);
 646         close(ctx.sfd[3]);
 647 }
 648
 649 /*
 650  *        t0    t1
 651  *     (ew) \  / (p)
 652  *           e0
 653  *            | (lt)
 654  *           s0
 655  */
 656 TEST(epoll13)
 657 {
 658         pthread_t emitter;
 659         struct epoll_event e;
 660         struct epoll_mtcontext ctx = { 0 };
 661
 662         signal(SIGUSR1, signal_handler);
 663
 664         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
 665
 666         ctx.efd[0] = epoll_create(1);
 667         ASSERT_GE(ctx.efd[0], 0);
 668
 669         e.events = EPOLLIN;
 670         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
 671
 672         ctx.main = pthread_self();
 673         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
 674         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
 675
 676         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
 677                 __sync_fetch_and_add(&ctx.count, 1);
 678
 679         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
 680         EXPECT_EQ(ctx.count, 2);
 681
 682         if (pthread_tryjoin_np(emitter, NULL) < 0) {
 683                 pthread_kill(emitter, SIGUSR1);
 684                 pthread_join(emitter, NULL);
 685         }
 686
 687         close(ctx.efd[0]);
 688         close(ctx.sfd[0]);
 689         close(ctx.sfd[1]);
 690 }
 691
 692 /*
 693  *        t0    t1
 694  *     (ew) \  / (p)
 695  *           e0
 696  *            | (et)
 697  *           s0
 698  */
 699 TEST(epoll14)
 700 {
 701         pthread_t emitter;
 702         struct epoll_event e;
 703         struct epoll_mtcontext ctx = { 0 };
 704
 705         signal(SIGUSR1, signal_handler);
 706
 707         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
 708
 709         ctx.efd[0] = epoll_create(1);
 710         ASSERT_GE(ctx.efd[0], 0);
 711
 712         e.events = EPOLLIN | EPOLLET;
 713         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
 714
 715         ctx.main = pthread_self();
 716         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
 717         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
 718
 719         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
 720                 __sync_fetch_and_add(&ctx.count, 1);
 721
 722         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
 723         EXPECT_EQ(ctx.count, 1);
 724
 725         if (pthread_tryjoin_np(emitter, NULL) < 0) {
 726                 pthread_kill(emitter, SIGUSR1);
 727                 pthread_join(emitter, NULL);
 728         }
 729
 730         close(ctx.efd[0]);
 731         close(ctx.sfd[0]);
 732         close(ctx.sfd[1]);
 733 }
 734
 735 /*
 736  *        t0    t1
 737  *     (ew) \  / (p)
 738  *           e0
 739  *     (lt) /  \ (lt)
 740  *        s0    s2
 741  */
 742 TEST(epoll15)
 743 {
 744         pthread_t emitter;
 745         struct epoll_event events[2];
 746         struct epoll_mtcontext ctx = { 0 };
 747
 748         signal(SIGUSR1, signal_handler);
 749
 750         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
 751         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
 752
 753         ctx.efd[0] = epoll_create(1);
 754         ASSERT_GE(ctx.efd[0], 0);
 755
 756         events[0].events = EPOLLIN;
 757         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], events), 0);
 758
 759         events[0].events = EPOLLIN;
 760         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[2], events), 0);
 761
 762         ctx.main = pthread_self();
 763         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry2ap, &ctx), 0);
 764         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
 765
 766         if (epoll_wait(ctx.efd[0], events, 2, -1) > 0)
 767                 __sync_fetch_and_add(&ctx.count, 1);
 768
 769         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
 770         EXPECT_EQ(ctx.count, 2);
 771
 772         if (pthread_tryjoin_np(emitter, NULL) < 0) {
 773                 pthread_kill(emitter, SIGUSR1);
 774                 pthread_join(emitter, NULL);
 775         }
 776
 777         close(ctx.efd[0]);
 778         close(ctx.sfd[0]);
 779         close(ctx.sfd[1]);
 780         close(ctx.sfd[2]);
 781         close(ctx.sfd[3]);
 782 }
 783
 784 /*
 785  *        t0    t1
 786  *     (ew) \  / (p)
 787  *           e0
 788  *     (et) /  \ (et)
 789  *        s0    s2
 790  */
 791 TEST(epoll16)
 792 {
 793         pthread_t emitter;
 794         struct epoll_event events[2];
 795         struct epoll_mtcontext ctx = { 0 };
 796
 797         signal(SIGUSR1, signal_handler);
 798
 799         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
 800         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
 801
 802         ctx.efd[0] = epoll_create(1);
 803         ASSERT_GE(ctx.efd[0], 0);
 804
 805         events[0].events = EPOLLIN | EPOLLET;
 806         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], events), 0);
 807
 808         events[0].events = EPOLLIN | EPOLLET;
 809         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[2], events), 0);
 810
 811         ctx.main = pthread_self();
 812         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
 813         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
 814
 815         if (epoll_wait(ctx.efd[0], events, 1, -1) > 0)
 816                 __sync_fetch_and_add(&ctx.count, 1);
 817
 818         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
 819         EXPECT_EQ(ctx.count, 2);
 820
 821         if (pthread_tryjoin_np(emitter, NULL) < 0) {
 822                 pthread_kill(emitter, SIGUSR1);
 823                 pthread_join(emitter, NULL);
 824         }
 825
 826         close(ctx.efd[0]);
 827         close(ctx.sfd[0]);
 828         close(ctx.sfd[1]);
 829         close(ctx.sfd[2]);
 830         close(ctx.sfd[3]);
 831 }
 832
 833 /*
 834  *          t0
 835  *           | (ew)
 836  *          e0
 837  *           | (lt)
 838  *          e1
 839  *           | (lt)
 840  *          s0
 841  */
 842 TEST(epoll17)
 843 {
 844         int efd[2];
 845         int sfd[2];
 846         struct epoll_event e;
 847
 848         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
 849
 850         efd[0] = epoll_create(1);
 851         ASSERT_GE(efd[0], 0);
 852
 853         efd[1] = epoll_create(1);
 854         ASSERT_GE(efd[1], 0);
 855
 856         e.events = EPOLLIN;
 857         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], &e), 0);
 858
 859         e.events = EPOLLIN;
 860         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], &e), 0);
 861
 862         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 863
 864         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
 865         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
 866
 867         close(efd[0]);
 868         close(efd[1]);
 869         close(sfd[0]);
 870         close(sfd[1]);
 871 }
 872
 873 /*
 874  *          t0
 875  *           | (ew)
 876  *          e0
 877  *           | (lt)
 878  *          e1
 879  *           | (et)
 880  *          s0
 881  */
 882 TEST(epoll18)
 883 {
 884         int efd[2];
 885         int sfd[2];
 886         struct epoll_event e;
 887
 888         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
 889
 890         efd[0] = epoll_create(1);
 891         ASSERT_GE(efd[0], 0);
 892
 893         efd[1] = epoll_create(1);
 894         ASSERT_GE(efd[1], 0);
 895
 896         e.events = EPOLLIN | EPOLLET;
 897         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], &e), 0);
 898
 899         e.events = EPOLLIN;
 900         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], &e), 0);
 901
 902         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 903
 904         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
 905         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
 906
 907         close(efd[0]);
 908         close(efd[1]);
 909         close(sfd[0]);
 910         close(sfd[1]);
 911 }
 912
 913 /*
 914  *           t0
 915  *            | (ew)
 916  *           e0
 917  *            | (et)
 918  *           e1
 919  *            | (lt)
 920  *           s0
 921  */
 922 TEST(epoll19)
 923 {
 924         int efd[2];
 925         int sfd[2];
 926         struct epoll_event e;
 927
 928         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
 929
 930         efd[0] = epoll_create(1);
 931         ASSERT_GE(efd[0], 0);
 932
 933         efd[1] = epoll_create(1);
 934         ASSERT_GE(efd[1], 0);
 935
 936         e.events = EPOLLIN;
 937         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], &e), 0);
 938
 939         e.events = EPOLLIN | EPOLLET;
 940         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], &e), 0);
 941
 942         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 943
 944         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
 945         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 0);
 946
 947         close(efd[0]);
 948         close(efd[1]);
 949         close(sfd[0]);
 950         close(sfd[1]);
 951 }
 952
 953 /*
 954  *           t0
 955  *            | (ew)
 956  *           e0
 957  *            | (et)
 958  *           e1
 959  *            | (et)
 960  *           s0
 961  */
 962 TEST(epoll20)
 963 {
 964         int efd[2];
 965         int sfd[2];
 966         struct epoll_event e;
 967
 968         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
 969
 970         efd[0] = epoll_create(1);
 971         ASSERT_GE(efd[0], 0);
 972
 973         efd[1] = epoll_create(1);
 974         ASSERT_GE(efd[1], 0);
 975
 976         e.events = EPOLLIN | EPOLLET;
 977         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], &e), 0);
 978
 979         e.events = EPOLLIN | EPOLLET;
 980         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], &e), 0);
 981
 982         ASSERT_EQ(write(sfd[1], "w", 1), 1);
 983
 984         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
 985         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 0);
 986
 987         close(efd[0]);
 988         close(efd[1]);
 989         close(sfd[0]);
 990         close(sfd[1]);
 991 }
 992
 993 /*
 994  *          t0
 995  *           | (p)
 996  *          e0
 997  *           | (lt)
 998  *          e1
 999  *           | (lt)
1000  *          s0
1001  */
1002 TEST(epoll21)
1003 {
1004         int efd[2];
1005         int sfd[2];
1006         struct pollfd pfd;
1007         struct epoll_event e;
1008
1009         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
1010
1011         efd[0] = epoll_create(1);
1012         ASSERT_GE(efd[0], 0);
1013
1014         efd[1] = epoll_create(1);
1015         ASSERT_GE(efd[1], 0);
1016
1017         e.events = EPOLLIN;
1018         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], &e), 0);
1019
1020         e.events = EPOLLIN;
1021         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], &e), 0);
1022
1023         ASSERT_EQ(write(sfd[1], "w", 1), 1);
1024
1025         pfd.fd = efd[0];
1026         pfd.events = POLLIN;
1027         EXPECT_EQ(poll(&pfd, 1, 0), 1);
1028         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
1029
1030         pfd.fd = efd[0];
1031         pfd.events = POLLIN;
1032         EXPECT_EQ(poll(&pfd, 1, 0), 1);
1033         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
1034
1035         close(efd[0]);
1036         close(efd[1]);
1037         close(sfd[0]);
1038         close(sfd[1]);
1039 }
1040
1041 /*
1042  *          t0
1043  *           | (p)
1044  *          e0
1045  *           | (lt)
1046  *          e1
1047  *           | (et)
1048  *          s0
1049  */
1050 TEST(epoll22)
1051 {
1052         int efd[2];
1053         int sfd[2];
1054         struct pollfd pfd;
1055         struct epoll_event e;
1056
1057         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
1058
1059         efd[0] = epoll_create(1);
1060         ASSERT_GE(efd[0], 0);
1061
1062         efd[1] = epoll_create(1);
1063         ASSERT_GE(efd[1], 0);
1064
1065         e.events = EPOLLIN | EPOLLET;
1066         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], &e), 0);
1067
1068         e.events = EPOLLIN;
1069         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], &e), 0);
1070
1071         ASSERT_EQ(write(sfd[1], "w", 1), 1);
1072
1073         pfd.fd = efd[0];
1074         pfd.events = POLLIN;
1075         EXPECT_EQ(poll(&pfd, 1, 0), 1);
1076         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
1077
1078         pfd.fd = efd[0];
1079         pfd.events = POLLIN;
1080         EXPECT_EQ(poll(&pfd, 1, 0), 1);
1081         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
1082
1083         close(efd[0]);
1084         close(efd[1]);
1085         close(sfd[0]);
1086         close(sfd[1]);
1087 }
1088
1089 /*
1090  *          t0
1091  *           | (p)
1092  *          e0
1093  *           | (et)
1094  *          e1
1095  *           | (lt)
1096  *          s0
1097  */
1098 TEST(epoll23)
1099 {
1100         int efd[2];
1101         int sfd[2];
1102         struct pollfd pfd;
1103         struct epoll_event e;
1104
1105         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
1106
1107         efd[0] = epoll_create(1);
1108         ASSERT_GE(efd[0], 0);
1109
1110         efd[1] = epoll_create(1);
1111         ASSERT_GE(efd[1], 0);
1112
1113         e.events = EPOLLIN;
1114         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], &e), 0);
1115
1116         e.events = EPOLLIN | EPOLLET;
1117         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], &e), 0);
1118
1119         ASSERT_EQ(write(sfd[1], "w", 1), 1);
1120
1121         pfd.fd = efd[0];
1122         pfd.events = POLLIN;
1123         EXPECT_EQ(poll(&pfd, 1, 0), 1);
1124         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
1125
1126         pfd.fd = efd[0];
1127         pfd.events = POLLIN;
1128         EXPECT_EQ(poll(&pfd, 1, 0), 0);
1129         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 0);
1130
1131         close(efd[0]);
1132         close(efd[1]);
1133         close(sfd[0]);
1134         close(sfd[1]);
1135 }
1136
1137 /*
1138  *          t0
1139  *           | (p)
1140  *          e0
1141  *           | (et)
1142  *          e1
1143  *           | (et)
1144  *          s0
1145  */
1146 TEST(epoll24)
1147 {
1148         int efd[2];
1149         int sfd[2];
1150         struct pollfd pfd;
1151         struct epoll_event e;
1152
1153         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
1154
1155         efd[0] = epoll_create(1);
1156         ASSERT_GE(efd[0], 0);
1157
1158         efd[1] = epoll_create(1);
1159         ASSERT_GE(efd[1], 0);
1160
1161         e.events = EPOLLIN | EPOLLET;
1162         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], &e), 0);
1163
1164         e.events = EPOLLIN | EPOLLET;
1165         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], &e), 0);
1166
1167         ASSERT_EQ(write(sfd[1], "w", 1), 1);
1168
1169         pfd.fd = efd[0];
1170         pfd.events = POLLIN;
1171         EXPECT_EQ(poll(&pfd, 1, 0), 1);
1172         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 1);
1173
1174         pfd.fd = efd[0];
1175         pfd.events = POLLIN;
1176         EXPECT_EQ(poll(&pfd, 1, 0), 0);
1177         EXPECT_EQ(epoll_wait(efd[0], &e, 1, 0), 0);
1178
1179         close(efd[0]);
1180         close(efd[1]);
1181         close(sfd[0]);
1182         close(sfd[1]);
1183 }
1184
1185 /*
1186  *        t0    t1
1187  *     (ew) \  / (ew)
1188  *           e0
1189  *            | (lt)
1190  *           e1
1191  *            | (lt)
1192  *           s0
1193  */
1194 TEST(epoll25)
1195 {
1196         pthread_t emitter;
1197         struct epoll_event e;
1198         struct epoll_mtcontext ctx = { 0 };
1199
1200         signal(SIGUSR1, signal_handler);
1201
1202         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1203
1204         ctx.efd[0] = epoll_create(1);
1205         ASSERT_GE(ctx.efd[0], 0);
1206
1207         ctx.efd[1] = epoll_create(1);
1208         ASSERT_GE(ctx.efd[1], 0);
1209
1210         e.events = EPOLLIN;
1211         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1212
1213         e.events = EPOLLIN;
1214         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1215
1216         ctx.main = pthread_self();
1217         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
1218         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1219
1220         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
1221                 __sync_fetch_and_add(&ctx.count, 1);
1222
1223         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1224         EXPECT_EQ(ctx.count, 2);
1225
1226         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1227                 pthread_kill(emitter, SIGUSR1);
1228                 pthread_join(emitter, NULL);
1229         }
1230
1231         close(ctx.efd[0]);
1232         close(ctx.efd[1]);
1233         close(ctx.sfd[0]);
1234         close(ctx.sfd[1]);
1235 }
1236
1237 /*
1238  *        t0    t1
1239  *     (ew) \  / (ew)
1240  *           e0
1241  *            | (lt)
1242  *           e1
1243  *            | (et)
1244  *           s0
1245  */
1246 TEST(epoll26)
1247 {
1248         pthread_t emitter;
1249         struct epoll_event e;
1250         struct epoll_mtcontext ctx = { 0 };
1251
1252         signal(SIGUSR1, signal_handler);
1253
1254         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1255
1256         ctx.efd[0] = epoll_create(1);
1257         ASSERT_GE(ctx.efd[0], 0);
1258
1259         ctx.efd[1] = epoll_create(1);
1260         ASSERT_GE(ctx.efd[1], 0);
1261
1262         e.events = EPOLLIN | EPOLLET;
1263         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1264
1265         e.events = EPOLLIN;
1266         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1267
1268         ctx.main = pthread_self();
1269         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
1270         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1271
1272         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
1273                 __sync_fetch_and_add(&ctx.count, 1);
1274
1275         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1276         EXPECT_EQ(ctx.count, 2);
1277
1278         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1279                 pthread_kill(emitter, SIGUSR1);
1280                 pthread_join(emitter, NULL);
1281         }
1282
1283         close(ctx.efd[0]);
1284         close(ctx.efd[1]);
1285         close(ctx.sfd[0]);
1286         close(ctx.sfd[1]);
1287 }
1288
1289 /*
1290  *        t0    t1
1291  *     (ew) \  / (ew)
1292  *           e0
1293  *            | (et)
1294  *           e1
1295  *            | (lt)
1296  *           s0
1297  */
1298 TEST(epoll27)
1299 {
1300         pthread_t emitter;
1301         struct epoll_event e;
1302         struct epoll_mtcontext ctx = { 0 };
1303
1304         signal(SIGUSR1, signal_handler);
1305
1306         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1307
1308         ctx.efd[0] = epoll_create(1);
1309         ASSERT_GE(ctx.efd[0], 0);
1310
1311         ctx.efd[1] = epoll_create(1);
1312         ASSERT_GE(ctx.efd[1], 0);
1313
1314         e.events = EPOLLIN;
1315         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1316
1317         e.events = EPOLLIN | EPOLLET;
1318         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1319
1320         ctx.main = pthread_self();
1321         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
1322         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1323
1324         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
1325                 __sync_fetch_and_add(&ctx.count, 1);
1326
1327         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1328         EXPECT_EQ(ctx.count, 1);
1329
1330         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1331                 pthread_kill(emitter, SIGUSR1);
1332                 pthread_join(emitter, NULL);
1333         }
1334
1335         close(ctx.efd[0]);
1336         close(ctx.efd[1]);
1337         close(ctx.sfd[0]);
1338         close(ctx.sfd[1]);
1339 }
1340
1341 /*
1342  *        t0    t1
1343  *     (ew) \  / (ew)
1344  *           e0
1345  *            | (et)
1346  *           e1
1347  *            | (et)
1348  *           s0
1349  */
1350 TEST(epoll28)
1351 {
1352         pthread_t emitter;
1353         struct epoll_event e;
1354         struct epoll_mtcontext ctx = { 0 };
1355
1356         signal(SIGUSR1, signal_handler);
1357
1358         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1359
1360         ctx.efd[0] = epoll_create(1);
1361         ASSERT_GE(ctx.efd[0], 0);
1362
1363         ctx.efd[1] = epoll_create(1);
1364         ASSERT_GE(ctx.efd[1], 0);
1365
1366         e.events = EPOLLIN | EPOLLET;
1367         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1368
1369         e.events = EPOLLIN | EPOLLET;
1370         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1371
1372         ctx.main = pthread_self();
1373         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
1374         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1375
1376         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
1377                 __sync_fetch_and_add(&ctx.count, 1);
1378
1379         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1380         EXPECT_EQ(ctx.count, 1);
1381
1382         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1383                 pthread_kill(emitter, SIGUSR1);
1384                 pthread_join(emitter, NULL);
1385         }
1386
1387         close(ctx.efd[0]);
1388         close(ctx.efd[1]);
1389         close(ctx.sfd[0]);
1390         close(ctx.sfd[1]);
1391 }
1392
1393 /*
1394  *        t0    t1
1395  *     (ew) \  / (p)
1396  *           e0
1397  *            | (lt)
1398  *           e1
1399  *            | (lt)
1400  *           s0
1401  */
1402 TEST(epoll29)
1403 {
1404         pthread_t emitter;
1405         struct epoll_event e;
1406         struct epoll_mtcontext ctx = { 0 };
1407
1408         signal(SIGUSR1, signal_handler);
1409
1410         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1411
1412         ctx.efd[0] = epoll_create(1);
1413         ASSERT_GE(ctx.efd[0], 0);
1414
1415         ctx.efd[1] = epoll_create(1);
1416         ASSERT_GE(ctx.efd[1], 0);
1417
1418         e.events = EPOLLIN;
1419         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1420
1421         e.events = EPOLLIN;
1422         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1423
1424         ctx.main = pthread_self();
1425         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
1426         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1427
1428         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
1429                 __sync_fetch_and_add(&ctx.count, 1);
1430
1431         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1432         EXPECT_EQ(ctx.count, 2);
1433
1434         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1435                 pthread_kill(emitter, SIGUSR1);
1436                 pthread_join(emitter, NULL);
1437         }
1438
1439         close(ctx.efd[0]);
1440         close(ctx.sfd[0]);
1441         close(ctx.sfd[1]);
1442 }
1443
1444 /*
1445  *        t0    t1
1446  *     (ew) \  / (p)
1447  *           e0
1448  *            | (lt)
1449  *           e1
1450  *            | (et)
1451  *           s0
1452  */
1453 TEST(epoll30)
1454 {
1455         pthread_t emitter;
1456         struct epoll_event e;
1457         struct epoll_mtcontext ctx = { 0 };
1458
1459         signal(SIGUSR1, signal_handler);
1460
1461         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1462
1463         ctx.efd[0] = epoll_create(1);
1464         ASSERT_GE(ctx.efd[0], 0);
1465
1466         ctx.efd[1] = epoll_create(1);
1467         ASSERT_GE(ctx.efd[1], 0);
1468
1469         e.events = EPOLLIN | EPOLLET;
1470         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1471
1472         e.events = EPOLLIN;
1473         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1474
1475         ctx.main = pthread_self();
1476         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
1477         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1478
1479         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
1480                 __sync_fetch_and_add(&ctx.count, 1);
1481
1482         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1483         EXPECT_EQ(ctx.count, 2);
1484
1485         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1486                 pthread_kill(emitter, SIGUSR1);
1487                 pthread_join(emitter, NULL);
1488         }
1489
1490         close(ctx.efd[0]);
1491         close(ctx.sfd[0]);
1492         close(ctx.sfd[1]);
1493 }
1494
1495 /*
1496  *        t0    t1
1497  *     (ew) \  / (p)
1498  *           e0
1499  *            | (et)
1500  *           e1
1501  *            | (lt)
1502  *           s0
1503  */
1504 TEST(epoll31)
1505 {
1506         pthread_t emitter;
1507         struct epoll_event e;
1508         struct epoll_mtcontext ctx = { 0 };
1509
1510         signal(SIGUSR1, signal_handler);
1511
1512         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1513
1514         ctx.efd[0] = epoll_create(1);
1515         ASSERT_GE(ctx.efd[0], 0);
1516
1517         ctx.efd[1] = epoll_create(1);
1518         ASSERT_GE(ctx.efd[1], 0);
1519
1520         e.events = EPOLLIN;
1521         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1522
1523         e.events = EPOLLIN | EPOLLET;
1524         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1525
1526         ctx.main = pthread_self();
1527         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
1528         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1529
1530         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
1531                 __sync_fetch_and_add(&ctx.count, 1);
1532
1533         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1534         EXPECT_EQ(ctx.count, 1);
1535
1536         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1537                 pthread_kill(emitter, SIGUSR1);
1538                 pthread_join(emitter, NULL);
1539         }
1540
1541         close(ctx.efd[0]);
1542         close(ctx.sfd[0]);
1543         close(ctx.sfd[1]);
1544 }
1545
1546 /*
1547  *        t0    t1
1548  *     (ew) \  / (p)
1549  *           e0
1550  *            | (et)
1551  *           e1
1552  *            | (et)
1553  *           s0
1554  */
1555 TEST(epoll32)
1556 {
1557         pthread_t emitter;
1558         struct epoll_event e;
1559         struct epoll_mtcontext ctx = { 0 };
1560
1561         signal(SIGUSR1, signal_handler);
1562
1563         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1564
1565         ctx.efd[0] = epoll_create(1);
1566         ASSERT_GE(ctx.efd[0], 0);
1567
1568         ctx.efd[1] = epoll_create(1);
1569         ASSERT_GE(ctx.efd[1], 0);
1570
1571         e.events = EPOLLIN | EPOLLET;
1572         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1573
1574         e.events = EPOLLIN | EPOLLET;
1575         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1576
1577         ctx.main = pthread_self();
1578         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
1579         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1580
1581         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
1582                 __sync_fetch_and_add(&ctx.count, 1);
1583
1584         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1585         EXPECT_EQ(ctx.count, 1);
1586
1587         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1588                 pthread_kill(emitter, SIGUSR1);
1589                 pthread_join(emitter, NULL);
1590         }
1591
1592         close(ctx.efd[0]);
1593         close(ctx.sfd[0]);
1594         close(ctx.sfd[1]);
1595 }
1596
1597 /*
1598  *        t0   t1
1599  *    (ew) |    | (ew)
1600  *         |   e0
1601  *          \  / (lt)
1602  *           e1
1603  *            | (lt)
1604  *           s0
1605  */
1606 TEST(epoll33)
1607 {
1608         pthread_t emitter;
1609         struct epoll_event e;
1610         struct epoll_mtcontext ctx = { 0 };
1611
1612         signal(SIGUSR1, signal_handler);
1613
1614         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1615
1616         ctx.efd[0] = epoll_create(1);
1617         ASSERT_GE(ctx.efd[0], 0);
1618
1619         ctx.efd[1] = epoll_create(1);
1620         ASSERT_GE(ctx.efd[1], 0);
1621
1622         e.events = EPOLLIN;
1623         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1624
1625         e.events = EPOLLIN;
1626         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1627
1628         ctx.main = pthread_self();
1629         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
1630         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1631
1632         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
1633                 __sync_fetch_and_add(&ctx.count, 1);
1634
1635         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1636         EXPECT_EQ(ctx.count, 2);
1637
1638         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1639                 pthread_kill(emitter, SIGUSR1);
1640                 pthread_join(emitter, NULL);
1641         }
1642
1643         close(ctx.efd[0]);
1644         close(ctx.efd[1]);
1645         close(ctx.sfd[0]);
1646         close(ctx.sfd[1]);
1647 }
1648
1649 /*
1650  *        t0   t1
1651  *    (ew) |    | (ew)
1652  *         |   e0
1653  *          \  / (lt)
1654  *           e1
1655  *            | (et)
1656  *           s0
1657  */
1658 TEST(epoll34)
1659 {
1660         pthread_t emitter;
1661         struct epoll_event e;
1662         struct epoll_mtcontext ctx = { 0 };
1663
1664         signal(SIGUSR1, signal_handler);
1665
1666         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1667
1668         ctx.efd[0] = epoll_create(1);
1669         ASSERT_GE(ctx.efd[0], 0);
1670
1671         ctx.efd[1] = epoll_create(1);
1672         ASSERT_GE(ctx.efd[1], 0);
1673
1674         e.events = EPOLLIN | EPOLLET;
1675         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1676
1677         e.events = EPOLLIN;
1678         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1679
1680         ctx.main = pthread_self();
1681         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1o, &ctx), 0);
1682         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1683
1684         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
1685                 __sync_fetch_and_or(&ctx.count, 2);
1686
1687         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1688         EXPECT_TRUE((ctx.count == 2) || (ctx.count == 3));
1689
1690         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1691                 pthread_kill(emitter, SIGUSR1);
1692                 pthread_join(emitter, NULL);
1693         }
1694
1695         close(ctx.efd[0]);
1696         close(ctx.efd[1]);
1697         close(ctx.sfd[0]);
1698         close(ctx.sfd[1]);
1699 }
1700
1701 /*
1702  *        t0   t1
1703  *    (ew) |    | (ew)
1704  *         |   e0
1705  *          \  / (et)
1706  *           e1
1707  *            | (lt)
1708  *           s0
1709  */
1710 TEST(epoll35)
1711 {
1712         pthread_t emitter;
1713         struct epoll_event e;
1714         struct epoll_mtcontext ctx = { 0 };
1715
1716         signal(SIGUSR1, signal_handler);
1717
1718         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1719
1720         ctx.efd[0] = epoll_create(1);
1721         ASSERT_GE(ctx.efd[0], 0);
1722
1723         ctx.efd[1] = epoll_create(1);
1724         ASSERT_GE(ctx.efd[1], 0);
1725
1726         e.events = EPOLLIN;
1727         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1728
1729         e.events = EPOLLIN | EPOLLET;
1730         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1731
1732         ctx.main = pthread_self();
1733         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
1734         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1735
1736         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
1737                 __sync_fetch_and_add(&ctx.count, 1);
1738
1739         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1740         EXPECT_EQ(ctx.count, 2);
1741
1742         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1743                 pthread_kill(emitter, SIGUSR1);
1744                 pthread_join(emitter, NULL);
1745         }
1746
1747         close(ctx.efd[0]);
1748         close(ctx.efd[1]);
1749         close(ctx.sfd[0]);
1750         close(ctx.sfd[1]);
1751 }
1752
1753 /*
1754  *        t0   t1
1755  *    (ew) |    | (ew)
1756  *         |   e0
1757  *          \  / (et)
1758  *           e1
1759  *            | (et)
1760  *           s0
1761  */
1762 TEST(epoll36)
1763 {
1764         pthread_t emitter;
1765         struct epoll_event e;
1766         struct epoll_mtcontext ctx = { 0 };
1767
1768         signal(SIGUSR1, signal_handler);
1769
1770         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1771
1772         ctx.efd[0] = epoll_create(1);
1773         ASSERT_GE(ctx.efd[0], 0);
1774
1775         ctx.efd[1] = epoll_create(1);
1776         ASSERT_GE(ctx.efd[1], 0);
1777
1778         e.events = EPOLLIN | EPOLLET;
1779         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1780
1781         e.events = EPOLLIN | EPOLLET;
1782         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1783
1784         ctx.main = pthread_self();
1785         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1o, &ctx), 0);
1786         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1787
1788         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
1789                 __sync_fetch_and_or(&ctx.count, 2);
1790
1791         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1792         EXPECT_TRUE((ctx.count == 2) || (ctx.count == 3));
1793
1794         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1795                 pthread_kill(emitter, SIGUSR1);
1796                 pthread_join(emitter, NULL);
1797         }
1798
1799         close(ctx.efd[0]);
1800         close(ctx.efd[1]);
1801         close(ctx.sfd[0]);
1802         close(ctx.sfd[1]);
1803 }
1804
1805 /*
1806  *        t0   t1
1807  *     (p) |    | (ew)
1808  *         |   e0
1809  *          \  / (lt)
1810  *           e1
1811  *            | (lt)
1812  *           s0
1813  */
1814 TEST(epoll37)
1815 {
1816         pthread_t emitter;
1817         struct pollfd pfd;
1818         struct epoll_event e;
1819         struct epoll_mtcontext ctx = { 0 };
1820
1821         signal(SIGUSR1, signal_handler);
1822
1823         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1824
1825         ctx.efd[0] = epoll_create(1);
1826         ASSERT_GE(ctx.efd[0], 0);
1827
1828         ctx.efd[1] = epoll_create(1);
1829         ASSERT_GE(ctx.efd[1], 0);
1830
1831         e.events = EPOLLIN;
1832         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1833
1834         e.events = EPOLLIN;
1835         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1836
1837         ctx.main = pthread_self();
1838         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
1839         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1840
1841         pfd.fd = ctx.efd[1];
1842         pfd.events = POLLIN;
1843         if (poll(&pfd, 1, -1) > 0) {
1844                 if (epoll_wait(ctx.efd[1], &e, 1, 0) > 0)
1845                         __sync_fetch_and_add(&ctx.count, 1);
1846         }
1847
1848         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1849         EXPECT_EQ(ctx.count, 2);
1850
1851         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1852                 pthread_kill(emitter, SIGUSR1);
1853                 pthread_join(emitter, NULL);
1854         }
1855
1856         close(ctx.efd[0]);
1857         close(ctx.efd[1]);
1858         close(ctx.sfd[0]);
1859         close(ctx.sfd[1]);
1860 }
1861
1862 /*
1863  *        t0   t1
1864  *     (p) |    | (ew)
1865  *         |   e0
1866  *          \  / (lt)
1867  *           e1
1868  *            | (et)
1869  *           s0
1870  */
1871 TEST(epoll38)
1872 {
1873         pthread_t emitter;
1874         struct pollfd pfd;
1875         struct epoll_event e;
1876         struct epoll_mtcontext ctx = { 0 };
1877
1878         signal(SIGUSR1, signal_handler);
1879
1880         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1881
1882         ctx.efd[0] = epoll_create(1);
1883         ASSERT_GE(ctx.efd[0], 0);
1884
1885         ctx.efd[1] = epoll_create(1);
1886         ASSERT_GE(ctx.efd[1], 0);
1887
1888         e.events = EPOLLIN | EPOLLET;
1889         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1890
1891         e.events = EPOLLIN;
1892         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1893
1894         ctx.main = pthread_self();
1895         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1o, &ctx), 0);
1896         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1897
1898         pfd.fd = ctx.efd[1];
1899         pfd.events = POLLIN;
1900         if (poll(&pfd, 1, -1) > 0) {
1901                 if (epoll_wait(ctx.efd[1], &e, 1, 0) > 0)
1902                         __sync_fetch_and_or(&ctx.count, 2);
1903         }
1904
1905         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1906         EXPECT_TRUE((ctx.count == 2) || (ctx.count == 3));
1907
1908         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1909                 pthread_kill(emitter, SIGUSR1);
1910                 pthread_join(emitter, NULL);
1911         }
1912
1913         close(ctx.efd[0]);
1914         close(ctx.efd[1]);
1915         close(ctx.sfd[0]);
1916         close(ctx.sfd[1]);
1917 }
1918
1919 /*
1920  *        t0   t1
1921  *     (p) |    | (ew)
1922  *         |   e0
1923  *          \  / (et)
1924  *           e1
1925  *            | (lt)
1926  *           s0
1927  */
1928 TEST(epoll39)
1929 {
1930         pthread_t emitter;
1931         struct pollfd pfd;
1932         struct epoll_event e;
1933         struct epoll_mtcontext ctx = { 0 };
1934
1935         signal(SIGUSR1, signal_handler);
1936
1937         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1938
1939         ctx.efd[0] = epoll_create(1);
1940         ASSERT_GE(ctx.efd[0], 0);
1941
1942         ctx.efd[1] = epoll_create(1);
1943         ASSERT_GE(ctx.efd[1], 0);
1944
1945         e.events = EPOLLIN;
1946         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
1947
1948         e.events = EPOLLIN | EPOLLET;
1949         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
1950
1951         ctx.main = pthread_self();
1952         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
1953         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
1954
1955         pfd.fd = ctx.efd[1];
1956         pfd.events = POLLIN;
1957         if (poll(&pfd, 1, -1) > 0) {
1958                 if (epoll_wait(ctx.efd[1], &e, 1, 0) > 0)
1959                         __sync_fetch_and_add(&ctx.count, 1);
1960         }
1961
1962         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
1963         EXPECT_EQ(ctx.count, 2);
1964
1965         if (pthread_tryjoin_np(emitter, NULL) < 0) {
1966                 pthread_kill(emitter, SIGUSR1);
1967                 pthread_join(emitter, NULL);
1968         }
1969
1970         close(ctx.efd[0]);
1971         close(ctx.efd[1]);
1972         close(ctx.sfd[0]);
1973         close(ctx.sfd[1]);
1974 }
1975
1976 /*
1977  *        t0   t1
1978  *     (p) |    | (ew)
1979  *         |   e0
1980  *          \  / (et)
1981  *           e1
1982  *            | (et)
1983  *           s0
1984  */
1985 TEST(epoll40)
1986 {
1987         pthread_t emitter;
1988         struct pollfd pfd;
1989         struct epoll_event e;
1990         struct epoll_mtcontext ctx = { 0 };
1991
1992         signal(SIGUSR1, signal_handler);
1993
1994         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
1995
1996         ctx.efd[0] = epoll_create(1);
1997         ASSERT_GE(ctx.efd[0], 0);
1998
1999         ctx.efd[1] = epoll_create(1);
2000         ASSERT_GE(ctx.efd[1], 0);
2001
2002         e.events = EPOLLIN | EPOLLET;
2003         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2004
2005         e.events = EPOLLIN | EPOLLET;
2006         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2007
2008         ctx.main = pthread_self();
2009         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1o, &ctx), 0);
2010         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2011
2012         pfd.fd = ctx.efd[1];
2013         pfd.events = POLLIN;
2014         if (poll(&pfd, 1, -1) > 0) {
2015                 if (epoll_wait(ctx.efd[1], &e, 1, 0) > 0)
2016                         __sync_fetch_and_or(&ctx.count, 2);
2017         }
2018
2019         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2020         EXPECT_TRUE((ctx.count == 2) || (ctx.count == 3));
2021
2022         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2023                 pthread_kill(emitter, SIGUSR1);
2024                 pthread_join(emitter, NULL);
2025         }
2026
2027         close(ctx.efd[0]);
2028         close(ctx.efd[1]);
2029         close(ctx.sfd[0]);
2030         close(ctx.sfd[1]);
2031 }
2032
2033 /*
2034  *        t0   t1
2035  *    (ew) |    | (p)
2036  *         |   e0
2037  *          \  / (lt)
2038  *           e1
2039  *            | (lt)
2040  *           s0
2041  */
2042 TEST(epoll41)
2043 {
2044         pthread_t emitter;
2045         struct epoll_event e;
2046         struct epoll_mtcontext ctx = { 0 };
2047
2048         signal(SIGUSR1, signal_handler);
2049
2050         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
2051
2052         ctx.efd[0] = epoll_create(1);
2053         ASSERT_GE(ctx.efd[0], 0);
2054
2055         ctx.efd[1] = epoll_create(1);
2056         ASSERT_GE(ctx.efd[1], 0);
2057
2058         e.events = EPOLLIN;
2059         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2060
2061         e.events = EPOLLIN;
2062         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2063
2064         ctx.main = pthread_self();
2065         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
2066         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2067
2068         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
2069                 __sync_fetch_and_add(&ctx.count, 1);
2070
2071         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2072         EXPECT_EQ(ctx.count, 2);
2073
2074         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2075                 pthread_kill(emitter, SIGUSR1);
2076                 pthread_join(emitter, NULL);
2077         }
2078
2079         close(ctx.efd[0]);
2080         close(ctx.efd[1]);
2081         close(ctx.sfd[0]);
2082         close(ctx.sfd[1]);
2083 }
2084
2085 /*
2086  *        t0   t1
2087  *    (ew) |    | (p)
2088  *         |   e0
2089  *          \  / (lt)
2090  *           e1
2091  *            | (et)
2092  *           s0
2093  */
2094 TEST(epoll42)
2095 {
2096         pthread_t emitter;
2097         struct epoll_event e;
2098         struct epoll_mtcontext ctx = { 0 };
2099
2100         signal(SIGUSR1, signal_handler);
2101
2102         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
2103
2104         ctx.efd[0] = epoll_create(1);
2105         ASSERT_GE(ctx.efd[0], 0);
2106
2107         ctx.efd[1] = epoll_create(1);
2108         ASSERT_GE(ctx.efd[1], 0);
2109
2110         e.events = EPOLLIN | EPOLLET;
2111         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2112
2113         e.events = EPOLLIN;
2114         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2115
2116         ctx.main = pthread_self();
2117         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1op, &ctx), 0);
2118         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2119
2120         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
2121                 __sync_fetch_and_or(&ctx.count, 2);
2122
2123         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2124         EXPECT_TRUE((ctx.count == 2) || (ctx.count == 3));
2125
2126         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2127                 pthread_kill(emitter, SIGUSR1);
2128                 pthread_join(emitter, NULL);
2129         }
2130
2131         close(ctx.efd[0]);
2132         close(ctx.efd[1]);
2133         close(ctx.sfd[0]);
2134         close(ctx.sfd[1]);
2135 }
2136
2137 /*
2138  *        t0   t1
2139  *    (ew) |    | (p)
2140  *         |   e0
2141  *          \  / (et)
2142  *           e1
2143  *            | (lt)
2144  *           s0
2145  */
2146 TEST(epoll43)
2147 {
2148         pthread_t emitter;
2149         struct epoll_event e;
2150         struct epoll_mtcontext ctx = { 0 };
2151
2152         signal(SIGUSR1, signal_handler);
2153
2154         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
2155
2156         ctx.efd[0] = epoll_create(1);
2157         ASSERT_GE(ctx.efd[0], 0);
2158
2159         ctx.efd[1] = epoll_create(1);
2160         ASSERT_GE(ctx.efd[1], 0);
2161
2162         e.events = EPOLLIN;
2163         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2164
2165         e.events = EPOLLIN | EPOLLET;
2166         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2167
2168         ctx.main = pthread_self();
2169         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
2170         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2171
2172         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
2173                 __sync_fetch_and_add(&ctx.count, 1);
2174
2175         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2176         EXPECT_EQ(ctx.count, 2);
2177
2178         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2179                 pthread_kill(emitter, SIGUSR1);
2180                 pthread_join(emitter, NULL);
2181         }
2182
2183         close(ctx.efd[0]);
2184         close(ctx.efd[1]);
2185         close(ctx.sfd[0]);
2186         close(ctx.sfd[1]);
2187 }
2188
2189 /*
2190  *        t0   t1
2191  *    (ew) |    | (p)
2192  *         |   e0
2193  *          \  / (et)
2194  *           e1
2195  *            | (et)
2196  *           s0
2197  */
2198 TEST(epoll44)
2199 {
2200         pthread_t emitter;
2201         struct epoll_event e;
2202         struct epoll_mtcontext ctx = { 0 };
2203
2204         signal(SIGUSR1, signal_handler);
2205
2206         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
2207
2208         ctx.efd[0] = epoll_create(1);
2209         ASSERT_GE(ctx.efd[0], 0);
2210
2211         ctx.efd[1] = epoll_create(1);
2212         ASSERT_GE(ctx.efd[1], 0);
2213
2214         e.events = EPOLLIN | EPOLLET;
2215         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2216
2217         e.events = EPOLLIN | EPOLLET;
2218         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2219
2220         ctx.main = pthread_self();
2221         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1op, &ctx), 0);
2222         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2223
2224         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
2225                 __sync_fetch_and_or(&ctx.count, 2);
2226
2227         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2228         EXPECT_TRUE((ctx.count == 2) || (ctx.count == 3));
2229
2230         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2231                 pthread_kill(emitter, SIGUSR1);
2232                 pthread_join(emitter, NULL);
2233         }
2234
2235         close(ctx.efd[0]);
2236         close(ctx.efd[1]);
2237         close(ctx.sfd[0]);
2238         close(ctx.sfd[1]);
2239 }
2240
2241 /*
2242  *        t0   t1
2243  *     (p) |    | (p)
2244  *         |   e0
2245  *          \  / (lt)
2246  *           e1
2247  *            | (lt)
2248  *           s0
2249  */
2250 TEST(epoll45)
2251 {
2252         pthread_t emitter;
2253         struct pollfd pfd;
2254         struct epoll_event e;
2255         struct epoll_mtcontext ctx = { 0 };
2256
2257         signal(SIGUSR1, signal_handler);
2258
2259         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
2260
2261         ctx.efd[0] = epoll_create(1);
2262         ASSERT_GE(ctx.efd[0], 0);
2263
2264         ctx.efd[1] = epoll_create(1);
2265         ASSERT_GE(ctx.efd[1], 0);
2266
2267         e.events = EPOLLIN;
2268         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2269
2270         e.events = EPOLLIN;
2271         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2272
2273         ctx.main = pthread_self();
2274         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
2275         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2276
2277         pfd.fd = ctx.efd[1];
2278         pfd.events = POLLIN;
2279         if (poll(&pfd, 1, -1) > 0) {
2280                 if (epoll_wait(ctx.efd[1], &e, 1, 0) > 0)
2281                         __sync_fetch_and_add(&ctx.count, 1);
2282         }
2283
2284         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2285         EXPECT_EQ(ctx.count, 2);
2286
2287         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2288                 pthread_kill(emitter, SIGUSR1);
2289                 pthread_join(emitter, NULL);
2290         }
2291
2292         close(ctx.efd[0]);
2293         close(ctx.efd[1]);
2294         close(ctx.sfd[0]);
2295         close(ctx.sfd[1]);
2296 }
2297
2298 /*
2299  *        t0   t1
2300  *     (p) |    | (p)
2301  *         |   e0
2302  *          \  / (lt)
2303  *           e1
2304  *            | (et)
2305  *           s0
2306  */
2307 TEST(epoll46)
2308 {
2309         pthread_t emitter;
2310         struct epoll_event e;
2311         struct epoll_mtcontext ctx = { 0 };
2312
2313         signal(SIGUSR1, signal_handler);
2314
2315         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
2316
2317         ctx.efd[0] = epoll_create(1);
2318         ASSERT_GE(ctx.efd[0], 0);
2319
2320         ctx.efd[1] = epoll_create(1);
2321         ASSERT_GE(ctx.efd[1], 0);
2322
2323         e.events = EPOLLIN | EPOLLET;
2324         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2325
2326         e.events = EPOLLIN;
2327         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2328
2329         ctx.main = pthread_self();
2330         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1op, &ctx), 0);
2331         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2332
2333         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
2334                 __sync_fetch_and_or(&ctx.count, 2);
2335
2336         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2337         EXPECT_TRUE((ctx.count == 2) || (ctx.count == 3));
2338
2339         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2340                 pthread_kill(emitter, SIGUSR1);
2341                 pthread_join(emitter, NULL);
2342         }
2343
2344         close(ctx.efd[0]);
2345         close(ctx.efd[1]);
2346         close(ctx.sfd[0]);
2347         close(ctx.sfd[1]);
2348 }
2349
2350 /*
2351  *        t0   t1
2352  *     (p) |    | (p)
2353  *         |   e0
2354  *          \  / (et)
2355  *           e1
2356  *            | (lt)
2357  *           s0
2358  */
2359 TEST(epoll47)
2360 {
2361         pthread_t emitter;
2362         struct pollfd pfd;
2363         struct epoll_event e;
2364         struct epoll_mtcontext ctx = { 0 };
2365
2366         signal(SIGUSR1, signal_handler);
2367
2368         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
2369
2370         ctx.efd[0] = epoll_create(1);
2371         ASSERT_GE(ctx.efd[0], 0);
2372
2373         ctx.efd[1] = epoll_create(1);
2374         ASSERT_GE(ctx.efd[1], 0);
2375
2376         e.events = EPOLLIN;
2377         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2378
2379         e.events = EPOLLIN | EPOLLET;
2380         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2381
2382         ctx.main = pthread_self();
2383         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
2384         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2385
2386         pfd.fd = ctx.efd[1];
2387         pfd.events = POLLIN;
2388         if (poll(&pfd, 1, -1) > 0) {
2389                 if (epoll_wait(ctx.efd[1], &e, 1, 0) > 0)
2390                         __sync_fetch_and_add(&ctx.count, 1);
2391         }
2392
2393         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2394         EXPECT_EQ(ctx.count, 2);
2395
2396         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2397                 pthread_kill(emitter, SIGUSR1);
2398                 pthread_join(emitter, NULL);
2399         }
2400
2401         close(ctx.efd[0]);
2402         close(ctx.efd[1]);
2403         close(ctx.sfd[0]);
2404         close(ctx.sfd[1]);
2405 }
2406
2407 /*
2408  *        t0   t1
2409  *     (p) |    | (p)
2410  *         |   e0
2411  *          \  / (et)
2412  *           e1
2413  *            | (et)
2414  *           s0
2415  */
2416 TEST(epoll48)
2417 {
2418         pthread_t emitter;
2419         struct epoll_event e;
2420         struct epoll_mtcontext ctx = { 0 };
2421
2422         signal(SIGUSR1, signal_handler);
2423
2424         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
2425
2426         ctx.efd[0] = epoll_create(1);
2427         ASSERT_GE(ctx.efd[0], 0);
2428
2429         ctx.efd[1] = epoll_create(1);
2430         ASSERT_GE(ctx.efd[1], 0);
2431
2432         e.events = EPOLLIN | EPOLLET;
2433         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2434
2435         e.events = EPOLLIN | EPOLLET;
2436         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2437
2438         ctx.main = pthread_self();
2439         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1op, &ctx), 0);
2440         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry1, &ctx), 0);
2441
2442         if (epoll_wait(ctx.efd[1], &e, 1, -1) > 0)
2443                 __sync_fetch_and_or(&ctx.count, 2);
2444
2445         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2446         EXPECT_TRUE((ctx.count == 2) || (ctx.count == 3));
2447
2448         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2449                 pthread_kill(emitter, SIGUSR1);
2450                 pthread_join(emitter, NULL);
2451         }
2452
2453         close(ctx.efd[0]);
2454         close(ctx.efd[1]);
2455         close(ctx.sfd[0]);
2456         close(ctx.sfd[1]);
2457 }
2458
2459 /*
2460  *           t0
2461  *            | (ew)
2462  *           e0
2463  *     (lt) /  \ (lt)
2464  *        e1    e2
2465  *    (lt) |     | (lt)
2466  *        s0    s2
2467  */
2468 TEST(epoll49)
2469 {
2470         int efd[3];
2471         int sfd[4];
2472         struct epoll_event events[2];
2473
2474         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
2475         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[2]), 0);
2476
2477         efd[0] = epoll_create(1);
2478         ASSERT_GE(efd[0], 0);
2479
2480         efd[1] = epoll_create(1);
2481         ASSERT_GE(efd[1], 0);
2482
2483         efd[2] = epoll_create(1);
2484         ASSERT_GE(efd[2], 0);
2485
2486         events[0].events = EPOLLIN;
2487         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], events), 0);
2488
2489         events[0].events = EPOLLIN;
2490         ASSERT_EQ(epoll_ctl(efd[2], EPOLL_CTL_ADD, sfd[2], events), 0);
2491
2492         events[0].events = EPOLLIN;
2493         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], events), 0);
2494
2495         events[0].events = EPOLLIN;
2496         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[2], events), 0);
2497
2498         ASSERT_EQ(write(sfd[1], "w", 1), 1);
2499         ASSERT_EQ(write(sfd[3], "w", 1), 1);
2500
2501         EXPECT_EQ(epoll_wait(efd[0], events, 2, 0), 2);
2502         EXPECT_EQ(epoll_wait(efd[0], events, 2, 0), 2);
2503
2504         close(efd[0]);
2505         close(efd[1]);
2506         close(efd[2]);
2507         close(sfd[0]);
2508         close(sfd[1]);
2509         close(sfd[2]);
2510         close(sfd[3]);
2511 }
2512
2513 /*
2514  *           t0
2515  *            | (ew)
2516  *           e0
2517  *     (et) /  \ (et)
2518  *        e1    e2
2519  *    (lt) |     | (lt)
2520  *        s0    s2
2521  */
2522 TEST(epoll50)
2523 {
2524         int efd[3];
2525         int sfd[4];
2526         struct epoll_event events[2];
2527
2528         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
2529         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[2]), 0);
2530
2531         efd[0] = epoll_create(1);
2532         ASSERT_GE(efd[0], 0);
2533
2534         efd[1] = epoll_create(1);
2535         ASSERT_GE(efd[1], 0);
2536
2537         efd[2] = epoll_create(1);
2538         ASSERT_GE(efd[2], 0);
2539
2540         events[0].events = EPOLLIN;
2541         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], events), 0);
2542
2543         events[0].events = EPOLLIN;
2544         ASSERT_EQ(epoll_ctl(efd[2], EPOLL_CTL_ADD, sfd[2], events), 0);
2545
2546         events[0].events = EPOLLIN | EPOLLET;
2547         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], events), 0);
2548
2549         events[0].events = EPOLLIN | EPOLLET;
2550         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[2], events), 0);
2551
2552         ASSERT_EQ(write(sfd[1], "w", 1), 1);
2553         ASSERT_EQ(write(sfd[3], "w", 1), 1);
2554
2555         EXPECT_EQ(epoll_wait(efd[0], events, 2, 0), 2);
2556         EXPECT_EQ(epoll_wait(efd[0], events, 2, 0), 0);
2557
2558         close(efd[0]);
2559         close(efd[1]);
2560         close(efd[2]);
2561         close(sfd[0]);
2562         close(sfd[1]);
2563         close(sfd[2]);
2564         close(sfd[3]);
2565 }
2566
2567 /*
2568  *           t0
2569  *            | (p)
2570  *           e0
2571  *     (lt) /  \ (lt)
2572  *        e1    e2
2573  *    (lt) |     | (lt)
2574  *        s0    s2
2575  */
2576 TEST(epoll51)
2577 {
2578         int efd[3];
2579         int sfd[4];
2580         struct pollfd pfd;
2581         struct epoll_event events[2];
2582
2583         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
2584         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[2]), 0);
2585
2586         efd[0] = epoll_create(1);
2587         ASSERT_GE(efd[0], 0);
2588
2589         efd[1] = epoll_create(1);
2590         ASSERT_GE(efd[1], 0);
2591
2592         efd[2] = epoll_create(1);
2593         ASSERT_GE(efd[2], 0);
2594
2595         events[0].events = EPOLLIN;
2596         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], events), 0);
2597
2598         events[0].events = EPOLLIN;
2599         ASSERT_EQ(epoll_ctl(efd[2], EPOLL_CTL_ADD, sfd[2], events), 0);
2600
2601         events[0].events = EPOLLIN;
2602         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], events), 0);
2603
2604         events[0].events = EPOLLIN;
2605         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[2], events), 0);
2606
2607         ASSERT_EQ(write(sfd[1], "w", 1), 1);
2608         ASSERT_EQ(write(sfd[3], "w", 1), 1);
2609
2610         pfd.fd = efd[0];
2611         pfd.events = POLLIN;
2612         EXPECT_EQ(poll(&pfd, 1, 0), 1);
2613         EXPECT_EQ(epoll_wait(efd[0], events, 2, 0), 2);
2614
2615         pfd.fd = efd[0];
2616         pfd.events = POLLIN;
2617         EXPECT_EQ(poll(&pfd, 1, 0), 1);
2618         EXPECT_EQ(epoll_wait(efd[0], events, 2, 0), 2);
2619
2620         close(efd[0]);
2621         close(efd[1]);
2622         close(efd[2]);
2623         close(sfd[0]);
2624         close(sfd[1]);
2625         close(sfd[2]);
2626         close(sfd[3]);
2627 }
2628
2629 /*
2630  *           t0
2631  *            | (p)
2632  *           e0
2633  *     (et) /  \ (et)
2634  *        e1    e2
2635  *    (lt) |     | (lt)
2636  *        s0    s2
2637  */
2638 TEST(epoll52)
2639 {
2640         int efd[3];
2641         int sfd[4];
2642         struct pollfd pfd;
2643         struct epoll_event events[2];
2644
2645         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[0]), 0);
2646         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &sfd[2]), 0);
2647
2648         efd[0] = epoll_create(1);
2649         ASSERT_GE(efd[0], 0);
2650
2651         efd[1] = epoll_create(1);
2652         ASSERT_GE(efd[1], 0);
2653
2654         efd[2] = epoll_create(1);
2655         ASSERT_GE(efd[2], 0);
2656
2657         events[0].events = EPOLLIN;
2658         ASSERT_EQ(epoll_ctl(efd[1], EPOLL_CTL_ADD, sfd[0], events), 0);
2659
2660         events[0].events = EPOLLIN;
2661         ASSERT_EQ(epoll_ctl(efd[2], EPOLL_CTL_ADD, sfd[2], events), 0);
2662
2663         events[0].events = EPOLLIN | EPOLLET;
2664         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[1], events), 0);
2665
2666         events[0].events = EPOLLIN | EPOLLET;
2667         ASSERT_EQ(epoll_ctl(efd[0], EPOLL_CTL_ADD, efd[2], events), 0);
2668
2669         ASSERT_EQ(write(sfd[1], "w", 1), 1);
2670         ASSERT_EQ(write(sfd[3], "w", 1), 1);
2671
2672         pfd.fd = efd[0];
2673         pfd.events = POLLIN;
2674         EXPECT_EQ(poll(&pfd, 1, 0), 1);
2675         EXPECT_EQ(epoll_wait(efd[0], events, 2, 0), 2);
2676
2677         pfd.fd = efd[0];
2678         pfd.events = POLLIN;
2679         EXPECT_EQ(poll(&pfd, 1, 0), 0);
2680         EXPECT_EQ(epoll_wait(efd[0], events, 2, 0), 0);
2681
2682         close(efd[0]);
2683         close(efd[1]);
2684         close(efd[2]);
2685         close(sfd[0]);
2686         close(sfd[1]);
2687         close(sfd[2]);
2688         close(sfd[3]);
2689 }
2690
2691 /*
2692  *        t0    t1
2693  *     (ew) \  / (ew)
2694  *           e0
2695  *     (lt) /  \ (lt)
2696  *        e1    e2
2697  *    (lt) |     | (lt)
2698  *        s0    s2
2699  */
2700 TEST(epoll53)
2701 {
2702         pthread_t emitter;
2703         struct epoll_event e;
2704         struct epoll_mtcontext ctx = { 0 };
2705
2706         signal(SIGUSR1, signal_handler);
2707
2708         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
2709         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
2710
2711         ctx.efd[0] = epoll_create(1);
2712         ASSERT_GE(ctx.efd[0], 0);
2713
2714         ctx.efd[1] = epoll_create(1);
2715         ASSERT_GE(ctx.efd[1], 0);
2716
2717         ctx.efd[2] = epoll_create(1);
2718         ASSERT_GE(ctx.efd[2], 0);
2719
2720         e.events = EPOLLIN;
2721         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2722
2723         e.events = EPOLLIN;
2724         ASSERT_EQ(epoll_ctl(ctx.efd[2], EPOLL_CTL_ADD, ctx.sfd[2], &e), 0);
2725
2726         e.events = EPOLLIN;
2727         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2728
2729         e.events = EPOLLIN;
2730         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[2], &e), 0);
2731
2732         ctx.main = pthread_self();
2733         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
2734         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
2735
2736         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
2737                 __sync_fetch_and_add(&ctx.count, 1);
2738
2739         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2740         EXPECT_EQ(ctx.count, 2);
2741
2742         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2743                 pthread_kill(emitter, SIGUSR1);
2744                 pthread_join(emitter, NULL);
2745         }
2746
2747         close(ctx.efd[0]);
2748         close(ctx.efd[1]);
2749         close(ctx.efd[2]);
2750         close(ctx.sfd[0]);
2751         close(ctx.sfd[1]);
2752         close(ctx.sfd[2]);
2753         close(ctx.sfd[3]);
2754 }
2755
2756 /*
2757  *        t0    t1
2758  *     (ew) \  / (ew)
2759  *           e0
2760  *     (et) /  \ (et)
2761  *        e1    e2
2762  *    (lt) |     | (lt)
2763  *        s0    s2
2764  */
2765 TEST(epoll54)
2766 {
2767         pthread_t emitter;
2768         struct epoll_event e;
2769         struct epoll_mtcontext ctx = { 0 };
2770
2771         signal(SIGUSR1, signal_handler);
2772
2773         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
2774         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
2775
2776         ctx.efd[0] = epoll_create(1);
2777         ASSERT_GE(ctx.efd[0], 0);
2778
2779         ctx.efd[1] = epoll_create(1);
2780         ASSERT_GE(ctx.efd[1], 0);
2781
2782         ctx.efd[2] = epoll_create(1);
2783         ASSERT_GE(ctx.efd[2], 0);
2784
2785         e.events = EPOLLIN;
2786         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2787
2788         e.events = EPOLLIN;
2789         ASSERT_EQ(epoll_ctl(ctx.efd[2], EPOLL_CTL_ADD, ctx.sfd[2], &e), 0);
2790
2791         e.events = EPOLLIN | EPOLLET;
2792         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2793
2794         e.events = EPOLLIN | EPOLLET;
2795         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[2], &e), 0);
2796
2797         ctx.main = pthread_self();
2798         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1a, &ctx), 0);
2799         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
2800
2801         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
2802                 __sync_fetch_and_add(&ctx.count, 1);
2803
2804         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2805         EXPECT_EQ(ctx.count, 2);
2806
2807         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2808                 pthread_kill(emitter, SIGUSR1);
2809                 pthread_join(emitter, NULL);
2810         }
2811
2812         close(ctx.efd[0]);
2813         close(ctx.efd[1]);
2814         close(ctx.efd[2]);
2815         close(ctx.sfd[0]);
2816         close(ctx.sfd[1]);
2817         close(ctx.sfd[2]);
2818         close(ctx.sfd[3]);
2819 }
2820
2821 /*
2822  *        t0    t1
2823  *     (ew) \  / (p)
2824  *           e0
2825  *     (lt) /  \ (lt)
2826  *        e1    e2
2827  *    (lt) |     | (lt)
2828  *        s0    s2
2829  */
2830 TEST(epoll55)
2831 {
2832         pthread_t emitter;
2833         struct epoll_event e;
2834         struct epoll_mtcontext ctx = { 0 };
2835
2836         signal(SIGUSR1, signal_handler);
2837
2838         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
2839         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
2840
2841         ctx.efd[0] = epoll_create(1);
2842         ASSERT_GE(ctx.efd[0], 0);
2843
2844         ctx.efd[1] = epoll_create(1);
2845         ASSERT_GE(ctx.efd[1], 0);
2846
2847         ctx.efd[2] = epoll_create(1);
2848         ASSERT_GE(ctx.efd[2], 0);
2849
2850         e.events = EPOLLIN;
2851         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2852
2853         e.events = EPOLLIN;
2854         ASSERT_EQ(epoll_ctl(ctx.efd[2], EPOLL_CTL_ADD, ctx.sfd[2], &e), 0);
2855
2856         e.events = EPOLLIN;
2857         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2858
2859         e.events = EPOLLIN;
2860         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[2], &e), 0);
2861
2862         ctx.main = pthread_self();
2863         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
2864         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
2865
2866         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
2867                 __sync_fetch_and_add(&ctx.count, 1);
2868
2869         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2870         EXPECT_EQ(ctx.count, 2);
2871
2872         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2873                 pthread_kill(emitter, SIGUSR1);
2874                 pthread_join(emitter, NULL);
2875         }
2876
2877         close(ctx.efd[0]);
2878         close(ctx.efd[1]);
2879         close(ctx.efd[2]);
2880         close(ctx.sfd[0]);
2881         close(ctx.sfd[1]);
2882         close(ctx.sfd[2]);
2883         close(ctx.sfd[3]);
2884 }
2885
2886 /*
2887  *        t0    t1
2888  *     (ew) \  / (p)
2889  *           e0
2890  *     (et) /  \ (et)
2891  *        e1    e2
2892  *    (lt) |     | (lt)
2893  *        s0    s2
2894  */
2895 TEST(epoll56)
2896 {
2897         pthread_t emitter;
2898         struct epoll_event e;
2899         struct epoll_mtcontext ctx = { 0 };
2900
2901         signal(SIGUSR1, signal_handler);
2902
2903         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
2904         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
2905
2906         ctx.efd[0] = epoll_create(1);
2907         ASSERT_GE(ctx.efd[0], 0);
2908
2909         ctx.efd[1] = epoll_create(1);
2910         ASSERT_GE(ctx.efd[1], 0);
2911
2912         ctx.efd[2] = epoll_create(1);
2913         ASSERT_GE(ctx.efd[2], 0);
2914
2915         e.events = EPOLLIN;
2916         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2917
2918         e.events = EPOLLIN;
2919         ASSERT_EQ(epoll_ctl(ctx.efd[2], EPOLL_CTL_ADD, ctx.sfd[2], &e), 0);
2920
2921         e.events = EPOLLIN | EPOLLET;
2922         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2923
2924         e.events = EPOLLIN | EPOLLET;
2925         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[2], &e), 0);
2926
2927         ctx.main = pthread_self();
2928         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
2929         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
2930
2931         if (epoll_wait(ctx.efd[0], &e, 1, -1) > 0)
2932                 __sync_fetch_and_add(&ctx.count, 1);
2933
2934         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
2935         EXPECT_EQ(ctx.count, 2);
2936
2937         if (pthread_tryjoin_np(emitter, NULL) < 0) {
2938                 pthread_kill(emitter, SIGUSR1);
2939                 pthread_join(emitter, NULL);
2940         }
2941
2942         close(ctx.efd[0]);
2943         close(ctx.efd[1]);
2944         close(ctx.efd[2]);
2945         close(ctx.sfd[0]);
2946         close(ctx.sfd[1]);
2947         close(ctx.sfd[2]);
2948         close(ctx.sfd[3]);
2949 }
2950
2951 /*
2952  *        t0    t1
2953  *      (p) \  / (p)
2954  *           e0
2955  *     (lt) /  \ (lt)
2956  *        e1    e2
2957  *    (lt) |     | (lt)
2958  *        s0    s2
2959  */
2960 TEST(epoll57)
2961 {
2962         pthread_t emitter;
2963         struct pollfd pfd;
2964         struct epoll_event e;
2965         struct epoll_mtcontext ctx = { 0 };
2966
2967         signal(SIGUSR1, signal_handler);
2968
2969         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
2970         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
2971
2972         ctx.efd[0] = epoll_create(1);
2973         ASSERT_GE(ctx.efd[0], 0);
2974
2975         ctx.efd[1] = epoll_create(1);
2976         ASSERT_GE(ctx.efd[1], 0);
2977
2978         ctx.efd[2] = epoll_create(1);
2979         ASSERT_GE(ctx.efd[2], 0);
2980
2981         e.events = EPOLLIN;
2982         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
2983
2984         e.events = EPOLLIN;
2985         ASSERT_EQ(epoll_ctl(ctx.efd[2], EPOLL_CTL_ADD, ctx.sfd[2], &e), 0);
2986
2987         e.events = EPOLLIN;
2988         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
2989
2990         e.events = EPOLLIN;
2991         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[2], &e), 0);
2992
2993         ctx.main = pthread_self();
2994         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
2995         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
2996
2997         pfd.fd = ctx.efd[0];
2998         pfd.events = POLLIN;
2999         if (poll(&pfd, 1, -1) > 0) {
3000                 if (epoll_wait(ctx.efd[0], &e, 1, 0) > 0)
3001                         __sync_fetch_and_add(&ctx.count, 1);
3002         }
3003
3004         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
3005         EXPECT_EQ(ctx.count, 2);
3006
3007         if (pthread_tryjoin_np(emitter, NULL) < 0) {
3008                 pthread_kill(emitter, SIGUSR1);
3009                 pthread_join(emitter, NULL);
3010         }
3011
3012         close(ctx.efd[0]);
3013         close(ctx.efd[1]);
3014         close(ctx.efd[2]);
3015         close(ctx.sfd[0]);
3016         close(ctx.sfd[1]);
3017         close(ctx.sfd[2]);
3018         close(ctx.sfd[3]);
3019 }
3020
3021 /*
3022  *        t0    t1
3023  *      (p) \  / (p)
3024  *           e0
3025  *     (et) /  \ (et)
3026  *        e1    e2
3027  *    (lt) |     | (lt)
3028  *        s0    s2
3029  */
3030 TEST(epoll58)
3031 {
3032         pthread_t emitter;
3033         struct pollfd pfd;
3034         struct epoll_event e;
3035         struct epoll_mtcontext ctx = { 0 };
3036
3037         signal(SIGUSR1, signal_handler);
3038
3039         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[0]), 0);
3040         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, &ctx.sfd[2]), 0);
3041
3042         ctx.efd[0] = epoll_create(1);
3043         ASSERT_GE(ctx.efd[0], 0);
3044
3045         ctx.efd[1] = epoll_create(1);
3046         ASSERT_GE(ctx.efd[1], 0);
3047
3048         ctx.efd[2] = epoll_create(1);
3049         ASSERT_GE(ctx.efd[2], 0);
3050
3051         e.events = EPOLLIN;
3052         ASSERT_EQ(epoll_ctl(ctx.efd[1], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
3053
3054         e.events = EPOLLIN;
3055         ASSERT_EQ(epoll_ctl(ctx.efd[2], EPOLL_CTL_ADD, ctx.sfd[2], &e), 0);
3056
3057         e.events = EPOLLIN | EPOLLET;
3058         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[1], &e), 0);
3059
3060         e.events = EPOLLIN | EPOLLET;
3061         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.efd[2], &e), 0);
3062
3063         ctx.main = pthread_self();
3064         ASSERT_EQ(pthread_create(&ctx.waiter, NULL, waiter_entry1ap, &ctx), 0);
3065         ASSERT_EQ(pthread_create(&emitter, NULL, emitter_entry2, &ctx), 0);
3066
3067         pfd.fd = ctx.efd[0];
3068         pfd.events = POLLIN;
3069         if (poll(&pfd, 1, -1) > 0) {
3070                 if (epoll_wait(ctx.efd[0], &e, 1, 0) > 0)
3071                         __sync_fetch_and_add(&ctx.count, 1);
3072         }
3073
3074         ASSERT_EQ(pthread_join(ctx.waiter, NULL), 0);
3075         EXPECT_EQ(ctx.count, 2);
3076
3077         if (pthread_tryjoin_np(emitter, NULL) < 0) {
3078                 pthread_kill(emitter, SIGUSR1);
3079                 pthread_join(emitter, NULL);
3080         }
3081
3082         close(ctx.efd[0]);
3083         close(ctx.efd[1]);
3084         close(ctx.efd[2]);
3085         close(ctx.sfd[0]);
3086         close(ctx.sfd[1]);
3087         close(ctx.sfd[2]);
3088         close(ctx.sfd[3]);
3089 }
3090
3091 static void *epoll59_thread(void *ctx_)
3092 {
3093         struct epoll_mtcontext *ctx = ctx_;
3094         struct epoll_event e;
3095         int i;
3096
3097         for (i = 0; i < 100000; i++) {
3098                 while (ctx->count == 0)
3099                         ;
3100
3101                 e.events = EPOLLIN | EPOLLERR | EPOLLET;
3102                 epoll_ctl(ctx->efd[0], EPOLL_CTL_MOD, ctx->sfd[0], &e);
3103                 ctx->count = 0;
3104         }
3105
3106         return NULL;
3107 }
3108
3109 /*
3110  *        t0
3111  *      (p) \
3112  *           e0
3113  *     (et) /
3114  *        e0
3115  *
3116  * Based on https://bugzilla.kernel.org/show_bug.cgi?id=205933
3117  */
3118 TEST(epoll59)
3119 {
3120         pthread_t emitter;
3121         struct pollfd pfd;
3122         struct epoll_event e;
3123         struct epoll_mtcontext ctx = { 0 };
3124         int i, ret;
3125
3126         signal(SIGUSR1, signal_handler);
3127
3128         ctx.efd[0] = epoll_create1(0);
3129         ASSERT_GE(ctx.efd[0], 0);
3130
3131         ctx.sfd[0] = eventfd(1, 0);
3132         ASSERT_GE(ctx.sfd[0], 0);
3133
3134         e.events = EPOLLIN | EPOLLERR | EPOLLET;
3135         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
3136
3137         ASSERT_EQ(pthread_create(&emitter, NULL, epoll59_thread, &ctx), 0);
3138
3139         for (i = 0; i < 100000; i++) {
3140                 ret = epoll_wait(ctx.efd[0], &e, 1, 1000);
3141                 ASSERT_GT(ret, 0);
3142
3143                 while (ctx.count != 0)
3144                         ;
3145                 ctx.count = 1;
3146         }
3147         if (pthread_tryjoin_np(emitter, NULL) < 0) {
3148                 pthread_kill(emitter, SIGUSR1);
3149                 pthread_join(emitter, NULL);
3150         }
3151         close(ctx.efd[0]);
3152         close(ctx.sfd[0]);
3153 }
3154
3155 enum {
3156         EPOLL60_EVENTS_NR = 10,
3157 };
3158
3159 struct epoll60_ctx {
3160         volatile int stopped;
3161         int ready;
3162         int waiters;
3163         int epfd;
3164         int evfd[EPOLL60_EVENTS_NR];
3165 };
3166
3167 static void *epoll60_wait_thread(void *ctx_)
3168 {
3169         struct epoll60_ctx *ctx = ctx_;
3170         struct epoll_event e;
3171         sigset_t sigmask;
3172         uint64_t v;
3173         int ret;
3174
3175         /* Block SIGUSR1 */
3176         sigemptyset(&sigmask);
3177         sigaddset(&sigmask, SIGUSR1);
3178         sigprocmask(SIG_SETMASK, &sigmask, NULL);
3179
3180         /* Prepare empty mask for epoll_pwait() */
3181         sigemptyset(&sigmask);
3182
3183         while (!ctx->stopped) {
3184                 /* Mark we are ready */
3185                 __atomic_fetch_add(&ctx->ready, 1, __ATOMIC_ACQUIRE);
3186
3187                 /* Start when all are ready */
3188                 while (__atomic_load_n(&ctx->ready, __ATOMIC_ACQUIRE) &&
3189                        !ctx->stopped);
3190
3191                 /* Account this waiter */
3192                 __atomic_fetch_add(&ctx->waiters, 1, __ATOMIC_ACQUIRE);
3193
3194                 ret = epoll_pwait(ctx->epfd, &e, 1, 2000, &sigmask);
3195                 if (ret != 1) {
3196                         /* We expect only signal delivery on stop */
3197                         assert(ret < 0 && errno == EINTR && "Lost wakeup!\n");
3198                         assert(ctx->stopped);
3199                         break;
3200                 }
3201
3202                 ret = read(e.data.fd, &v, sizeof(v));
3203                 /* Since we are on ET mode, thus each thread gets its own fd. */
3204                 assert(ret == sizeof(v));
3205
3206                 __atomic_fetch_sub(&ctx->waiters, 1, __ATOMIC_RELEASE);
3207         }
3208
3209         return NULL;
3210 }
3211
3212 static inline unsigned long long msecs(void)
3213 {
3214         struct timespec ts;
3215         unsigned long long msecs;
3216
3217         clock_gettime(CLOCK_REALTIME, &ts);
3218         msecs = ts.tv_sec * 1000ull;
3219         msecs += ts.tv_nsec / 1000000ull;
3220
3221         return msecs;
3222 }
3223
3224 static inline int count_waiters(struct epoll60_ctx *ctx)
3225 {
3226         return __atomic_load_n(&ctx->waiters, __ATOMIC_ACQUIRE);
3227 }
3228
3229 TEST(epoll60)
3230 {
3231         struct epoll60_ctx ctx = { 0 };
3232         pthread_t waiters[ARRAY_SIZE(ctx.evfd)];
3233         struct epoll_event e;
3234         int i, n, ret;
3235
3236         signal(SIGUSR1, signal_handler);
3237
3238         ctx.epfd = epoll_create1(0);
3239         ASSERT_GE(ctx.epfd, 0);
3240
3241         /* Create event fds */
3242         for (i = 0; i < ARRAY_SIZE(ctx.evfd); i++) {
3243                 ctx.evfd[i] = eventfd(0, EFD_NONBLOCK);
3244                 ASSERT_GE(ctx.evfd[i], 0);
3245
3246                 e.events = EPOLLIN | EPOLLET;
3247                 e.data.fd = ctx.evfd[i];
3248                 ASSERT_EQ(epoll_ctl(ctx.epfd, EPOLL_CTL_ADD, ctx.evfd[i], &e), 0);
3249         }
3250
3251         /* Create waiter threads */
3252         for (i = 0; i < ARRAY_SIZE(waiters); i++)
3253                 ASSERT_EQ(pthread_create(&waiters[i], NULL,
3254                                          epoll60_wait_thread, &ctx), 0);
3255
3256         for (i = 0; i < 300; i++) {
3257                 uint64_t v = 1, ms;
3258
3259                 /* Wait for all to be ready */
3260                 while (__atomic_load_n(&ctx.ready, __ATOMIC_ACQUIRE) !=
3261                        ARRAY_SIZE(ctx.evfd))
3262                         ;
3263
3264                 /* Steady, go */
3265                 __atomic_fetch_sub(&ctx.ready, ARRAY_SIZE(ctx.evfd),
3266                                    __ATOMIC_ACQUIRE);
3267
3268                 /* Wait all have gone to kernel */
3269                 while (count_waiters(&ctx) != ARRAY_SIZE(ctx.evfd))
3270                         ;
3271
3272                 /* 1ms should be enough to schedule away */
3273                 usleep(1000);
3274
3275                 /* Quickly signal all handles at once */
3276                 for (n = 0; n < ARRAY_SIZE(ctx.evfd); n++) {
3277                         ret = write(ctx.evfd[n], &v, sizeof(v));
3278                         ASSERT_EQ(ret, sizeof(v));
3279                 }
3280
3281                 /* Busy loop for 1s and wait for all waiters to wake up */
3282                 ms = msecs();
3283                 while (count_waiters(&ctx) && msecs() < ms + 1000)
3284                         ;
3285
3286                 ASSERT_EQ(count_waiters(&ctx), 0);
3287         }
3288         ctx.stopped = 1;
3289         /* Stop waiters */
3290         for (i = 0; i < ARRAY_SIZE(waiters); i++)
3291                 ret = pthread_kill(waiters[i], SIGUSR1);
3292         for (i = 0; i < ARRAY_SIZE(waiters); i++)
3293                 pthread_join(waiters[i], NULL);
3294
3295         for (i = 0; i < ARRAY_SIZE(waiters); i++)
3296                 close(ctx.evfd[i]);
3297         close(ctx.epfd);
3298 }
3299
3300 struct epoll61_ctx {
3301         int epfd;
3302         int evfd;
3303 };
3304
3305 static void *epoll61_write_eventfd(void *ctx_)
3306 {
3307         struct epoll61_ctx *ctx = ctx_;
3308         int64_t l = 1;
3309
3310         usleep(10950);
3311         write(ctx->evfd, &l, sizeof(l));
3312         return NULL;
3313 }
3314
3315 static void *epoll61_epoll_with_timeout(void *ctx_)
3316 {
3317         struct epoll61_ctx *ctx = ctx_;
3318         struct epoll_event events[1];
3319         int n;
3320
3321         n = epoll_wait(ctx->epfd, events, 1, 11);
3322         /*
3323          * If epoll returned the eventfd, write on the eventfd to wake up the
3324          * blocking poller.
3325          */
3326         if (n == 1) {
3327                 int64_t l = 1;
3328
3329                 write(ctx->evfd, &l, sizeof(l));
3330         }
3331         return NULL;
3332 }
3333
3334 static void *epoll61_blocking_epoll(void *ctx_)
3335 {
3336         struct epoll61_ctx *ctx = ctx_;
3337         struct epoll_event events[1];
3338
3339         epoll_wait(ctx->epfd, events, 1, -1);
3340         return NULL;
3341 }
3342
3343 TEST(epoll61)
3344 {
3345         struct epoll61_ctx ctx;
3346         struct epoll_event ev;
3347         int i, r;
3348
3349         ctx.epfd = epoll_create1(0);
3350         ASSERT_GE(ctx.epfd, 0);
3351         ctx.evfd = eventfd(0, EFD_NONBLOCK);
3352         ASSERT_GE(ctx.evfd, 0);
3353
3354         ev.events = EPOLLIN | EPOLLET | EPOLLERR | EPOLLHUP;
3355         ev.data.ptr = NULL;
3356         r = epoll_ctl(ctx.epfd, EPOLL_CTL_ADD, ctx.evfd, &ev);
3357         ASSERT_EQ(r, 0);
3358
3359         /*
3360          * We are testing a race.  Repeat the test case 1000 times to make it
3361          * more likely to fail in case of a bug.
3362          */
3363         for (i = 0; i < 1000; i++) {
3364                 pthread_t threads[3];
3365                 int n;
3366
3367                 /*
3368                  * Start 3 threads:
3369                  * Thread 1 sleeps for 10.9ms and writes to the evenfd.
3370                  * Thread 2 calls epoll with a timeout of 11ms.
3371                  * Thread 3 calls epoll with a timeout of -1.
3372                  *
3373                  * The eventfd write by Thread 1 should either wakeup Thread 2
3374                  * or Thread 3.  If it wakes up Thread 2, Thread 2 writes on the
3375                  * eventfd to wake up Thread 3.
3376                  *
3377                  * If no events are missed, all three threads should eventually
3378                  * be joinable.
3379                  */
3380                 ASSERT_EQ(pthread_create(&threads[0], NULL,
3381                                          epoll61_write_eventfd, &ctx), 0);
3382                 ASSERT_EQ(pthread_create(&threads[1], NULL,
3383                                          epoll61_epoll_with_timeout, &ctx), 0);
3384                 ASSERT_EQ(pthread_create(&threads[2], NULL,
3385                                          epoll61_blocking_epoll, &ctx), 0);
3386
3387                 for (n = 0; n < ARRAY_SIZE(threads); ++n)
3388                         ASSERT_EQ(pthread_join(threads[n], NULL), 0);
3389         }
3390
3391         close(ctx.epfd);
3392         close(ctx.evfd);
3393 }
3394
3395 /* Equivalent to basic test epoll1, but exercising epoll_pwait2. */
3396 TEST(epoll62)
3397 {
3398         int efd;
3399         int sfd[2];
3400         struct epoll_event e;
3401
3402         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
3403
3404         efd = epoll_create(1);
3405         ASSERT_GE(efd, 0);
3406
3407         e.events = EPOLLIN;
3408         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], &e), 0);
3409
3410         ASSERT_EQ(write(sfd[1], "w", 1), 1);
3411
3412         EXPECT_EQ(sys_epoll_pwait2(efd, &e, 1, NULL, NULL, 0), 1);
3413         EXPECT_EQ(sys_epoll_pwait2(efd, &e, 1, NULL, NULL, 0), 1);
3414
3415         close(efd);
3416         close(sfd[0]);
3417         close(sfd[1]);
3418 }
3419
3420 /* Epoll_pwait2 basic timeout test. */
3421 TEST(epoll63)
3422 {
3423         const int cfg_delay_ms = 10;
3424         unsigned long long tdiff;
3425         struct __kernel_timespec ts;
3426         int efd;
3427         int sfd[2];
3428         struct epoll_event e;
3429
3430         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, sfd), 0);
3431
3432         efd = epoll_create(1);
3433         ASSERT_GE(efd, 0);
3434
3435         e.events = EPOLLIN;
3436         ASSERT_EQ(epoll_ctl(efd, EPOLL_CTL_ADD, sfd[0], &e), 0);
3437
3438         ts.tv_sec = 0;
3439         ts.tv_nsec = cfg_delay_ms * 1000 * 1000;
3440
3441         tdiff = msecs();
3442         EXPECT_EQ(sys_epoll_pwait2(efd, &e, 1, &ts, NULL, 0), 0);
3443         tdiff = msecs() - tdiff;
3444
3445         EXPECT_GE(tdiff, cfg_delay_ms);
3446
3447         close(efd);
3448         close(sfd[0]);
3449         close(sfd[1]);
3450 }
3451
3452 /*
3453  *        t0    t1
3454  *     (ew) \  / (ew)
3455  *           e0
3456  *            | (lt)
3457  *           s0
3458  */
3459 TEST(epoll64)
3460 {
3461         pthread_t waiter[2];
3462         struct epoll_event e;
3463         struct epoll_mtcontext ctx = { 0 };
3464
3465         signal(SIGUSR1, signal_handler);
3466
3467         ASSERT_EQ(socketpair(AF_UNIX, SOCK_STREAM, 0, ctx.sfd), 0);
3468
3469         ctx.efd[0] = epoll_create(1);
3470         ASSERT_GE(ctx.efd[0], 0);
3471
3472         e.events = EPOLLIN;
3473         ASSERT_EQ(epoll_ctl(ctx.efd[0], EPOLL_CTL_ADD, ctx.sfd[0], &e), 0);
3474
3475         /*
3476          * main will act as the emitter once both waiter threads are
3477          * blocked and expects to both be awoken upon the ready event.
3478          */
3479         ctx.main = pthread_self();
3480         ASSERT_EQ(pthread_create(&waiter[0], NULL, waiter_entry1a, &ctx), 0);
3481         ASSERT_EQ(pthread_create(&waiter[1], NULL, waiter_entry1a, &ctx), 0);
3482
3483         usleep(100000);
3484         ASSERT_EQ(write(ctx.sfd[1], "w", 1), 1);
3485
3486         ASSERT_EQ(pthread_join(waiter[0], NULL), 0);
3487         ASSERT_EQ(pthread_join(waiter[1], NULL), 0);
3488
3489         EXPECT_EQ(ctx.count, 2);
3490
3491         close(ctx.efd[0]);
3492         close(ctx.sfd[0]);
3493         close(ctx.sfd[1]);
3494 }
3495
3496 TEST_HARNESS_MAIN