lib/tevent/testsuite.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    testing of the events subsystem
   5
   6    Copyright (C) Stefan Metzmacher 2006-2009
   7    Copyright (C) Jeremy Allison    2013
   8
   9      ** NOTE! The following LGPL license applies to the tevent
  10      ** library. This does NOT imply that all of Samba is released
  11      ** under the LGPL
  12
  13    This library is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU Lesser General Public
  15    License as published by the Free Software Foundation; either
  16    version 3 of the License, or (at your option) any later version.
  17
  18    This library is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21    Lesser General Public License for more details.
  22
  23    You should have received a copy of the GNU Lesser General Public
  24    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  25 */
  26
  27 #include "includes.h"
  28 #include "lib/tevent/tevent.h"
  29 #include "system/filesys.h"
  30 #include "system/select.h"
  31 #include "system/network.h"
  32 #include "torture/torture.h"
  33 #ifdef HAVE_PTHREAD
  34 #include <pthread.h>
  35 #include <assert.h>
  36 #endif
  37
  38 static int fde_count;
  39
  40 static void fde_handler_read(struct tevent_context *ev_ctx, struct tevent_fd *f,
  41                         uint16_t flags, void *private_data)
  42 {
  43         int *fd = (int *)private_data;
  44         char c;
  45 #ifdef SA_SIGINFO
  46         kill(getpid(), SIGUSR1);
  47 #endif
  48         kill(getpid(), SIGALRM);
  49
  50         read(fd[0], &c, 1);
  51         fde_count++;
  52 }
  53
  54 static void fde_handler_write(struct tevent_context *ev_ctx, struct tevent_fd *f,
  55                         uint16_t flags, void *private_data)
  56 {
  57         int *fd = (int *)private_data;
  58         char c = 0;
  59         write(fd[1], &c, 1);
  60 }
  61
  62
  63 /* This will only fire if the fd's returned from pipe() are bi-directional. */
  64 static void fde_handler_read_1(struct tevent_context *ev_ctx, struct tevent_fd *f,
  65                         uint16_t flags, void *private_data)
  66 {
  67         int *fd = (int *)private_data;
  68         char c;
  69 #ifdef SA_SIGINFO
  70         kill(getpid(), SIGUSR1);
  71 #endif
  72         kill(getpid(), SIGALRM);
  73
  74         read(fd[1], &c, 1);
  75         fde_count++;
  76 }
  77
  78 /* This will only fire if the fd's returned from pipe() are bi-directional. */
  79 static void fde_handler_write_1(struct tevent_context *ev_ctx, struct tevent_fd *f,
  80                         uint16_t flags, void *private_data)
  81 {
  82         int *fd = (int *)private_data;
  83         char c = 0;
  84         write(fd[0], &c, 1);
  85 }
  86
  87 static void finished_handler(struct tevent_context *ev_ctx, struct tevent_timer *te,
  88                              struct timeval tval, void *private_data)
  89 {
  90         int *finished = (int *)private_data;
  91         (*finished) = 1;
  92 }
  93
  94 static void count_handler(struct tevent_context *ev_ctx, struct tevent_signal *te,
  95                           int signum, int count, void *info, void *private_data)
  96 {
  97         int *countp = (int *)private_data;
  98         (*countp) += count;
  99 }
 100
 101 static bool test_event_context(struct torture_context *test,
 102                                const void *test_data)
 103 {
 104         struct tevent_context *ev_ctx;
 105         int fd[2] = { -1, -1 };
 106         const char *backend = (const char *)test_data;
 107         int alarm_count=0, info_count=0;
 108         struct tevent_fd *fde_read;
 109         struct tevent_fd *fde_read_1;
 110         struct tevent_fd *fde_write;
 111         struct tevent_fd *fde_write_1;
 112 #ifdef SA_RESTART
 113         struct tevent_signal *se1 = NULL;
 114 #endif
 115 #ifdef SA_RESETHAND
 116         struct tevent_signal *se2 = NULL;
 117 #endif
 118 #ifdef SA_SIGINFO
 119         struct tevent_signal *se3 = NULL;
 120 #endif
 121         int finished=0;
 122         struct timeval t;
 123
 124         ev_ctx = tevent_context_init_byname(test, backend);
 125         if (ev_ctx == NULL) {
 126                 torture_comment(test, "event backend '%s' not supported\n", backend);
 127                 return true;
 128         }
 129
 130         torture_comment(test, "backend '%s' - %s\n",
 131                         backend, __FUNCTION__);
 132
 133         /* reset globals */
 134         fde_count = 0;
 135
 136         /* create a pipe */
 137         pipe(fd);
 138
 139         fde_read = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_READ,
 140                             fde_handler_read, fd);
 141         fde_write_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[0], TEVENT_FD_WRITE,
 142                             fde_handler_write_1, fd);
 143
 144         fde_write = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_WRITE,
 145                             fde_handler_write, fd);
 146         fde_read_1 = tevent_add_fd(ev_ctx, ev_ctx, fd[1], TEVENT_FD_READ,
 147                             fde_handler_read_1, fd);
 148
 149         tevent_fd_set_auto_close(fde_read);
 150         tevent_fd_set_auto_close(fde_write);
 151
 152         tevent_add_timer(ev_ctx, ev_ctx, timeval_current_ofs(2,0),
 153                          finished_handler, &finished);
 154
 155 #ifdef SA_RESTART
 156         se1 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESTART, count_handler, &alarm_count);
 157         torture_assert(test, se1 != NULL, "failed to setup se1");
 158 #endif
 159 #ifdef SA_RESETHAND
 160         se2 = tevent_add_signal(ev_ctx, ev_ctx, SIGALRM, SA_RESETHAND, count_handler, &alarm_count);
 161         torture_assert(test, se2 != NULL, "failed to setup se2");
 162 #endif
 163 #ifdef SA_SIGINFO
 164         se3 = tevent_add_signal(ev_ctx, ev_ctx, SIGUSR1, SA_SIGINFO, count_handler, &info_count);
 165         torture_assert(test, se3 != NULL, "failed to setup se3");
 166 #endif
 167
 168         t = timeval_current();
 169         while (!finished) {
 170                 errno = 0;
 171                 if (tevent_loop_once(ev_ctx) == -1) {
 172                         talloc_free(ev_ctx);
 173                         torture_fail(test, talloc_asprintf(test, "Failed event loop %s\n", strerror(errno)));
 174                 }
 175         }
 176
 177         talloc_free(fde_read);
 178         talloc_free(fde_write);
 179         talloc_free(fde_read_1);
 180         talloc_free(fde_write_1);
 181
 182         while (alarm_count < fde_count+1) {
 183                 if (tevent_loop_once(ev_ctx) == -1) {
 184                         break;
 185                 }
 186         }
 187
 188         torture_comment(test, "Got %.2f pipe events/sec\n", fde_count/timeval_elapsed(&t));
 189
 190 #ifdef SA_RESTART
 191         talloc_free(se1);
 192 #endif
 193
 194         torture_assert_int_equal(test, alarm_count, 1+fde_count, "alarm count mismatch");
 195
 196 #ifdef SA_RESETHAND
 197         /*
 198          * we do not call talloc_free(se2)
 199          * because it is already gone,
 200          * after triggering the event handler.
 201          */
 202 #endif
 203
 204 #ifdef SA_SIGINFO
 205         talloc_free(se3);
 206         torture_assert_int_equal(test, info_count, fde_count, "info count mismatch");
 207 #endif
 208
 209         talloc_free(ev_ctx);
 210
 211         return true;
 212 }
 213
 214 struct test_event_fd1_state {
 215         struct torture_context *tctx;
 216         const char *backend;
 217         struct tevent_context *ev;
 218         int sock[2];
 219         struct tevent_timer *te;
 220         struct tevent_fd *fde0;
 221         struct tevent_fd *fde1;
 222         bool got_write;
 223         bool got_read;
 224         bool drain;
 225         bool drain_done;
 226         unsigned loop_count;
 227         bool finished;
 228         const char *error;
 229 };
 230
 231 static void test_event_fd1_fde_handler(struct tevent_context *ev_ctx,
 232                                        struct tevent_fd *fde,
 233                                        uint16_t flags,
 234                                        void *private_data)
 235 {
 236         struct test_event_fd1_state *state =
 237                 (struct test_event_fd1_state *)private_data;
 238
 239         if (state->drain_done) {
 240                 state->finished = true;
 241                 state->error = __location__;
 242                 return;
 243         }
 244
 245         if (state->drain) {
 246                 ssize_t ret;
 247                 uint8_t c = 0;
 248
 249                 if (!(flags & TEVENT_FD_READ)) {
 250                         state->finished = true;
 251                         state->error = __location__;
 252                         return;
 253                 }
 254
 255                 ret = read(state->sock[0], &c, 1);
 256                 if (ret == 1) {
 257                         return;
 258                 }
 259
 260                 /*
 261                  * end of test...
 262                  */
 263                 tevent_fd_set_flags(fde, 0);
 264                 state->drain_done = true;
 265                 return;
 266         }
 267
 268         if (!state->got_write) {
 269                 uint8_t c = 0;
 270
 271                 if (flags != TEVENT_FD_WRITE) {
 272                         state->finished = true;
 273                         state->error = __location__;
 274                         return;
 275                 }
 276                 state->got_write = true;
 277
 278                 /*
 279                  * we write to the other socket...
 280                  */
 281                 write(state->sock[1], &c, 1);
 282                 TEVENT_FD_NOT_WRITEABLE(fde);
 283                 TEVENT_FD_READABLE(fde);
 284                 return;
 285         }
 286
 287         if (!state->got_read) {
 288                 if (flags != TEVENT_FD_READ) {
 289                         state->finished = true;
 290                         state->error = __location__;
 291                         return;
 292                 }
 293                 state->got_read = true;
 294
 295                 TEVENT_FD_NOT_READABLE(fde);
 296                 return;
 297         }
 298
 299         state->finished = true;
 300         state->error = __location__;
 301         return;
 302 }
 303
 304 static void test_event_fd1_finished(struct tevent_context *ev_ctx,
 305                                     struct tevent_timer *te,
 306                                     struct timeval tval,
 307                                     void *private_data)
 308 {
 309         struct test_event_fd1_state *state =
 310                 (struct test_event_fd1_state *)private_data;
 311
 312         if (state->drain_done) {
 313                 state->finished = true;
 314                 return;
 315         }
 316
 317         if (!state->got_write) {
 318                 state->finished = true;
 319                 state->error = __location__;
 320                 return;
 321         }
 322
 323         if (!state->got_read) {
 324                 state->finished = true;
 325                 state->error = __location__;
 326                 return;
 327         }
 328
 329         state->loop_count++;
 330         if (state->loop_count > 3) {
 331                 state->finished = true;
 332                 state->error = __location__;
 333                 return;
 334         }
 335
 336         state->got_write = false;
 337         state->got_read = false;
 338
 339         tevent_fd_set_flags(state->fde0, TEVENT_FD_WRITE);
 340
 341         if (state->loop_count > 2) {
 342                 state->drain = true;
 343                 TALLOC_FREE(state->fde1);
 344                 TEVENT_FD_READABLE(state->fde0);
 345         }
 346
 347         state->te = tevent_add_timer(state->ev, state->ev,
 348                                     timeval_current_ofs(0,2000),
 349                                     test_event_fd1_finished, state);
 350 }
 351
 352 static bool test_event_fd1(struct torture_context *tctx,
 353                            const void *test_data)
 354 {
 355         struct test_event_fd1_state state;
 356
 357         ZERO_STRUCT(state);
 358         state.tctx = tctx;
 359         state.backend = (const char *)test_data;
 360
 361         state.ev = tevent_context_init_byname(tctx, state.backend);
 362         if (state.ev == NULL) {
 363                 torture_skip(tctx, talloc_asprintf(tctx,
 364                              "event backend '%s' not supported\n",
 365                              state.backend));
 366                 return true;
 367         }
 368
 369         tevent_set_debug_stderr(state.ev);
 370         torture_comment(tctx, "backend '%s' - %s\n",
 371                         state.backend, __FUNCTION__);
 372
 373         /*
 374          * This tests the following:
 375          *
 376          * It monitors the state of state.sock[0]
 377          * with tevent_fd, but we never read/write on state.sock[0]
 378          * while state.sock[1] * is only used to write a few bytes.
 379          *
 380          * We have a loop:
 381          *   - we wait only for TEVENT_FD_WRITE on state.sock[0]
 382          *   - we write 1 byte to state.sock[1]
 383          *   - we wait only for TEVENT_FD_READ on state.sock[0]
 384          *   - we disable events on state.sock[0]
 385          *   - the timer event restarts the loop
 386          * Then we close state.sock[1]
 387          * We have a loop:
 388          *   - we wait for TEVENT_FD_READ/WRITE on state.sock[0]
 389          *   - we try to read 1 byte
 390          *   - if the read gets an error of returns 0
 391          *     we disable the event handler
 392          *   - the timer finishes the test
 393          */
 394         state.sock[0] = -1;
 395         state.sock[1] = -1;
 396         socketpair(AF_UNIX, SOCK_STREAM, 0, state.sock);
 397
 398         state.te = tevent_add_timer(state.ev, state.ev,
 399                                     timeval_current_ofs(0,1000),
 400                                     test_event_fd1_finished, &state);
 401         state.fde0 = tevent_add_fd(state.ev, state.ev,
 402                                    state.sock[0], TEVENT_FD_WRITE,
 403                                    test_event_fd1_fde_handler, &state);
 404         /* state.fde1 is only used to auto close */
 405         state.fde1 = tevent_add_fd(state.ev, state.ev,
 406                                    state.sock[1], 0,
 407                                    test_event_fd1_fde_handler, &state);
 408
 409         tevent_fd_set_auto_close(state.fde0);
 410         tevent_fd_set_auto_close(state.fde1);
 411
 412         while (!state.finished) {
 413                 errno = 0;
 414                 if (tevent_loop_once(state.ev) == -1) {
 415                         talloc_free(state.ev);
 416                         torture_fail(tctx, talloc_asprintf(tctx,
 417                                      "Failed event loop %s\n",
 418                                      strerror(errno)));
 419                 }
 420         }
 421
 422         talloc_free(state.ev);
 423
 424         torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
 425                        "%s", state.error));
 426
 427         return true;
 428 }
 429
 430 struct test_event_fd2_state {
 431         struct torture_context *tctx;
 432         const char *backend;
 433         struct tevent_context *ev;
 434         struct tevent_timer *te;
 435         struct test_event_fd2_sock {
 436                 struct test_event_fd2_state *state;
 437                 int fd;
 438                 struct tevent_fd *fde;
 439                 size_t num_written;
 440                 size_t num_read;
 441                 bool got_full;
 442         } sock0, sock1;
 443         bool finished;
 444         const char *error;
 445 };
 446
 447 static void test_event_fd2_sock_handler(struct tevent_context *ev_ctx,
 448                                         struct tevent_fd *fde,
 449                                         uint16_t flags,
 450                                         void *private_data)
 451 {
 452         struct test_event_fd2_sock *cur_sock =
 453                 (struct test_event_fd2_sock *)private_data;
 454         struct test_event_fd2_state *state = cur_sock->state;
 455         struct test_event_fd2_sock *oth_sock = NULL;
 456         uint8_t v = 0, c;
 457         ssize_t ret;
 458
 459         if (cur_sock == &state->sock0) {
 460                 oth_sock = &state->sock1;
 461         } else {
 462                 oth_sock = &state->sock0;
 463         }
 464
 465         if (oth_sock->num_written == 1) {
 466                 if (flags != (TEVENT_FD_READ | TEVENT_FD_WRITE)) {
 467                         state->finished = true;
 468                         state->error = __location__;
 469                         return;
 470                 }
 471         }
 472
 473         if (cur_sock->num_read == oth_sock->num_written) {
 474                 state->finished = true;
 475                 state->error = __location__;
 476                 return;
 477         }
 478
 479         if (!(flags & TEVENT_FD_READ)) {
 480                 state->finished = true;
 481                 state->error = __location__;
 482                 return;
 483         }
 484
 485         if (oth_sock->num_read > 0) {
 486                 /*
 487                  * There should be room to write a byte again
 488                  */
 489                 if (!(flags & TEVENT_FD_WRITE)) {
 490                         state->finished = true;
 491                         state->error = __location__;
 492                         return;
 493                 }
 494         }
 495
 496         if ((flags & TEVENT_FD_WRITE) && !cur_sock->got_full) {
 497                 v = (uint8_t)cur_sock->num_written;
 498                 ret = write(cur_sock->fd, &v, 1);
 499                 if (ret != 1) {
 500                         state->finished = true;
 501                         state->error = __location__;
 502                         return;
 503                 }
 504                 cur_sock->num_written++;
 505                 if (cur_sock->num_written > 0x80000000) {
 506                         state->finished = true;
 507                         state->error = __location__;
 508                         return;
 509                 }
 510                 return;
 511         }
 512
 513         if (!cur_sock->got_full) {
 514                 cur_sock->got_full = true;
 515
 516                 if (!oth_sock->got_full) {
 517                         /*
 518                          * cur_sock is full,
 519                          * lets wait for oth_sock
 520                          * to be filled
 521                          */
 522                         tevent_fd_set_flags(cur_sock->fde, 0);
 523                         return;
 524                 }
 525
 526                 /*
 527                  * oth_sock waited for cur_sock,
 528                  * lets restart it
 529                  */
 530                 tevent_fd_set_flags(oth_sock->fde,
 531                                     TEVENT_FD_READ|TEVENT_FD_WRITE);
 532         }
 533
 534         ret = read(cur_sock->fd, &v, 1);
 535         if (ret != 1) {
 536                 state->finished = true;
 537                 state->error = __location__;
 538                 return;
 539         }
 540         c = (uint8_t)cur_sock->num_read;
 541         if (c != v) {
 542                 state->finished = true;
 543                 state->error = __location__;
 544                 return;
 545         }
 546         cur_sock->num_read++;
 547
 548         if (cur_sock->num_read < oth_sock->num_written) {
 549                 /* there is more to read */
 550                 return;
 551         }
 552         /*
 553          * we read everything, we need to remove TEVENT_FD_WRITE
 554          * to avoid spinning
 555          */
 556         TEVENT_FD_NOT_WRITEABLE(cur_sock->fde);
 557
 558         if (oth_sock->num_read == cur_sock->num_written) {
 559                 /*
 560                  * both directions are finished
 561                  */
 562                 state->finished = true;
 563         }
 564
 565         return;
 566 }
 567
 568 static void test_event_fd2_finished(struct tevent_context *ev_ctx,
 569                                     struct tevent_timer *te,
 570                                     struct timeval tval,
 571                                     void *private_data)
 572 {
 573         struct test_event_fd2_state *state =
 574                 (struct test_event_fd2_state *)private_data;
 575
 576         /*
 577          * this should never be triggered
 578          */
 579         state->finished = true;
 580         state->error = __location__;
 581 }
 582
 583 static bool test_event_fd2(struct torture_context *tctx,
 584                            const void *test_data)
 585 {
 586         struct test_event_fd2_state state;
 587         int sock[2];
 588         uint8_t c = 0;
 589
 590         ZERO_STRUCT(state);
 591         state.tctx = tctx;
 592         state.backend = (const char *)test_data;
 593
 594         state.ev = tevent_context_init_byname(tctx, state.backend);
 595         if (state.ev == NULL) {
 596                 torture_skip(tctx, talloc_asprintf(tctx,
 597                              "event backend '%s' not supported\n",
 598                              state.backend));
 599                 return true;
 600         }
 601
 602         tevent_set_debug_stderr(state.ev);
 603         torture_comment(tctx, "backend '%s' - %s\n",
 604                         state.backend, __FUNCTION__);
 605
 606         /*
 607          * This tests the following
 608          *
 609          * - We write 1 byte to each socket
 610          * - We wait for TEVENT_FD_READ/WRITE on both sockets
 611          * - When we get TEVENT_FD_WRITE we write 1 byte
 612          *   until both socket buffers are full, which
 613          *   means both sockets only get TEVENT_FD_READ.
 614          * - Then we read 1 byte until we have consumed
 615          *   all bytes the other end has written.
 616          */
 617         sock[0] = -1;
 618         sock[1] = -1;
 619         socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
 620
 621         /*
 622          * the timer should never expire
 623          */
 624         state.te = tevent_add_timer(state.ev, state.ev,
 625                                     timeval_current_ofs(600, 0),
 626                                     test_event_fd2_finished, &state);
 627         state.sock0.state = &state;
 628         state.sock0.fd = sock[0];
 629         state.sock0.fde = tevent_add_fd(state.ev, state.ev,
 630                                         state.sock0.fd,
 631                                         TEVENT_FD_READ | TEVENT_FD_WRITE,
 632                                         test_event_fd2_sock_handler,
 633                                         &state.sock0);
 634         state.sock1.state = &state;
 635         state.sock1.fd = sock[1];
 636         state.sock1.fde = tevent_add_fd(state.ev, state.ev,
 637                                         state.sock1.fd,
 638                                         TEVENT_FD_READ | TEVENT_FD_WRITE,
 639                                         test_event_fd2_sock_handler,
 640                                         &state.sock1);
 641
 642         tevent_fd_set_auto_close(state.sock0.fde);
 643         tevent_fd_set_auto_close(state.sock1.fde);
 644
 645         write(state.sock0.fd, &c, 1);
 646         state.sock0.num_written++;
 647         write(state.sock1.fd, &c, 1);
 648         state.sock1.num_written++;
 649
 650         while (!state.finished) {
 651                 errno = 0;
 652                 if (tevent_loop_once(state.ev) == -1) {
 653                         talloc_free(state.ev);
 654                         torture_fail(tctx, talloc_asprintf(tctx,
 655                                      "Failed event loop %s\n",
 656                                      strerror(errno)));
 657                 }
 658         }
 659
 660         talloc_free(state.ev);
 661
 662         torture_assert(tctx, state.error == NULL, talloc_asprintf(tctx,
 663                        "%s", state.error));
 664
 665         return true;
 666 }
 667
 668 #ifdef HAVE_PTHREAD
 669
 670 static pthread_mutex_t threaded_mutex = PTHREAD_MUTEX_INITIALIZER;
 671 static bool do_shutdown = false;
 672
 673 static void test_event_threaded_lock(void)
 674 {
 675         int ret;
 676         ret = pthread_mutex_lock(&threaded_mutex);
 677         assert(ret == 0);
 678 }
 679
 680 static void test_event_threaded_unlock(void)
 681 {
 682         int ret;
 683         ret = pthread_mutex_unlock(&threaded_mutex);
 684         assert(ret == 0);
 685 }
 686
 687 static void test_event_threaded_trace(enum tevent_trace_point point,
 688                                       void *private_data)
 689 {
 690         switch (point) {
 691         case TEVENT_TRACE_BEFORE_WAIT:
 692                 test_event_threaded_unlock();
 693                 break;
 694         case TEVENT_TRACE_AFTER_WAIT:
 695                 test_event_threaded_lock();
 696                 break;
 697         case TEVENT_TRACE_BEFORE_LOOP_ONCE:
 698         case TEVENT_TRACE_AFTER_LOOP_ONCE:
 699                 break;
 700         }
 701 }
 702
 703 static void test_event_threaded_timer(struct tevent_context *ev,
 704                                       struct tevent_timer *te,
 705                                       struct timeval current_time,
 706                                       void *private_data)
 707 {
 708         return;
 709 }
 710
 711 static void *test_event_poll_thread(void *private_data)
 712 {
 713         struct tevent_context *ev = (struct tevent_context *)private_data;
 714
 715         test_event_threaded_lock();
 716
 717         while (true) {
 718                 int ret;
 719                 ret = tevent_loop_once(ev);
 720                 assert(ret == 0);
 721                 if (do_shutdown) {
 722                         test_event_threaded_unlock();
 723                         return NULL;
 724                 }
 725         }
 726
 727 }
 728
 729 static void test_event_threaded_read_handler(struct tevent_context *ev,
 730                                              struct tevent_fd *fde,
 731                                              uint16_t flags,
 732                                              void *private_data)
 733 {
 734         int *pfd = (int *)private_data;
 735         char c;
 736         ssize_t nread;
 737
 738         if ((flags & TEVENT_FD_READ) == 0) {
 739                 return;
 740         }
 741
 742         do {
 743                 nread = read(*pfd, &c, 1);
 744         } while ((nread == -1) && (errno == EINTR));
 745
 746         assert(nread == 1);
 747 }
 748
 749 static bool test_event_context_threaded(struct torture_context *test,
 750                                         const void *test_data)
 751 {
 752         struct tevent_context *ev;
 753         struct tevent_timer *te;
 754         struct tevent_fd *fde;
 755         pthread_t poll_thread;
 756         int fds[2];
 757         int ret;
 758         char c = 0;
 759
 760         ev = tevent_context_init_byname(test, "poll_mt");
 761         torture_assert(test, ev != NULL, "poll_mt not supported");
 762
 763         tevent_set_trace_callback(ev, test_event_threaded_trace, NULL);
 764
 765         te = tevent_add_timer(ev, ev, timeval_current_ofs(5, 0),
 766                               test_event_threaded_timer, NULL);
 767         torture_assert(test, te != NULL, "Could not add timer");
 768
 769         ret = pthread_create(&poll_thread, NULL, test_event_poll_thread, ev);
 770         torture_assert(test, ret == 0, "Could not create poll thread");
 771
 772         ret = pipe(fds);
 773         torture_assert(test, ret == 0, "Could not create pipe");
 774
 775         poll(NULL, 0, 100);
 776
 777         test_event_threaded_lock();
 778
 779         fde = tevent_add_fd(ev, ev, fds[0], TEVENT_FD_READ,
 780                             test_event_threaded_read_handler, &fds[0]);
 781         torture_assert(test, fde != NULL, "Could not add fd event");
 782
 783         test_event_threaded_unlock();
 784
 785         poll(NULL, 0, 100);
 786
 787         write(fds[1], &c, 1);
 788
 789         poll(NULL, 0, 100);
 790
 791         test_event_threaded_lock();
 792         do_shutdown = true;
 793         test_event_threaded_unlock();
 794
 795         write(fds[1], &c, 1);
 796
 797         ret = pthread_join(poll_thread, NULL);
 798         torture_assert(test, ret == 0, "pthread_join failed");
 799
 800         return true;
 801 }
 802
 803 #endif
 804
 805 struct torture_suite *torture_local_event(TALLOC_CTX *mem_ctx)
 806 {
 807         struct torture_suite *suite = torture_suite_create(mem_ctx, "event");
 808         const char **list = tevent_backend_list(suite);
 809         int i;
 810
 811         for (i=0;list && list[i];i++) {
 812                 struct torture_suite *backend_suite;
 813
 814                 backend_suite = torture_suite_create(mem_ctx, list[i]);
 815
 816                 torture_suite_add_simple_tcase_const(backend_suite,
 817                                                "context",
 818                                                test_event_context,
 819                                                (const void *)list[i]);
 820                 torture_suite_add_simple_tcase_const(backend_suite,
 821                                                "fd1",
 822                                                test_event_fd1,
 823                                                (const void *)list[i]);
 824                 torture_suite_add_simple_tcase_const(backend_suite,
 825                                                "fd2",
 826                                                test_event_fd2,
 827                                                (const void *)list[i]);
 828
 829                 torture_suite_add_suite(suite, backend_suite);
 830         }
 831
 832 #ifdef HAVE_PTHREAD
 833         torture_suite_add_simple_tcase_const(suite, "threaded_poll_mt",
 834                                              test_event_context_threaded,
 835                                              NULL);
 836 #endif
 837
 838         return suite;
 839 }