nptl/tst-cancel4.c

   1 /* Copyright (C) 2002-2018 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 /* NOTE: this tests functionality beyond POSIX.  POSIX does not allow
  20    exit to be called more than once.  */
  21
  22 #include <stddef.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <sys/types.h>
  27 #include <sys/socket.h>
  28 #include <sys/un.h>
  29 #include <sys/ipc.h>
  30 #include <sys/msg.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33 #include <limits.h>
  34 #include <pthread.h>
  35 #include <fcntl.h>
  36 #include <termios.h>
  37 #include <sys/mman.h>
  38 #include <sys/poll.h>
  39 #include <sys/wait.h>
  40 #include <sys/stat.h>
  41 #include <sys/uio.h>
  42
  43
  44 /* Since STREAMS are not supported in the standard Linux kernel and
  45    there we don't advertise STREAMS as supported is no need to test
  46    the STREAMS related functions.  This affects
  47      getmsg()              getpmsg()          putmsg()
  48      putpmsg()
  49
  50    lockf() and fcntl() are tested in tst-cancel16.
  51
  52    pthread_join() is tested in tst-join5.
  53
  54    pthread_testcancel()'s only purpose is to allow cancellation.  This
  55    is tested in several places.
  56
  57    sem_wait() and sem_timedwait() are checked in tst-cancel1[2345] tests.
  58
  59    mq_send(), mq_timedsend(), mq_receive() and mq_timedreceive() are checked
  60    in tst-mqueue8{,x} tests.
  61
  62    aio_suspend() is tested in tst-cancel17.
  63
  64    clock_nanosleep() is tested in tst-cancel18.
  65
  66    Linux sendmmsg and recvmmsg are checked in tst-cancel4_1.c and
  67    tst-cancel4_2.c respectively.
  68 */
  69
  70 #include "tst-cancel4-common.h"
  71
  72
  73 #ifndef IPC_ADDVAL
  74 # define IPC_ADDVAL 0
  75 #endif
  76
  77
  78 static void *
  79 tf_read  (void *arg)
  80 {
  81   int fd;
  82
  83   if (arg == NULL)
  84     fd = fds[0];
  85   else
  86     {
  87       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
  88       tempfd = fd = mkstemp (fname);
  89       if (fd == -1)
  90         FAIL_EXIT1 ("mkstemp failed: %m");
  91       unlink (fname);
  92
  93       xpthread_barrier_wait (&b2);
  94     }
  95
  96   xpthread_barrier_wait (&b2);
  97
  98   ssize_t s;
  99   pthread_cleanup_push (cl, NULL);
 100
 101   char buf[100];
 102   s = read (fd, buf, sizeof (buf));
 103
 104   pthread_cleanup_pop (0);
 105
 106   FAIL_EXIT1 ("read returns with %zd", s);
 107 }
 108
 109
 110 static void *
 111 tf_readv  (void *arg)
 112 {
 113   int fd;
 114
 115   if (arg == NULL)
 116     fd = fds[0];
 117   else
 118     {
 119       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 120       tempfd = fd = mkstemp (fname);
 121       if (fd == -1)
 122         FAIL_EXIT1 ("mkstemp failed: %m");
 123       unlink (fname);
 124
 125       xpthread_barrier_wait (&b2);
 126     }
 127
 128   xpthread_barrier_wait (&b2);
 129
 130   ssize_t s;
 131   pthread_cleanup_push (cl, NULL);
 132
 133   char buf[100];
 134   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
 135   s = readv (fd, iov, 1);
 136
 137   pthread_cleanup_pop (0);
 138
 139   FAIL_EXIT1 ("readv returns with %zd", s);
 140 }
 141
 142
 143 static void *
 144 tf_write  (void *arg)
 145 {
 146   int fd;
 147
 148   if (arg == NULL)
 149     fd = fds[1];
 150   else
 151     {
 152       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 153       tempfd = fd = mkstemp (fname);
 154       if (fd == -1)
 155         FAIL_EXIT1 ("mkstemp failed: %m");
 156       unlink (fname);
 157
 158       xpthread_barrier_wait (&b2);
 159     }
 160
 161   xpthread_barrier_wait (&b2);
 162
 163   ssize_t s;
 164   pthread_cleanup_push (cl, NULL);
 165
 166   char buf[WRITE_BUFFER_SIZE];
 167   memset (buf, '\0', sizeof (buf));
 168   s = write (fd, buf, sizeof (buf));
 169
 170   pthread_cleanup_pop (0);
 171
 172   FAIL_EXIT1 ("write returns with %zd", s);
 173 }
 174
 175
 176 static void *
 177 tf_writev  (void *arg)
 178 {
 179   int fd;
 180
 181   if (arg == NULL)
 182     fd = fds[1];
 183   else
 184     {
 185       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 186       tempfd = fd = mkstemp (fname);
 187       if (fd == -1)
 188         FAIL_EXIT1 ("mkstemp failed: %m");
 189       unlink (fname);
 190
 191       xpthread_barrier_wait (&b2);
 192     }
 193
 194   xpthread_barrier_wait (&b2);
 195
 196   ssize_t s;
 197   pthread_cleanup_push (cl, NULL);
 198
 199   char buf[WRITE_BUFFER_SIZE];
 200   memset (buf, '\0', sizeof (buf));
 201   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
 202   s = writev (fd, iov, 1);
 203
 204   pthread_cleanup_pop (0);
 205
 206   FAIL_EXIT1 ("writev returns with %zd", s);
 207 }
 208
 209
 210 static void *
 211 tf_sleep (void *arg)
 212 {
 213   xpthread_barrier_wait (&b2);
 214
 215   if (arg != NULL)
 216     xpthread_barrier_wait (&b2);
 217
 218   pthread_cleanup_push (cl, NULL);
 219
 220   sleep (arg == NULL ? 1000000 : 0);
 221
 222   pthread_cleanup_pop (0);
 223
 224   FAIL_EXIT1 ("sleep returns");
 225 }
 226
 227
 228 static void *
 229 tf_usleep (void *arg)
 230 {
 231   xpthread_barrier_wait (&b2);
 232
 233   if (arg != NULL)
 234     xpthread_barrier_wait (&b2);
 235
 236   pthread_cleanup_push (cl, NULL);
 237
 238   usleep (arg == NULL ? (useconds_t) ULONG_MAX : 0);
 239
 240   pthread_cleanup_pop (0);
 241
 242   FAIL_EXIT1 ("usleep returns");
 243 }
 244
 245
 246 static void *
 247 tf_nanosleep (void *arg)
 248 {
 249   xpthread_barrier_wait (&b2);
 250
 251   if (arg != NULL)
 252     xpthread_barrier_wait (&b2);
 253
 254   pthread_cleanup_push (cl, NULL);
 255
 256   struct timespec ts = { .tv_sec = arg == NULL ? 10000000 : 0, .tv_nsec = 0 };
 257   TEMP_FAILURE_RETRY (nanosleep (&ts, &ts));
 258
 259   pthread_cleanup_pop (0);
 260
 261   FAIL_EXIT1 ("nanosleep returns");
 262 }
 263
 264
 265 static void *
 266 tf_select (void *arg)
 267 {
 268   int fd;
 269
 270   if (arg == NULL)
 271     fd = fds[0];
 272   else
 273     {
 274       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 275       tempfd = fd = mkstemp (fname);
 276       if (fd == -1)
 277         FAIL_EXIT1 ("mkstemp failed: %m");
 278       unlink (fname);
 279
 280       xpthread_barrier_wait (&b2);
 281     }
 282
 283   xpthread_barrier_wait (&b2);
 284
 285   fd_set rfs;
 286   FD_ZERO (&rfs);
 287   FD_SET (fd, &rfs);
 288
 289   int s;
 290   pthread_cleanup_push (cl, NULL);
 291
 292   s = select (fd + 1, &rfs, NULL, NULL, NULL);
 293
 294   pthread_cleanup_pop (0);
 295
 296   FAIL_EXIT1 ("select returns with %d: %m", s);
 297 }
 298
 299
 300 static void *
 301 tf_pselect (void *arg)
 302 {
 303   int fd;
 304
 305   if (arg == NULL)
 306     fd = fds[0];
 307   else
 308     {
 309       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 310       tempfd = fd = mkstemp (fname);
 311       if (fd == -1)
 312         FAIL_EXIT1 ("mkstemp failed: %m");
 313       unlink (fname);
 314
 315       xpthread_barrier_wait (&b2);
 316     }
 317
 318   xpthread_barrier_wait (&b2);
 319
 320   fd_set rfs;
 321   FD_ZERO (&rfs);
 322   FD_SET (fd, &rfs);
 323
 324   int s;
 325   pthread_cleanup_push (cl, NULL);
 326
 327   s = pselect (fd + 1, &rfs, NULL, NULL, NULL, NULL);
 328
 329   pthread_cleanup_pop (0);
 330
 331   FAIL_EXIT1 ("pselect returns with %d: %m", s);
 332 }
 333
 334
 335 static void *
 336 tf_poll (void *arg)
 337 {
 338   int fd;
 339
 340   if (arg == NULL)
 341     fd = fds[0];
 342   else
 343     {
 344       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 345       tempfd = fd = mkstemp (fname);
 346       if (fd == -1)
 347         FAIL_EXIT1 ("mkstemp failed: %m");
 348       unlink (fname);
 349
 350       xpthread_barrier_wait (&b2);
 351     }
 352
 353   xpthread_barrier_wait (&b2);
 354
 355   struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
 356
 357   int s;
 358   pthread_cleanup_push (cl, NULL);
 359
 360   s = poll (rfs, 1, -1);
 361
 362   pthread_cleanup_pop (0);
 363
 364   FAIL_EXIT1 ("poll returns with %d: %m", s);
 365 }
 366
 367
 368 static void *
 369 tf_ppoll (void *arg)
 370 {
 371   int fd;
 372
 373   if (arg == NULL)
 374     fd = fds[0];
 375   else
 376     {
 377       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 378       tempfd = fd = mkstemp (fname);
 379       if (fd == -1)
 380         FAIL_EXIT1 ("mkstemp failed: %m");
 381       unlink (fname);
 382
 383       xpthread_barrier_wait (&b2);
 384     }
 385
 386   xpthread_barrier_wait (&b2);
 387
 388   struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
 389
 390   int s;
 391   pthread_cleanup_push (cl, NULL);
 392
 393   s = ppoll (rfs, 1, NULL, NULL);
 394
 395   pthread_cleanup_pop (0);
 396
 397   FAIL_EXIT1 ("ppoll returns with %d: %m", s);
 398 }
 399
 400
 401 static void *
 402 tf_wait (void *arg)
 403 {
 404   pid_t pid = fork ();
 405   if (pid == -1)
 406     FAIL_EXIT1 ("fork: %m");
 407
 408   if (pid == 0)
 409     {
 410       /* Make the program disappear after a while.  */
 411       if (arg == NULL)
 412         sleep (10);
 413       exit (0);
 414     }
 415
 416   if (arg != NULL)
 417     {
 418       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 419       while (nanosleep (&ts, &ts) != 0)
 420         continue;
 421
 422       xpthread_barrier_wait (&b2);
 423     }
 424
 425   xpthread_barrier_wait (&b2);
 426
 427   int s;
 428   pthread_cleanup_push (cl, NULL);
 429
 430   s = wait (NULL);
 431
 432   pthread_cleanup_pop (0);
 433
 434   FAIL_EXIT1 ("wait returns with %d: %m", s);
 435 }
 436
 437
 438 static void *
 439 tf_waitpid (void *arg)
 440 {
 441   pid_t pid = fork ();
 442   if (pid == -1)
 443     FAIL_EXIT1 ("fork: %m");
 444
 445   if (pid == 0)
 446     {
 447       /* Make the program disappear after a while.  */
 448       if (arg == NULL)
 449         sleep (10);
 450       exit (0);
 451     }
 452
 453   if (arg != NULL)
 454     {
 455       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 456       while (nanosleep (&ts, &ts) != 0)
 457         continue;
 458
 459       xpthread_barrier_wait (&b2);
 460     }
 461
 462   xpthread_barrier_wait (&b2);
 463
 464   int s;
 465   pthread_cleanup_push (cl, NULL);
 466
 467   s = waitpid (-1, NULL, 0);
 468
 469   pthread_cleanup_pop (0);
 470
 471   FAIL_EXIT1 ("waitpid returns with %d: %m", s);
 472 }
 473
 474
 475 static void *
 476 tf_waitid (void *arg)
 477 {
 478   pid_t pid = fork ();
 479   if (pid == -1)
 480     FAIL_EXIT1 ("fork: %m");
 481
 482   if (pid == 0)
 483     {
 484       /* Make the program disappear after a while.  */
 485       if (arg == NULL)
 486         sleep (10);
 487       exit (0);
 488     }
 489
 490   if (arg != NULL)
 491     {
 492       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 493       while (nanosleep (&ts, &ts) != 0)
 494         continue;
 495
 496       xpthread_barrier_wait (&b2);
 497     }
 498
 499   xpthread_barrier_wait (&b2);
 500
 501   int s;
 502   pthread_cleanup_push (cl, NULL);
 503
 504 #ifndef WEXITED
 505 # define WEXITED 0
 506 #endif
 507   siginfo_t si;
 508   s = waitid (P_PID, pid, &si, WEXITED);
 509
 510   pthread_cleanup_pop (0);
 511
 512   FAIL_EXIT1 ("waitid returns with %d: %m", s);
 513 }
 514
 515
 516 static void *
 517 tf_sigpause (void *arg)
 518 {
 519   xpthread_barrier_wait (&b2);
 520
 521   if (arg != NULL)
 522     xpthread_barrier_wait (&b2);
 523
 524   pthread_cleanup_push (cl, NULL);
 525
 526   sigpause (sigmask (SIGINT));
 527
 528   pthread_cleanup_pop (0);
 529
 530   FAIL_EXIT1 ("sigpause returned");
 531 }
 532
 533
 534 static void *
 535 tf_sigsuspend (void *arg)
 536 {
 537   xpthread_barrier_wait (&b2);
 538
 539   if (arg != NULL)
 540     xpthread_barrier_wait (&b2);
 541
 542   pthread_cleanup_push (cl, NULL);
 543
 544   /* Just for fun block all signals.  */
 545   sigset_t mask;
 546   sigfillset (&mask);
 547   sigsuspend (&mask);
 548
 549   pthread_cleanup_pop (0);
 550
 551   FAIL_EXIT1 ("sigsuspend returned");
 552 }
 553
 554
 555 static void *
 556 tf_sigwait (void *arg)
 557 {
 558   xpthread_barrier_wait (&b2);
 559
 560   if (arg != NULL)
 561     xpthread_barrier_wait (&b2);
 562
 563   /* Block SIGUSR1.  */
 564   sigset_t mask;
 565   sigemptyset (&mask);
 566   sigaddset (&mask, SIGUSR1);
 567   TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
 568
 569   int sig;
 570   pthread_cleanup_push (cl, NULL);
 571
 572   /* Wait for SIGUSR1.  */
 573   sigwait (&mask, &sig);
 574
 575   pthread_cleanup_pop (0);
 576
 577   FAIL_EXIT1 ("sigwait returned with signal %d", sig);
 578 }
 579
 580
 581 static void *
 582 tf_sigwaitinfo (void *arg)
 583 {
 584   xpthread_barrier_wait (&b2);
 585
 586   if (arg != NULL)
 587     xpthread_barrier_wait (&b2);
 588
 589   /* Block SIGUSR1.  */
 590   sigset_t mask;
 591   sigemptyset (&mask);
 592   sigaddset (&mask, SIGUSR1);
 593   TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
 594
 595   siginfo_t info;
 596   pthread_cleanup_push (cl, NULL);
 597
 598   /* Wait for SIGUSR1.  */
 599   sigwaitinfo (&mask, &info);
 600
 601   pthread_cleanup_pop (0);
 602
 603   FAIL_EXIT1 ("sigwaitinfo returned with signal %d", info.si_signo);
 604 }
 605
 606
 607 static void *
 608 tf_sigtimedwait (void *arg)
 609 {
 610   xpthread_barrier_wait (&b2);
 611
 612   if (arg != NULL)
 613     xpthread_barrier_wait (&b2);
 614
 615   /* Block SIGUSR1.  */
 616   sigset_t mask;
 617   sigemptyset (&mask);
 618   sigaddset (&mask, SIGUSR1);
 619   TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
 620
 621   /* Wait for SIGUSR1.  */
 622   siginfo_t info;
 623   struct timespec ts = { .tv_sec = 60, .tv_nsec = 0 };
 624   pthread_cleanup_push (cl, NULL);
 625
 626   sigtimedwait (&mask, &info, &ts);
 627
 628   pthread_cleanup_pop (0);
 629
 630   FAIL_EXIT1 ("sigtimedwait returned with signal %d", info.si_signo);
 631 }
 632
 633
 634 static void *
 635 tf_pause (void *arg)
 636 {
 637   xpthread_barrier_wait (&b2);
 638
 639   if (arg != NULL)
 640     xpthread_barrier_wait (&b2);
 641
 642   pthread_cleanup_push (cl, NULL);
 643
 644   pause ();
 645
 646   pthread_cleanup_pop (0);
 647
 648   FAIL_EXIT1 ("pause returned");
 649 }
 650
 651
 652 static void *
 653 tf_accept (void *arg)
 654 {
 655   struct sockaddr_un sun;
 656   /* To test a non-blocking accept call we make the call file by using
 657      a datagrame socket.  */
 658   int pf = arg == NULL ? SOCK_STREAM : SOCK_DGRAM;
 659
 660   tempfd = socket (AF_UNIX, pf, 0);
 661   if (tempfd == -1)
 662     FAIL_EXIT1 ("socket (AF_UNIX, %s, 0): %m", arg == NULL ? "SOCK_STREAM"
 663                                                : "SOCK_DGRAM");
 664
 665   int tries = 0;
 666   do
 667     {
 668       TEST_VERIFY_EXIT (tries++ < 10);
 669
 670       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-1-XXXXXX");
 671       TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
 672
 673       sun.sun_family = AF_UNIX;
 674     }
 675   while (bind (tempfd, (struct sockaddr *) &sun,
 676                offsetof (struct sockaddr_un, sun_path)
 677                + strlen (sun.sun_path) + 1) != 0);
 678
 679   unlink (sun.sun_path);
 680
 681   listen (tempfd, 5);
 682
 683   socklen_t len = sizeof (sun);
 684
 685   xpthread_barrier_wait (&b2);
 686
 687   if (arg != NULL)
 688     xpthread_barrier_wait (&b2);
 689
 690   pthread_cleanup_push (cl, NULL);
 691
 692   accept (tempfd, (struct sockaddr *) &sun, &len);
 693
 694   pthread_cleanup_pop (0);
 695
 696   FAIL_EXIT1 ("accept returned");
 697 }
 698
 699
 700 static void *
 701 tf_send (void *arg)
 702 {
 703   struct sockaddr_un sun;
 704
 705   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
 706   if (tempfd == -1)
 707     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
 708
 709   int tries = 0;
 710   do
 711     {
 712       TEST_VERIFY_EXIT (tries++ < 10);
 713
 714       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
 715       TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
 716
 717       sun.sun_family = AF_UNIX;
 718     }
 719   while (bind (tempfd, (struct sockaddr *) &sun,
 720                offsetof (struct sockaddr_un, sun_path)
 721                + strlen (sun.sun_path) + 1) != 0);
 722
 723   listen (tempfd, 5);
 724
 725   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
 726   if (tempfd2 == -1)
 727     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
 728
 729   set_socket_buffer (tempfd2);
 730
 731   if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
 732     FAIL_EXIT1 ("connect: %m");
 733
 734   unlink (sun.sun_path);
 735
 736   xpthread_barrier_wait (&b2);
 737
 738   if (arg != NULL)
 739     xpthread_barrier_wait (&b2);
 740
 741   pthread_cleanup_push (cl, NULL);
 742
 743   char mem[WRITE_BUFFER_SIZE];
 744
 745   send (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0);
 746
 747   pthread_cleanup_pop (0);
 748
 749   FAIL_EXIT1 ("send returned");
 750 }
 751
 752
 753 static void *
 754 tf_recv (void *arg)
 755 {
 756   struct sockaddr_un sun;
 757
 758   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
 759   if (tempfd == -1)
 760     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
 761
 762   int tries = 0;
 763   do
 764     {
 765       TEST_VERIFY_EXIT (tries++ < 10);
 766
 767       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-3-XXXXXX");
 768       TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
 769
 770       sun.sun_family = AF_UNIX;
 771     }
 772   while (bind (tempfd, (struct sockaddr *) &sun,
 773                offsetof (struct sockaddr_un, sun_path)
 774                + strlen (sun.sun_path) + 1) != 0);
 775
 776   listen (tempfd, 5);
 777
 778   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
 779   if (tempfd2 == -1)
 780     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
 781
 782   if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
 783     FAIL_EXIT1 ("connect: %m");
 784
 785   unlink (sun.sun_path);
 786
 787   xpthread_barrier_wait (&b2);
 788
 789   if (arg != NULL)
 790     xpthread_barrier_wait (&b2);
 791
 792   pthread_cleanup_push (cl, NULL);
 793
 794   char mem[70];
 795
 796   recv (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0);
 797
 798   pthread_cleanup_pop (0);
 799
 800   FAIL_EXIT1 ("recv returned");
 801 }
 802
 803
 804 static void *
 805 tf_recvfrom (void *arg)
 806 {
 807   struct sockaddr_un sun;
 808
 809   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
 810   if (tempfd == -1)
 811     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
 812
 813   int tries = 0;
 814   do
 815     {
 816       TEST_VERIFY_EXIT (tries++ < 10);
 817
 818       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-4-XXXXXX");
 819       TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
 820
 821       sun.sun_family = AF_UNIX;
 822     }
 823   while (bind (tempfd, (struct sockaddr *) &sun,
 824                offsetof (struct sockaddr_un, sun_path)
 825                + strlen (sun.sun_path) + 1) != 0);
 826
 827   tempfname = strdup (sun.sun_path);
 828
 829   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
 830   if (tempfd2 == -1)
 831     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
 832
 833   xpthread_barrier_wait (&b2);
 834
 835   if (arg != NULL)
 836     xpthread_barrier_wait (&b2);
 837
 838   pthread_cleanup_push (cl, NULL);
 839
 840   char mem[70];
 841   socklen_t len = sizeof (sun);
 842
 843   recvfrom (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0,
 844             (struct sockaddr *) &sun, &len);
 845
 846   pthread_cleanup_pop (0);
 847
 848   FAIL_EXIT1 ("recvfrom returned");
 849 }
 850
 851
 852 static void *
 853 tf_recvmsg (void *arg)
 854 {
 855   struct sockaddr_un sun;
 856
 857   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
 858   if (tempfd == -1)
 859     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
 860
 861   int tries = 0;
 862   do
 863     {
 864       TEST_VERIFY_EXIT (tries++ < 10);
 865
 866       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-5-XXXXXX");
 867       TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
 868
 869       sun.sun_family = AF_UNIX;
 870     }
 871   while (bind (tempfd, (struct sockaddr *) &sun,
 872                offsetof (struct sockaddr_un, sun_path)
 873                + strlen (sun.sun_path) + 1) != 0);
 874
 875   tempfname = strdup (sun.sun_path);
 876
 877   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
 878   if (tempfd2 == -1)
 879     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
 880
 881   xpthread_barrier_wait (&b2);
 882
 883   if (arg != NULL)
 884     xpthread_barrier_wait (&b2);
 885
 886   pthread_cleanup_push (cl, NULL);
 887
 888   char mem[70];
 889   struct iovec iov[1];
 890   iov[0].iov_base = mem;
 891   iov[0].iov_len = arg == NULL ? sizeof (mem) : 0;
 892
 893   struct msghdr m;
 894   m.msg_name = &sun;
 895   m.msg_namelen = sizeof (sun);
 896   m.msg_iov = iov;
 897   m.msg_iovlen = 1;
 898   m.msg_control = NULL;
 899   m.msg_controllen = 0;
 900
 901   recvmsg (tempfd2, &m, 0);
 902
 903   pthread_cleanup_pop (0);
 904
 905   FAIL_EXIT1 ("recvmsg returned");
 906 }
 907
 908 static void *
 909 tf_open (void *arg)
 910 {
 911   if (arg == NULL)
 912     {
 913       fifofd = mkfifo (fifoname, S_IWUSR | S_IRUSR);
 914       if (fifofd == -1)
 915         FAIL_EXIT1 ("mkfifo: %m");
 916     }
 917   else
 918     {
 919       xpthread_barrier_wait (&b2);
 920     }
 921
 922   xpthread_barrier_wait (&b2);
 923
 924   pthread_cleanup_push (cl_fifo, NULL);
 925
 926   open (arg ? "Makefile" : fifoname, O_RDONLY);
 927
 928   pthread_cleanup_pop (0);
 929
 930   FAIL_EXIT1 ("open returned");
 931 }
 932
 933
 934 static void *
 935 tf_close (void *arg)
 936 {
 937   if (arg == NULL)
 938     // XXX If somebody can provide a portable test case in which close()
 939     // blocks we can enable this test to run in both rounds.
 940     abort ();
 941
 942   char fname[] = "/tmp/tst-cancel-fd-XXXXXX";
 943   tempfd = mkstemp (fname);
 944   if (tempfd == -1)
 945     FAIL_EXIT1 ("mkstemp failed: %m");
 946   unlink (fname);
 947
 948   xpthread_barrier_wait (&b2);
 949
 950   xpthread_barrier_wait (&b2);
 951
 952   pthread_cleanup_push (cl, NULL);
 953
 954   close (tempfd);
 955
 956   pthread_cleanup_pop (0);
 957
 958   FAIL_EXIT1 ("close returned");
 959 }
 960
 961
 962 static void *
 963 tf_pread (void *arg)
 964 {
 965   if (arg == NULL)
 966     // XXX If somebody can provide a portable test case in which pread()
 967     // blocks we can enable this test to run in both rounds.
 968     abort ();
 969
 970   tempfd = open ("Makefile", O_RDONLY);
 971   if (tempfd == -1)
 972     FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
 973
 974   xpthread_barrier_wait (&b2);
 975
 976   xpthread_barrier_wait (&b2);
 977
 978   pthread_cleanup_push (cl, NULL);
 979
 980   char mem[10];
 981   pread (tempfd, mem, sizeof (mem), 0);
 982
 983   pthread_cleanup_pop (0);
 984
 985   FAIL_EXIT1 ("pread returned");
 986 }
 987
 988
 989 static void *
 990 tf_pwrite (void *arg)
 991 {
 992   if (arg == NULL)
 993     // XXX If somebody can provide a portable test case in which pwrite()
 994     // blocks we can enable this test to run in both rounds.
 995     abort ();
 996
 997   char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 998   tempfd = mkstemp (fname);
 999   if (tempfd == -1)
1000     FAIL_EXIT1 ("mkstemp failed: %m");
1001   unlink (fname);
1002
1003   xpthread_barrier_wait (&b2);
1004
1005   xpthread_barrier_wait (&b2);
1006
1007   pthread_cleanup_push (cl, NULL);
1008
1009   char mem[10];
1010   pwrite (tempfd, mem, sizeof (mem), 0);
1011
1012   pthread_cleanup_pop (0);
1013
1014   FAIL_EXIT1 ("pwrite returned");
1015 }
1016
1017 static void *
1018 tf_preadv (void *arg)
1019 {
1020   int fd;
1021
1022   if (arg == NULL)
1023     /* XXX If somebody can provide a portable test case in which preadv
1024        blocks we can enable this test to run in both rounds.  */
1025     abort ();
1026
1027   char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1028   tempfd = fd = mkstemp (fname);
1029   if (fd == -1)
1030     FAIL_EXIT1 ("mkstemp failed: %m");
1031   unlink (fname);
1032
1033   xpthread_barrier_wait (&b2);
1034
1035   xpthread_barrier_wait (&b2);
1036
1037   ssize_t s;
1038   pthread_cleanup_push (cl, NULL);
1039
1040   char buf[100];
1041   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1042   s = preadv (fd, iov, 1, 0);
1043
1044   pthread_cleanup_pop (0);
1045
1046   FAIL_EXIT1 ("preadv returns with %zd", s);
1047 }
1048
1049 static void *
1050 tf_pwritev (void *arg)
1051 {
1052   int fd;
1053
1054   if (arg == NULL)
1055     /* XXX If somebody can provide a portable test case in which pwritev
1056        blocks we can enable this test to run in both rounds.  */
1057     abort ();
1058
1059   char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1060   tempfd = fd = mkstemp (fname);
1061   if (fd == -1)
1062     FAIL_EXIT1 ("mkstemp failed: %m");
1063   unlink (fname);
1064
1065   xpthread_barrier_wait (&b2);
1066
1067   xpthread_barrier_wait (&b2);
1068
1069   ssize_t s;
1070   pthread_cleanup_push (cl, NULL);
1071
1072   char buf[WRITE_BUFFER_SIZE];
1073   memset (buf, '\0', sizeof (buf));
1074   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1075   s = pwritev (fd, iov, 1, 0);
1076
1077   pthread_cleanup_pop (0);
1078
1079   FAIL_EXIT1 ("pwritev returns with %zd", s);
1080 }
1081
1082 static void *
1083 tf_pwritev2 (void *arg)
1084 {
1085   int fd;
1086
1087   if (arg == NULL)
1088     /* XXX If somebody can provide a portable test case in which pwritev2
1089        blocks we can enable this test to run in both rounds.  */
1090     abort ();
1091
1092   errno = 0;
1093
1094   char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1095   tempfd = fd = mkstemp (fname);
1096   if (fd == -1)
1097     FAIL_EXIT1 ("mkstemp: %m");
1098   unlink (fname);
1099
1100   xpthread_barrier_wait (&b2);
1101
1102   xpthread_barrier_wait (&b2);
1103
1104   ssize_t s;
1105   pthread_cleanup_push (cl, NULL);
1106
1107   char buf[WRITE_BUFFER_SIZE];
1108   memset (buf, '\0', sizeof (buf));
1109   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1110   s = pwritev2 (fd, iov, 1, 0, 0);
1111
1112   pthread_cleanup_pop (0);
1113
1114   FAIL_EXIT1 ("pwritev2 returns with %zd", s);
1115 }
1116
1117 static void *
1118 tf_preadv2 (void *arg)
1119 {
1120   int fd;
1121
1122   if (arg == NULL)
1123     /* XXX If somebody can provide a portable test case in which preadv2
1124        blocks we can enable this test to run in both rounds.  */
1125     abort ();
1126
1127   errno = 0;
1128
1129   char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1130   tempfd = fd = mkstemp (fname);
1131   if (fd == -1)
1132     FAIL_EXIT1 ("mkstemp failed: %m");
1133   unlink (fname);
1134
1135   xpthread_barrier_wait (&b2);
1136
1137   xpthread_barrier_wait (&b2);
1138
1139   ssize_t s;
1140   pthread_cleanup_push (cl, NULL);
1141
1142   char buf[100];
1143   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1144   s = preadv2 (fd, iov, 1, 0, 0);
1145
1146   pthread_cleanup_pop (0);
1147
1148   FAIL_EXIT1 ("preadv2 returns with %zd", s);
1149 }
1150
1151 static void *
1152 tf_fsync (void *arg)
1153 {
1154   if (arg == NULL)
1155     // XXX If somebody can provide a portable test case in which fsync()
1156     // blocks we can enable this test to run in both rounds.
1157     abort ();
1158
1159   tempfd = open ("Makefile", O_RDONLY);
1160   if (tempfd == -1)
1161     FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1162
1163   xpthread_barrier_wait (&b2);
1164
1165   xpthread_barrier_wait (&b2);
1166
1167   pthread_cleanup_push (cl, NULL);
1168
1169   fsync (tempfd);
1170
1171   pthread_cleanup_pop (0);
1172
1173   FAIL_EXIT1 ("fsync returned");
1174 }
1175
1176
1177 static void *
1178 tf_fdatasync (void *arg)
1179 {
1180   if (arg == NULL)
1181     // XXX If somebody can provide a portable test case in which fdatasync()
1182     // blocks we can enable this test to run in both rounds.
1183     abort ();
1184
1185   tempfd = open ("Makefile", O_RDONLY);
1186   if (tempfd == -1)
1187     FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1188
1189   xpthread_barrier_wait (&b2);
1190
1191   xpthread_barrier_wait (&b2);
1192
1193   pthread_cleanup_push (cl, NULL);
1194
1195   fdatasync (tempfd);
1196
1197   pthread_cleanup_pop (0);
1198
1199   FAIL_EXIT1 ("fdatasync returned");
1200 }
1201
1202
1203 static void *
1204 tf_msync (void *arg)
1205 {
1206   if (arg == NULL)
1207     // XXX If somebody can provide a portable test case in which msync()
1208     // blocks we can enable this test to run in both rounds.
1209     abort ();
1210
1211   tempfd = open ("Makefile", O_RDONLY);
1212   if (tempfd == -1)
1213     FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
1214
1215   void *p = xmmap (NULL, 10, PROT_READ, MAP_SHARED, tempfd);
1216
1217   xpthread_barrier_wait (&b2);
1218
1219   xpthread_barrier_wait (&b2);
1220
1221   pthread_cleanup_push (cl, NULL);
1222
1223   msync (p, 10, 0);
1224
1225   pthread_cleanup_pop (0);
1226
1227   FAIL_EXIT1 ("msync returned");
1228 }
1229
1230
1231 static void *
1232 tf_sendto (void *arg)
1233 {
1234   struct sockaddr_un sun;
1235
1236   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1237   if (tempfd == -1)
1238     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1239
1240   int tries = 0;
1241   do
1242     {
1243       TEST_VERIFY_EXIT (tries++ < 10);
1244
1245       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-6-XXXXXX");
1246       TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1247
1248       sun.sun_family = AF_UNIX;
1249     }
1250   while (bind (tempfd, (struct sockaddr *) &sun,
1251                offsetof (struct sockaddr_un, sun_path)
1252                + strlen (sun.sun_path) + 1) != 0);
1253
1254   listen (tempfd, 5);
1255
1256   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1257   if (tempfd2 == -1)
1258     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1259
1260   set_socket_buffer (tempfd2);
1261
1262   if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
1263     FAIL_EXIT1 ("connect: %m");
1264
1265   unlink (sun.sun_path);
1266
1267   xpthread_barrier_wait (&b2);
1268
1269   if (arg != NULL)
1270     xpthread_barrier_wait (&b2);
1271
1272   pthread_cleanup_push (cl, NULL);
1273
1274   char mem[WRITE_BUFFER_SIZE];
1275
1276   sendto (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0, NULL, 0);
1277
1278   pthread_cleanup_pop (0);
1279
1280   FAIL_EXIT1 ("sendto returned");
1281 }
1282
1283
1284 static void *
1285 tf_sendmsg (void *arg)
1286 {
1287   if (arg == NULL)
1288     // XXX If somebody can provide a portable test case in which sendmsg()
1289     // blocks we can enable this test to run in both rounds.
1290     abort ();
1291
1292   struct sockaddr_un sun;
1293
1294   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
1295   if (tempfd == -1)
1296     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
1297
1298   int tries = 0;
1299   do
1300     {
1301       TEST_VERIFY_EXIT (tries++ < 10);
1302
1303       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-7-XXXXXX");
1304       TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1305
1306       sun.sun_family = AF_UNIX;
1307     }
1308   while (bind (tempfd, (struct sockaddr *) &sun,
1309                offsetof (struct sockaddr_un, sun_path)
1310                + strlen (sun.sun_path) + 1) != 0);
1311   tempfname = strdup (sun.sun_path);
1312
1313   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
1314   if (tempfd2 == -1)
1315     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
1316
1317   xpthread_barrier_wait (&b2);
1318
1319   xpthread_barrier_wait (&b2);
1320
1321   pthread_cleanup_push (cl, NULL);
1322
1323   char mem[1];
1324   struct iovec iov[1];
1325   iov[0].iov_base = mem;
1326   iov[0].iov_len = 1;
1327
1328   struct msghdr m;
1329   m.msg_name = &sun;
1330   m.msg_namelen = (offsetof (struct sockaddr_un, sun_path)
1331                    + strlen (sun.sun_path) + 1);
1332   m.msg_iov = iov;
1333   m.msg_iovlen = 1;
1334   m.msg_control = NULL;
1335   m.msg_controllen = 0;
1336
1337   sendmsg (tempfd2, &m, 0);
1338
1339   pthread_cleanup_pop (0);
1340
1341   FAIL_EXIT1 ("sendmsg returned");
1342 }
1343
1344
1345 static void *
1346 tf_creat (void *arg)
1347 {
1348   if (arg == NULL)
1349     // XXX If somebody can provide a portable test case in which sendmsg()
1350     // blocks we can enable this test to run in both rounds.
1351     abort ();
1352
1353   xpthread_barrier_wait (&b2);
1354
1355   xpthread_barrier_wait (&b2);
1356
1357   pthread_cleanup_push (cl, NULL);
1358
1359   creat ("tmp/tst-cancel-4-should-not-exist", 0666);
1360
1361   pthread_cleanup_pop (0);
1362
1363   FAIL_EXIT1 ("creat returned");
1364 }
1365
1366
1367 static void *
1368 tf_connect (void *arg)
1369 {
1370   if (arg == NULL)
1371     // XXX If somebody can provide a portable test case in which connect()
1372     // blocks we can enable this test to run in both rounds.
1373     abort ();
1374
1375   struct sockaddr_un sun;
1376
1377   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1378   if (tempfd == -1)
1379     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1380
1381   int tries = 0;
1382   do
1383     {
1384       TEST_VERIFY_EXIT (tries++ < 10);
1385
1386       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
1387       TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
1388
1389       sun.sun_family = AF_UNIX;
1390     }
1391   while (bind (tempfd, (struct sockaddr *) &sun,
1392                offsetof (struct sockaddr_un, sun_path)
1393                + strlen (sun.sun_path) + 1) != 0);
1394   tempfname = strdup (sun.sun_path);
1395
1396   listen (tempfd, 5);
1397
1398   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1399   if (tempfd2 == -1)
1400     FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
1401
1402   xpthread_barrier_wait (&b2);
1403
1404   if (arg != NULL)
1405     xpthread_barrier_wait (&b2);
1406
1407   pthread_cleanup_push (cl, NULL);
1408
1409   connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun));
1410
1411   pthread_cleanup_pop (0);
1412
1413   FAIL_EXIT1 ("connect returned");
1414 }
1415
1416
1417 static void *
1418 tf_tcdrain (void *arg)
1419 {
1420   if (arg == NULL)
1421     // XXX If somebody can provide a portable test case in which tcdrain()
1422     // blocks we can enable this test to run in both rounds.
1423     abort ();
1424
1425   xpthread_barrier_wait (&b2);
1426
1427   if (arg != NULL)
1428     xpthread_barrier_wait (&b2);
1429
1430   pthread_cleanup_push (cl, NULL);
1431
1432   /* Regardless of stderr being a terminal, the tcdrain call should be
1433      canceled.  */
1434   tcdrain (STDERR_FILENO);
1435
1436   pthread_cleanup_pop (0);
1437
1438   FAIL_EXIT1 ("tcdrain returned");
1439 }
1440
1441
1442 static void *
1443 tf_msgrcv (void *arg)
1444 {
1445   tempmsg = msgget (IPC_PRIVATE, 0666 | IPC_CREAT);
1446   if (tempmsg == -1)
1447     FAIL_EXIT1 ("msgget (IPC_PRIVATE, 0666 | IPC_CREAT): %m");
1448
1449   xpthread_barrier_wait (&b2);
1450
1451   if (arg != NULL)
1452     xpthread_barrier_wait (&b2);
1453
1454   ssize_t s;
1455
1456   pthread_cleanup_push (cl, NULL);
1457
1458   struct
1459   {
1460     long int type;
1461     char mem[10];
1462   } m;
1463   int randnr;
1464   /* We need a positive random number.  */
1465   do
1466     randnr = random () % 64000;
1467   while (randnr <= 0);
1468   do
1469     {
1470       errno = 0;
1471       s = msgrcv (tempmsg, (struct msgbuf *) &m, 10, randnr, 0);
1472     }
1473   while (errno == EIDRM || errno == EINTR);
1474
1475   pthread_cleanup_pop (0);
1476
1477   msgctl (tempmsg, IPC_RMID, NULL);
1478
1479   FAIL_EXIT1 ("msgrcv returned %zd", s);
1480 }
1481
1482
1483 static void *
1484 tf_msgsnd (void *arg)
1485 {
1486   if (arg == NULL)
1487     // XXX If somebody can provide a portable test case in which msgsnd()
1488     // blocks we can enable this test to run in both rounds.
1489     abort ();
1490
1491   tempmsg = msgget (IPC_PRIVATE, 0666 | IPC_CREAT);
1492   if (tempmsg == -1)
1493     FAIL_EXIT1 ("msgget (IPC_PRIVATE, 0666 | IPC_CREAT): %m");
1494
1495   xpthread_barrier_wait (&b2);
1496
1497   xpthread_barrier_wait (&b2);
1498
1499   pthread_cleanup_push (cl, NULL);
1500
1501   struct
1502   {
1503     long int type;
1504     char mem[1];
1505   } m;
1506   /* We need a positive random number.  */
1507   do
1508     m.type = random () % 64000;
1509   while (m.type <= 0);
1510   msgsnd (tempmsg, (struct msgbuf *) &m, sizeof (m.mem), 0);
1511
1512   pthread_cleanup_pop (0);
1513
1514   msgctl (tempmsg, IPC_RMID, NULL);
1515
1516   FAIL_EXIT1 ("msgsnd returned");
1517 }
1518
1519
1520 struct cancel_tests tests[] =
1521 {
1522   ADD_TEST (read, 2, 0),
1523   ADD_TEST (readv, 2, 0),
1524   ADD_TEST (select, 2, 0),
1525   ADD_TEST (pselect, 2, 0),
1526   ADD_TEST (poll, 2, 0),
1527   ADD_TEST (ppoll, 2, 0),
1528   ADD_TEST (write, 2, 0),
1529   ADD_TEST (writev, 2, 0),
1530   ADD_TEST (sleep, 2, 0),
1531   ADD_TEST (usleep, 2, 0),
1532   ADD_TEST (nanosleep, 2, 0),
1533   ADD_TEST (wait, 2, 0),
1534   ADD_TEST (waitid, 2, 0),
1535   ADD_TEST (waitpid, 2, 0),
1536   ADD_TEST (sigpause, 2, 0),
1537   ADD_TEST (sigsuspend, 2, 0),
1538   ADD_TEST (sigwait, 2, 0),
1539   ADD_TEST (sigwaitinfo, 2, 0),
1540   ADD_TEST (sigtimedwait, 2, 0),
1541   ADD_TEST (pause, 2, 0),
1542   ADD_TEST (accept, 2, 0),
1543   ADD_TEST (send, 2, 0),
1544   ADD_TEST (recv, 2, 0),
1545   ADD_TEST (recvfrom, 2, 0),
1546   ADD_TEST (recvmsg, 2, 0),
1547   ADD_TEST (preadv, 2, 1),
1548   ADD_TEST (preadv2, 2, 1),
1549   ADD_TEST (pwritev, 2, 1),
1550   ADD_TEST (pwritev2, 2, 1),
1551   ADD_TEST (open, 2, 1),
1552   ADD_TEST (close, 2, 1),
1553   ADD_TEST (pread, 2, 1),
1554   ADD_TEST (pwrite, 2, 1),
1555   ADD_TEST (fsync, 2, 1),
1556   ADD_TEST (fdatasync, 2, 1),
1557   ADD_TEST (msync, 2, 1),
1558   ADD_TEST (sendto, 2, 1),
1559   ADD_TEST (sendmsg, 2, 1),
1560   ADD_TEST (creat, 2, 1),
1561   ADD_TEST (connect, 2, 1),
1562   ADD_TEST (tcdrain, 2, 1),
1563   ADD_TEST (msgrcv, 2, 0),
1564   ADD_TEST (msgsnd, 2, 1),
1565 };
1566 #define ntest_tf (sizeof (tests) / sizeof (tests[0]))
1567
1568 #include "tst-cancel4-common.c"