tests/regression/kernel/select_poll_epoll.cpp

   1 /*
   2  * Copyright (C) 2016 Julien Desfossez <jdesfossez@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #include <fcntl.h>
   9 #include <limits.h>
  10 #include <poll.h>
  11 #include <popt.h>
  12 #include <pthread.h>
  13 #include <signal.h>
  14 #include <stddef.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <sys/epoll.h>
  19 #include <sys/mman.h>
  20 #include <sys/resource.h>
  21 #include <sys/select.h>
  22 #include <sys/stat.h>
  23 #include <sys/syscall.h>
  24 #include <sys/time.h>
  25 #include <sys/types.h>
  26 #include <unistd.h>
  27
  28 #include <common/compat/time.hpp>
  29 #include <common/error.hpp>
  30
  31 #define BUF_SIZE 256
  32 #define NB_FD 1
  33 #define MAX_FDS 2047
  34 #define NR_ITER 1000 /* for stress-tests */
  35
  36 #define MIN_NR_FDS 5 /* the minimum number of open FDs required for the test to run */
  37 #define BIG_SELECT_FD 1022
  38
  39 #define MSEC_PER_USEC 1000
  40 #define MSEC_PER_NSEC (MSEC_PER_USEC * 1000)
  41
  42 static int timeout; /* seconds, -1 to disable */
  43 static volatile int stop_thread;
  44 static int wait_fd;
  45
  46 /* Used by logging utils. */
  47 int lttng_opt_quiet, lttng_opt_verbose, lttng_opt_mi;
  48
  49 static void run_working_cases(FILE *validation_output_file);
  50 static void pselect_invalid_fd(FILE *validation_output_file);
  51 static void test_ppoll_big(FILE *validation_output_file);
  52 static void ppoll_fds_buffer_overflow(FILE *validation_output_file);
  53 static void pselect_invalid_pointer(FILE *validation_output_file);
  54 static void ppoll_fds_ulong_max(FILE *validation_output_file);
  55 static void epoll_pwait_invalid_pointer(FILE *validation_output_file);
  56 static void epoll_pwait_int_max(FILE *validation_output_file);
  57 static void ppoll_concurrent_write(FILE *validation_output_file);
  58 static void epoll_pwait_concurrent_munmap(FILE *validation_output_file);
  59
  60 typedef void (*test_case_cb)(FILE *output_file);
  61
  62 static const struct test_case {
  63         test_case_cb run;
  64         bool produces_validation_info;
  65         int timeout;
  66 } test_cases [] =
  67 {
  68         { .run = run_working_cases, .produces_validation_info = true, .timeout = -1 },
  69         { .run = run_working_cases, .produces_validation_info = true, .timeout = 1 },
  70         { .run = pselect_invalid_fd, .produces_validation_info = false, .timeout = 0 },
  71         { .run = test_ppoll_big, .produces_validation_info = false, .timeout = 0 },
  72         { .run = ppoll_fds_buffer_overflow, .produces_validation_info = false, .timeout = 0 },
  73         { .run = pselect_invalid_pointer, .produces_validation_info = false, .timeout = 0 },
  74         { .run = ppoll_fds_ulong_max, .produces_validation_info = false, .timeout = 0 },
  75         { .run = epoll_pwait_invalid_pointer, .produces_validation_info = true, .timeout = 0 },
  76         { .run = epoll_pwait_int_max, .produces_validation_info = true, .timeout = 0 },
  77         { .run = ppoll_concurrent_write, .produces_validation_info = false, .timeout = 0 },
  78         { .run = epoll_pwait_concurrent_munmap, .produces_validation_info = true, .timeout = 0 },
  79 };
  80
  81 struct ppoll_thread_data {
  82         struct pollfd *ufds;
  83         int value;
  84 };
  85
  86 static
  87 void test_select_big(void)
  88 {
  89         fd_set rfds, wfds, exfds;
  90         struct timeval tv;
  91         int ret;
  92         int fd2;
  93         char buf[BUF_SIZE];
  94
  95         FD_ZERO(&rfds);
  96         FD_ZERO(&wfds);
  97         FD_ZERO(&exfds);
  98
  99         fd2 = dup2(wait_fd, BIG_SELECT_FD);
 100         if (fd2 < 0) {
 101                 PERROR("dup2");
 102                 goto end;
 103         }
 104         FD_SET(fd2, &rfds);
 105
 106         tv.tv_sec = 0;
 107         tv.tv_usec = timeout * MSEC_PER_USEC;
 108
 109         if (timeout > 0) {
 110                 ret = select(fd2 + 1, &rfds, &wfds, &exfds, &tv);
 111         } else {
 112                 ret = select(fd2 + 1, &rfds, &wfds, &exfds, NULL);
 113         }
 114
 115         if (ret == -1) {
 116                 PERROR("select()");
 117         } else if (ret) {
 118                 ret = read(wait_fd, buf, BUF_SIZE);
 119                 if (ret < 0) {
 120                         PERROR("[select] read");
 121                 }
 122         }
 123
 124         ret = close(BIG_SELECT_FD);
 125         if (ret) {
 126                 PERROR("close");
 127         }
 128
 129 end:
 130         return;
 131 }
 132
 133 static
 134 void test_pselect(void)
 135 {
 136         fd_set rfds;
 137         struct timespec tv;
 138         int ret;
 139         char buf[BUF_SIZE];
 140
 141         FD_ZERO(&rfds);
 142         FD_SET(wait_fd, &rfds);
 143
 144         tv.tv_sec = 0;
 145         tv.tv_nsec = timeout * MSEC_PER_NSEC;
 146
 147         if (timeout > 0) {
 148                 ret = pselect(1, &rfds, NULL, NULL, &tv, NULL);
 149         } else {
 150                 ret = pselect(1, &rfds, NULL, NULL, NULL, NULL);
 151         }
 152
 153         if (ret == -1) {
 154                 PERROR("pselect()");
 155         } else if (ret) {
 156                 ret = read(wait_fd, buf, BUF_SIZE);
 157                 if (ret < 0) {
 158                         PERROR("[pselect] read");
 159                 }
 160         }
 161 }
 162
 163 static
 164 void test_select(void)
 165 {
 166         fd_set rfds;
 167         struct timeval tv;
 168         int ret;
 169         char buf[BUF_SIZE];
 170
 171         FD_ZERO(&rfds);
 172         FD_SET(wait_fd, &rfds);
 173
 174         tv.tv_sec = 0;
 175         tv.tv_usec = timeout * MSEC_PER_USEC;
 176
 177         if (timeout > 0) {
 178                 ret = select(1, &rfds, NULL, NULL, &tv);
 179         } else {
 180                 ret = select(1, &rfds, NULL, NULL, NULL);
 181         }
 182
 183         if (ret == -1) {
 184                 PERROR("select()");
 185         } else if (ret) {
 186                 ret = read(wait_fd, buf, BUF_SIZE);
 187                 if (ret < 0) {
 188                         PERROR("[select] read");
 189                 }
 190         }
 191 }
 192
 193 static
 194 void test_poll(void)
 195 {
 196         struct pollfd ufds[NB_FD];
 197         char buf[BUF_SIZE];
 198         int ret;
 199
 200         ufds[0].fd = wait_fd;
 201         ufds[0].events = POLLIN|POLLPRI;
 202
 203         ret = poll(ufds, 1, timeout);
 204
 205         if (ret < 0) {
 206                 PERROR("poll");
 207         } else if (ret > 0) {
 208                 ret = read(wait_fd, buf, BUF_SIZE);
 209                 if (ret < 0) {
 210                         PERROR("[poll] read");
 211                 }
 212         }
 213 }
 214
 215 static
 216 void test_ppoll(void)
 217 {
 218         struct pollfd ufds[NB_FD];
 219         char buf[BUF_SIZE];
 220         int ret;
 221         struct timespec ts;
 222
 223         ufds[0].fd = wait_fd;
 224         ufds[0].events = POLLIN|POLLPRI;
 225
 226         if (timeout > 0) {
 227                 ts.tv_sec = 0;
 228                 ts.tv_nsec = timeout * MSEC_PER_NSEC;
 229                 ret = ppoll(ufds, 1, &ts, NULL);
 230         } else {
 231                 ret = ppoll(ufds, 1, NULL, NULL);
 232         }
 233
 234
 235         if (ret < 0) {
 236                 PERROR("ppoll");
 237         } else if (ret > 0) {
 238                 ret = read(wait_fd, buf, BUF_SIZE);
 239                 if (ret < 0) {
 240                         PERROR("[ppoll] read");
 241                 }
 242         }
 243 }
 244
 245 static
 246 void test_ppoll_big(FILE *validation_output_file __attribute__((unused)))
 247 {
 248         struct pollfd ufds[MAX_FDS];
 249         char buf[BUF_SIZE];
 250         int ret, i, fds[MAX_FDS];
 251
 252         for (i = 0; i < MAX_FDS; i++) {
 253                 fds[i] = dup(wait_fd);
 254                 if (fds[i] < 0) {
 255                         PERROR("dup");
 256                 }
 257                 ufds[i].fd = fds[i];
 258                 ufds[i].events = POLLIN|POLLPRI;
 259         }
 260
 261         ret = ppoll(ufds, MAX_FDS, NULL, NULL);
 262
 263         if (ret < 0) {
 264                 PERROR("ppoll");
 265         } else if (ret > 0) {
 266                 ret = read(wait_fd, buf, BUF_SIZE);
 267                 if (ret < 0) {
 268                         PERROR("[ppoll] read");
 269                 }
 270         }
 271
 272         for (i = 0; i < MAX_FDS; i++) {
 273                 ret = close(fds[i]);
 274                 if (ret != 0) {
 275                         PERROR("close");
 276                 }
 277         }
 278
 279         return;
 280 }
 281
 282 static
 283 void test_epoll(FILE *validation_output_file)
 284 {
 285         int ret, epollfd;
 286         char buf[BUF_SIZE];
 287         struct epoll_event epoll_event;
 288
 289         epollfd = epoll_create(NB_FD);
 290         if (epollfd < 0) {
 291                 PERROR("[epoll] create");
 292                 goto end;
 293         }
 294
 295         ret = fprintf(validation_output_file,
 296                         ", \"epoll_wait_fd\": %i", epollfd);
 297         if (ret < 0) {
 298                 PERROR("[epoll] Failed to write test validation output");
 299                 goto error;
 300         }
 301
 302         epoll_event.events = EPOLLIN | EPOLLPRI | EPOLLET;
 303         epoll_event.data.fd = wait_fd;
 304         ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, wait_fd, &epoll_event);
 305         if (ret < 0) {
 306                 PERROR("[epoll] add");
 307                 goto error;
 308         }
 309
 310         if (timeout > 0) {
 311                 ret = epoll_wait(epollfd, &epoll_event, 1, timeout);
 312         } else {
 313                 ret = epoll_wait(epollfd, &epoll_event, 1, -1);
 314         }
 315
 316         if (ret == 1) {
 317                 ret = read(wait_fd, buf, BUF_SIZE);
 318                 if (ret < 0) {
 319                         PERROR("[epoll] read");
 320                 }
 321         } else if (ret != 0) {
 322                 PERROR("epoll_wait");
 323         }
 324
 325 error:
 326         ret = close(epollfd);
 327         if (ret) {
 328                 PERROR("close");
 329         }
 330 end:
 331         return;
 332 }
 333
 334 static
 335 void test_epoll_pwait(FILE *validation_output_file)
 336 {
 337         int ret, epollfd;
 338         char buf[BUF_SIZE];
 339         struct epoll_event epoll_event;
 340
 341         epollfd = epoll_create(NB_FD);
 342         if (epollfd < 0) {
 343                 PERROR("[epoll_pwait] create");
 344                 goto end;
 345         }
 346
 347         ret = fprintf(validation_output_file,
 348                         ", \"epoll_pwait_fd\": %i", epollfd);
 349         if (ret < 0) {
 350                 PERROR("[epoll_pwait] Failed to write test validation output");
 351                 goto error;
 352         }
 353
 354         epoll_event.events = EPOLLIN | EPOLLPRI | EPOLLET;
 355         epoll_event.data.fd = wait_fd;
 356         ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, wait_fd, &epoll_event);
 357         if (ret < 0) {
 358                 PERROR("[epoll_pwait] add");
 359                 goto error;
 360         }
 361
 362         if (timeout > 0) {
 363                 ret = epoll_pwait(epollfd, &epoll_event, 1, timeout, NULL);
 364         } else {
 365                 ret = epoll_pwait(epollfd, &epoll_event, 1, -1, NULL);
 366         }
 367
 368         if (ret == 1) {
 369                 ret = read(wait_fd, buf, BUF_SIZE);
 370                 if (ret < 0) {
 371                         PERROR("[epoll_pwait] read");
 372                 }
 373         } else if (ret != 0) {
 374                 PERROR("epoll_pwait");
 375         }
 376
 377 error:
 378         ret = close(epollfd);
 379         if (ret) {
 380                 PERROR("close");
 381         }
 382 end:
 383         return;
 384 }
 385
 386 static
 387 void run_working_cases(FILE *validation_output_file)
 388 {
 389         int ret;
 390         int pipe_fds[2];
 391
 392         if (timeout > 0) {
 393                 /*
 394                  * We need an input pipe for some cases and stdin might
 395                  * have random data, so we create a dummy pipe for this
 396                  * test to make sure we are running under clean conditions.
 397                  */
 398                 ret = pipe(pipe_fds);
 399                 if (ret != 0) {
 400                         PERROR("pipe");
 401                         goto end;
 402                 }
 403                 wait_fd = pipe_fds[0];
 404         }
 405         test_select();
 406         test_pselect();
 407         test_select_big();
 408         test_poll();
 409         test_ppoll();
 410
 411         ret = fprintf(validation_output_file, "{ \"pid\": %i", getpid());
 412         if (ret < 0) {
 413                 PERROR("Failed to write pid to test validation file");
 414                 goto end;
 415         }
 416
 417         test_epoll(validation_output_file);
 418         test_epoll_pwait(validation_output_file);
 419
 420         if (timeout > 0) {
 421                 ret = close(pipe_fds[0]);
 422                 if (ret) {
 423                         PERROR("close");
 424                 }
 425                 ret = close(pipe_fds[1]);
 426                 if (ret) {
 427                         PERROR("close");
 428                 }
 429         }
 430
 431         ret = fputs(" }", validation_output_file);
 432         if (ret < 0) {
 433                 PERROR("Failed to close JSON dictionary in test validation file");
 434                 goto end;
 435         }
 436
 437 end:
 438         return;
 439 }
 440
 441 /*
 442  * Ask for 100 FDs in a buffer for allocated for only 1 FD, should
 443  * segfault (eventually with a "*** stack smashing detected ***" message).
 444  * The event should contain an array of 100 FDs filled with garbage.
 445  */
 446 static
 447 void ppoll_fds_buffer_overflow(
 448                 FILE *validation_output_file __attribute__((unused)))
 449 {
 450         struct pollfd ufds[NB_FD];
 451         char buf[BUF_SIZE];
 452         int ret;
 453
 454         ufds[0].fd = wait_fd;
 455         ufds[0].events = POLLIN|POLLPRI;
 456
 457         ret = syscall(SYS_ppoll, ufds, 100, NULL, NULL);
 458
 459         if (ret < 0) {
 460                 PERROR("ppoll");
 461         } else if (ret > 0) {
 462                 ret = read(wait_fd, buf, BUF_SIZE);
 463                 if (ret < 0) {
 464                         PERROR("[ppoll] read");
 465                 }
 466         }
 467 }
 468
 469 /*
 470  * Ask for ULONG_MAX FDs in a buffer for allocated for only 1 FD, should
 471  * cleanly fail with a "Invalid argument".
 472  * The event should contain an empty array of FDs and overflow = 1.
 473  */
 474 static
 475 void ppoll_fds_ulong_max(FILE *validation_output_file __attribute__((unused)))
 476 {
 477         struct pollfd ufds[NB_FD];
 478         char buf[BUF_SIZE];
 479         int ret;
 480
 481         ufds[0].fd = wait_fd;
 482         ufds[0].events = POLLIN|POLLPRI;
 483
 484         ret = syscall(SYS_ppoll, ufds, ULONG_MAX, NULL, NULL);
 485         if (ret < 0) {
 486                 /* Expected error. */
 487         } else if (ret > 0) {
 488                 ret = read(wait_fd, buf, BUF_SIZE);
 489                 if (ret < 0) {
 490                         PERROR("[ppoll] read");
 491                 }
 492         }
 493 }
 494
 495 /*
 496  * Pass an invalid file descriptor to pselect6(). The syscall should return
 497  * -EBADF. The recorded event should contain a "ret = -EBADF (-9)".
 498  */
 499 static
 500 void pselect_invalid_fd(FILE *validation_output_file __attribute__((unused)))
 501 {
 502         fd_set rfds;
 503         int ret;
 504         int fd;
 505         char buf[BUF_SIZE];
 506
 507         /*
 508          * Open a file, close it and use the closed FD in the pselect6 call.
 509          */
 510         fd = open("/dev/null", O_RDONLY);
 511         if (fd == -1) {
 512                 PERROR("open");
 513                 goto error;
 514         }
 515
 516         ret = close(fd);
 517         if (ret == -1) {
 518                 PERROR("close");
 519                 goto error;
 520         }
 521
 522         FD_ZERO(&rfds);
 523         FD_SET(fd, &rfds);
 524
 525         ret = syscall(SYS_pselect6, fd + 1, &rfds, NULL, NULL, NULL, NULL);
 526         if (ret == -1) {
 527                 /* Expected error. */
 528         } else if (ret) {
 529                 ret = read(wait_fd, buf, BUF_SIZE);
 530                 if (ret < 0) {
 531                         PERROR("[pselect] read");
 532                 }
 533         }
 534 error:
 535         return;
 536 }
 537
 538 /*
 539  * Invalid pointer as writefds, should output a ppoll event
 540  * with 0 FDs.
 541  */
 542 static
 543 void pselect_invalid_pointer(
 544                 FILE *validation_output_file __attribute__((unused)))
 545 {
 546         fd_set rfds;
 547         int ret;
 548         char buf[BUF_SIZE];
 549         void *invalid = (void *) 0x42;
 550
 551         FD_ZERO(&rfds);
 552         FD_SET(wait_fd, &rfds);
 553
 554         ret = syscall(SYS_pselect6, 1, &rfds, (fd_set *) invalid, NULL, NULL,
 555                         NULL);
 556         if (ret == -1) {
 557                 /* Expected error. */
 558         } else if (ret) {
 559                 ret = read(wait_fd, buf, BUF_SIZE);
 560                 if (ret < 0) {
 561                         PERROR("[pselect] read");
 562                 }
 563         }
 564 }
 565
 566 /*
 567  * Pass an invalid pointer to epoll_pwait, should fail with
 568  * "Bad address", the event returns 0 FDs.
 569  */
 570 static
 571 void epoll_pwait_invalid_pointer(FILE *validation_output_file)
 572 {
 573         int ret, epollfd;
 574         char buf[BUF_SIZE];
 575         struct epoll_event epoll_event;
 576         void *invalid = (void *) 0x42;
 577
 578         epollfd = epoll_create(NB_FD);
 579         if (epollfd < 0) {
 580                 PERROR("[epoll_pwait] create");
 581                 goto end;
 582         }
 583
 584         ret = fprintf(validation_output_file,
 585                         "{ \"epollfd\": %i, \"pid\": %i }", epollfd,
 586                         getpid());
 587         if (ret < 0) {
 588                 PERROR("[epoll_pwait] Failed to write test validation output");
 589                 goto error;
 590         }
 591
 592         epoll_event.events = EPOLLIN | EPOLLPRI | EPOLLET;
 593         epoll_event.data.fd = wait_fd;
 594         ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, wait_fd, &epoll_event);
 595         if (ret < 0) {
 596                 PERROR("[epoll_pwait] add");
 597                 goto error;
 598         }
 599
 600         ret = syscall(SYS_epoll_pwait, epollfd,
 601                         (struct epoll_event *) invalid, 1, -1, NULL);
 602
 603         if (ret == 1) {
 604                 ret = read(wait_fd, buf, BUF_SIZE);
 605                 if (ret < 0) {
 606                         PERROR("[epoll_pwait] read");
 607                 }
 608         } else if (ret != 0) {
 609                 /* Expected error. */
 610         }
 611
 612 error:
 613         ret = close(epollfd);
 614         if (ret) {
 615                 PERROR("close");
 616         }
 617 end:
 618         return;
 619 }
 620
 621 /*
 622  * Set maxevents to INT_MAX, should output "Invalid argument"
 623  * The event should return an empty array.
 624  */
 625 static
 626 void epoll_pwait_int_max(FILE *validation_output_file)
 627 {
 628         int ret, epollfd;
 629         char buf[BUF_SIZE];
 630         struct epoll_event epoll_event;
 631
 632         epollfd = epoll_create(NB_FD);
 633         if (epollfd < 0) {
 634                 PERROR("[epoll_pwait] create");
 635                 goto end;
 636         }
 637
 638         ret = fprintf(validation_output_file,
 639                         "{ \"epollfd\": %i, \"pid\": %i }", epollfd,
 640                         getpid());
 641         if (ret < 0) {
 642                 PERROR("[epoll_pwait] Failed to write test validation output");
 643                 goto error;
 644         }
 645
 646         epoll_event.events = EPOLLIN | EPOLLPRI | EPOLLET;
 647         epoll_event.data.fd = wait_fd;
 648         ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, wait_fd, &epoll_event);
 649         if (ret < 0) {
 650                 PERROR("[epoll_pwait] add");
 651                 goto error;
 652         }
 653
 654         ret = syscall(SYS_epoll_pwait, epollfd, &epoll_event, INT_MAX, -1,
 655                         NULL);
 656
 657         if (ret == 1) {
 658                 ret = read(wait_fd, buf, BUF_SIZE);
 659                 if (ret < 0) {
 660                         PERROR("[epoll_pwait] read");
 661                 }
 662         } else if (ret != 0) {
 663                 /* Expected error. */
 664         }
 665
 666 error:
 667         ret = close(epollfd);
 668         if (ret) {
 669                 PERROR("close");
 670         }
 671 end:
 672         return;
 673 }
 674
 675 static
 676 void *ppoll_writer(void *arg)
 677 {
 678         struct ppoll_thread_data *data = (struct ppoll_thread_data *) arg;
 679
 680         while (!stop_thread) {
 681                 memset(data->ufds, data->value,
 682                                 MAX_FDS * sizeof(struct pollfd));
 683                 usleep(100);
 684         }
 685
 686         return NULL;
 687 }
 688
 689 static
 690 void do_ppoll(int *fds, struct pollfd *ufds)
 691 {
 692         int i, ret;
 693         struct timespec ts;
 694         char buf[BUF_SIZE];
 695
 696         ts.tv_sec = 0;
 697         ts.tv_nsec = 1 * MSEC_PER_NSEC;
 698
 699         for (i = 0; i < MAX_FDS; i++) {
 700                 ufds[i].fd = fds[i];
 701                 ufds[i].events = POLLIN|POLLPRI;
 702         }
 703
 704         ret = ppoll(ufds, MAX_FDS, &ts, NULL);
 705
 706         if (ret < 0) {
 707                 PERROR("ppoll");
 708         } else if (ret > 0) {
 709                 ret = read(wait_fd, buf, BUF_SIZE);
 710                 if (ret < 0) {
 711                         PERROR("[ppoll] read");
 712                 }
 713         }
 714 }
 715
 716 static
 717 void stress_ppoll(int *fds, int value)
 718 {
 719         pthread_t writer;
 720         int iter, ret;
 721         struct ppoll_thread_data thread_data;
 722         struct pollfd ufds[MAX_FDS];
 723
 724         thread_data.ufds = ufds;
 725         thread_data.value = value;
 726
 727         stop_thread = 0;
 728         ret = pthread_create(&writer, NULL, &ppoll_writer, (void *) &thread_data);
 729         if (ret != 0) {
 730                 fprintf(stderr, "[error] pthread_create\n");
 731                 goto end;
 732         }
 733         for (iter = 0; iter < NR_ITER; iter++) {
 734                 do_ppoll(fds, ufds);
 735         }
 736         stop_thread = 1;
 737         ret = pthread_join(writer, NULL);
 738         if (ret) {
 739                 fprintf(stderr, "[error] pthread_join\n");
 740                 goto end;
 741         }
 742 end:
 743         return;
 744 }
 745
 746 /*
 747  * 3 rounds of NR_ITER iterations with concurrent updates of the pollfd
 748  * structure:
 749  *   - memset to 0
 750  *   - memset to 1
 751  *   - memset to INT_MAX
 752  * Waits for input, but also set a timeout in case the input FD is overwritten
 753  * before entering in the syscall. We use MAX_FDS FDs (dup of stdin), so the
 754  * resulting trace is big (20MB).
 755  *
 756  * ppoll should work as expected and the trace should be readable at the end.
 757  */
 758 static
 759 void ppoll_concurrent_write(
 760                 FILE *validation_output_file __attribute__((unused)))
 761 {
 762         int i, ret, fds[MAX_FDS];
 763
 764         for (i = 0; i < MAX_FDS; i++) {
 765                 fds[i] = dup(wait_fd);
 766                 if (fds[i] < 0) {
 767                         PERROR("dup");
 768                 }
 769         }
 770
 771         stress_ppoll(fds, 0);
 772         stress_ppoll(fds, 1);
 773         stress_ppoll(fds, INT_MAX);
 774
 775         for (i = 0; i < MAX_FDS; i++) {
 776                 ret = close(fds[i]);
 777                 if (ret != 0) {
 778                         PERROR("close");
 779                 }
 780         }
 781
 782         return;
 783 }
 784
 785 static
 786 void *epoll_pwait_writer(void *addr)
 787 {
 788         srand(time(NULL));
 789
 790         while (!stop_thread) {
 791                 usleep(rand() % 30);
 792                 munmap(addr, MAX_FDS * sizeof(struct epoll_event));
 793         }
 794
 795         return NULL;
 796 }
 797
 798 /*
 799  * epoll_pwait on MAX_FDS fds while a concurrent thread munmaps the
 800  * buffer allocated for the returned data. This should randomly segfault.
 801  * The trace should be readable and no kernel OOPS should occur.
 802  */
 803 static
 804 void epoll_pwait_concurrent_munmap(FILE *validation_output_file)
 805 {
 806         int ret, epollfd, i, fds[MAX_FDS];
 807         char buf[BUF_SIZE];
 808         struct epoll_event *epoll_event;
 809         pthread_t writer;
 810
 811         for (i = 0; i < MAX_FDS; i++) {
 812                 fds[i] = -1;
 813         }
 814         epollfd = epoll_create(MAX_FDS);
 815         if (epollfd < 0) {
 816                 PERROR("[epoll_pwait] create");
 817                 goto end;
 818         }
 819
 820         ret = fprintf(validation_output_file,
 821                         "{ \"epollfd\": %i, \"pid\": %i }", epollfd,
 822                         getpid());
 823         if (ret < 0) {
 824                 PERROR("[epoll_pwait] Failed to write test validation output");
 825                 goto error;
 826         }
 827
 828         epoll_event = (struct epoll_event *) mmap(NULL,
 829                         MAX_FDS * sizeof(struct epoll_event),
 830                         PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1,
 831                         0);
 832         if (epoll_event == MAP_FAILED) {
 833                 PERROR("mmap");
 834                 goto error;
 835         }
 836
 837         for (i = 0; i < MAX_FDS; i++) {
 838                 fds[i] = dup(wait_fd);
 839                 if (fds[i] < 0) {
 840                         PERROR("dup");
 841                 }
 842                 epoll_event[i].events = EPOLLIN | EPOLLPRI | EPOLLET;
 843                 epoll_event[i].data.fd = fds[i];
 844                 ret = epoll_ctl(epollfd, EPOLL_CTL_ADD, fds[i], epoll_event);
 845                 if (ret < 0) {
 846                         PERROR("[epoll_pwait] add");
 847                         goto error_unmap;
 848                 }
 849         }
 850         stop_thread = 0;
 851         ret = pthread_create(&writer, NULL, &epoll_pwait_writer,
 852                         (void *) epoll_event);
 853         if (ret != 0) {
 854                 fprintf(stderr, "[error] pthread_create\n");
 855                 goto error_unmap;
 856         }
 857
 858         ret = epoll_pwait(epollfd, epoll_event, 1, 1, NULL);
 859
 860         if (ret == 1) {
 861                 ret = read(wait_fd, buf, BUF_SIZE);
 862                 if (ret < 0) {
 863                         PERROR("[epoll_pwait] read");
 864                 }
 865         } else if (ret != 0) {
 866                 /* Expected error. */
 867         }
 868
 869         stop_thread = 1;
 870         ret = pthread_join(writer, NULL);
 871         if (ret) {
 872                 fprintf(stderr, "[error] pthread_join\n");
 873                 goto error_unmap;
 874         }
 875 error_unmap:
 876         for (i = 0; i < MAX_FDS; i++) {
 877                 ret = close(fds[i]);
 878                 if (ret != 0) {
 879                         PERROR("close");
 880                 }
 881         }
 882
 883         ret = munmap(epoll_event, MAX_FDS * sizeof(struct epoll_event));
 884         if (ret != 0) {
 885                 PERROR("munmap");
 886         }
 887
 888 error:
 889         ret = close(epollfd);
 890         if (ret) {
 891                 PERROR("close");
 892         }
 893 end:
 894         return;
 895 }
 896
 897 static
 898 void print_list(void)
 899 {
 900         fprintf(stderr, "Test list (-t X):\n");
 901         fprintf(stderr, "\t1: Working cases for select, pselect6, poll, ppoll "
 902                         "and epoll, waiting for input\n");
 903         fprintf(stderr, "\t2: Timeout cases (1ms) for select, pselect6, poll, "
 904                         "ppoll and epoll\n");
 905         fprintf(stderr, "\t3: pselect with an invalid fd\n");
 906         fprintf(stderr, "\t4: ppoll with %d FDs\n", MAX_FDS);
 907         fprintf(stderr, "\t5: ppoll buffer overflow, should segfault, waits "
 908                         "for input\n");
 909         fprintf(stderr, "\t6: pselect with an invalid pointer, waits for "
 910                         "input\n");
 911         fprintf(stderr, "\t7: ppoll with ulong_max fds, waits for input\n");
 912         fprintf(stderr, "\t8: epoll_pwait with an invalid pointer, waits for "
 913                         "input\n");
 914         fprintf(stderr, "\t9: epoll_pwait with maxevents set to INT_MAX, "
 915                         "waits for input\n");
 916         fprintf(stderr, "\t10: ppoll with concurrent updates of the structure "
 917                         "from user-space, stress test (3000 iterations), "
 918                         "waits for input + timeout 1ms\n");
 919         fprintf(stderr, "\t11: epoll_pwait with concurrent munmap of the buffer "
 920                         "from user-space, should randomly segfault, run "
 921                         "multiple times, waits for input + timeout 1ms\n");
 922 }
 923
 924 int main(int argc, const char **argv)
 925 {
 926         int c, ret, test = -1;
 927         poptContext optCon;
 928         struct rlimit open_lim;
 929         FILE *test_validation_output_file = NULL;
 930         const char *test_validation_output_file_path = NULL;
 931         struct poptOption optionsTable[] = {
 932                 { "test", 't', POPT_ARG_INT, &test, 0,
 933                         "Test to run", NULL },
 934                 { "list", 'l', 0, 0, 'l',
 935                         "List of tests (-t X)", NULL },
 936                 { "validation-file", 'o', POPT_ARG_STRING, &test_validation_output_file_path, 0,
 937                         "Test case output", NULL },
 938                 POPT_AUTOHELP
 939                 { NULL, 0, 0, NULL, 0, NULL, NULL }
 940         };
 941         const struct test_case *test_case;
 942
 943         optCon = poptGetContext(NULL, argc, argv, optionsTable, 0);
 944
 945         if (argc < 2) {
 946                 poptPrintUsage(optCon, stderr, 0);
 947                 ret = -1;
 948                 goto end;
 949         }
 950
 951         ret = 0;
 952
 953         while ((c = poptGetNextOpt(optCon)) >= 0) {
 954                 switch (c) {
 955                 case 'l':
 956                         print_list();
 957                         goto end;
 958                 }
 959         }
 960
 961         if (!test_validation_output_file_path) {
 962                 fprintf(stderr, "A test validation file path is required (--validation-file/-o)\n");
 963                 ret = -1;
 964                 goto end;
 965         }
 966
 967         test_validation_output_file = fopen(test_validation_output_file_path, "w+");
 968         if (!test_validation_output_file) {
 969                 PERROR("Failed to create test validation output file at '%s'",
 970                                 test_validation_output_file_path);
 971                 ret = -1;
 972                 goto end;
 973         }
 974
 975         open_lim.rlim_cur = MAX_FDS + MIN_NR_FDS;
 976         open_lim.rlim_max = MAX_FDS + MIN_NR_FDS;
 977
 978         ret = setrlimit(RLIMIT_NOFILE, &open_lim);
 979         if (ret < 0) {
 980                 PERROR("setrlimit");
 981                 goto end;
 982         }
 983
 984         /*
 985          * Some tests might segfault, but we need the getpid() to be output
 986          * for the validation, disabling the buffering on the validation file
 987          * works.
 988          */
 989         setbuf(test_validation_output_file, NULL);
 990         wait_fd = STDIN_FILENO;
 991
 992         /* Test case id is 1-based. */
 993         if (test < 1 || test > ARRAY_SIZE(test_cases)) {
 994                 poptPrintUsage(optCon, stderr, 0);
 995                 ret = -1;
 996         }
 997
 998         test_case = &test_cases[test - 1];
 999
1000         timeout = test_case->timeout;
1001         if (!test_case->produces_validation_info) {
1002                 /*
1003                  * All test cases need to provide, at minimum, the pid of the
1004                  * test application.
1005                  */
1006                 ret = fprintf(test_validation_output_file, "{ \"pid\": %i }", getpid());
1007                 if (ret < 0) {
1008                         PERROR("Failed to write application pid to test validation file");
1009                         goto end;
1010                 }
1011         }
1012
1013         test_case->run(test_validation_output_file);
1014
1015 end:
1016         if (test_validation_output_file) {
1017                 const int close_ret = fclose(test_validation_output_file);
1018
1019                 if (close_ret) {
1020                         PERROR("Failed to close test output file");
1021                 }
1022         }
1023         poptFreeContext(optCon);
1024         return ret;
1025 }