nptl/tst-cancel4.c

   1 /* Copyright (C) 2002-2016 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 <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/types.h>
  26 #include <sys/socket.h>
  27 #include <sys/un.h>
  28 #include <sys/ipc.h>
  29 #include <sys/msg.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <pthread.h>
  33 #include <fcntl.h>
  34 #include <termios.h>
  35 #include <sys/mman.h>
  36 #include <sys/poll.h>
  37 #include <sys/wait.h>
  38
  39
  40 /* Since STREAMS are not supported in the standard Linux kernel and
  41    there we don't advertise STREAMS as supported is no need to test
  42    the STREAMS related functions.  This affects
  43      getmsg()              getpmsg()          putmsg()
  44      putpmsg()
  45
  46    lockf() and fcntl() are tested in tst-cancel16.
  47
  48    pthread_join() is tested in tst-join5.
  49
  50    pthread_testcancel()'s only purpose is to allow cancellation.  This
  51    is tested in several places.
  52
  53    sem_wait() and sem_timedwait() are checked in tst-cancel1[2345] tests.
  54
  55    mq_send(), mq_timedsend(), mq_receive() and mq_timedreceive() are checked
  56    in tst-mqueue8{,x} tests.
  57
  58    aio_suspend() is tested in tst-cancel17.
  59
  60    clock_nanosleep() is tested in tst-cancel18.
  61
  62    Linux sendmmsg and recvmmsg are checked in tst-cancel4_1.c and
  63    tst-cancel4_2.c respectively.
  64 */
  65
  66 #include "tst-cancel4-common.h"
  67
  68
  69 #ifndef IPC_ADDVAL
  70 # define IPC_ADDVAL 0
  71 #endif
  72
  73
  74 static void *
  75 tf_read  (void *arg)
  76 {
  77   int fd;
  78   int r;
  79
  80   if (arg == NULL)
  81     fd = fds[0];
  82   else
  83     {
  84       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
  85       tempfd = fd = mkstemp (fname);
  86       if (fd == -1)
  87         printf ("%s: mkstemp failed\n", __FUNCTION__);
  88       unlink (fname);
  89
  90       r = pthread_barrier_wait (&b2);
  91       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
  92         {
  93           printf ("%s: barrier_wait failed\n", __FUNCTION__);
  94           exit (1);
  95         }
  96     }
  97
  98   r = pthread_barrier_wait (&b2);
  99   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 100     {
 101       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 102       exit (1);
 103     }
 104
 105   ssize_t s;
 106   pthread_cleanup_push (cl, NULL);
 107
 108   char buf[100];
 109   s = read (fd, buf, sizeof (buf));
 110
 111   pthread_cleanup_pop (0);
 112
 113   printf ("%s: read returns with %zd\n", __FUNCTION__, s);
 114
 115   exit (1);
 116 }
 117
 118
 119 static void *
 120 tf_readv  (void *arg)
 121 {
 122   int fd;
 123   int r;
 124
 125   if (arg == NULL)
 126     fd = fds[0];
 127   else
 128     {
 129       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 130       tempfd = fd = mkstemp (fname);
 131       if (fd == -1)
 132         printf ("%s: mkstemp failed\n", __FUNCTION__);
 133       unlink (fname);
 134
 135       r = pthread_barrier_wait (&b2);
 136       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 137         {
 138           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 139           exit (1);
 140         }
 141     }
 142
 143   r = pthread_barrier_wait (&b2);
 144   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 145     {
 146       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 147       exit (1);
 148     }
 149
 150   ssize_t s;
 151   pthread_cleanup_push (cl, NULL);
 152
 153   char buf[100];
 154   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
 155   s = readv (fd, iov, 1);
 156
 157   pthread_cleanup_pop (0);
 158
 159   printf ("%s: readv returns with %zd\n", __FUNCTION__, s);
 160
 161   exit (1);
 162 }
 163
 164
 165 static void *
 166 tf_write  (void *arg)
 167 {
 168   int fd;
 169   int r;
 170
 171   if (arg == NULL)
 172     fd = fds[1];
 173   else
 174     {
 175       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 176       tempfd = fd = mkstemp (fname);
 177       if (fd == -1)
 178         printf ("%s: mkstemp failed\n", __FUNCTION__);
 179       unlink (fname);
 180
 181       r = pthread_barrier_wait (&b2);
 182       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 183         {
 184           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 185           exit (1);
 186         }
 187     }
 188
 189   r = pthread_barrier_wait (&b2);
 190   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 191     {
 192       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 193       exit (1);
 194     }
 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   s = write (fd, buf, sizeof (buf));
 202
 203   pthread_cleanup_pop (0);
 204
 205   printf ("%s: write returns with %zd\n", __FUNCTION__, s);
 206
 207   exit (1);
 208 }
 209
 210
 211 static void *
 212 tf_writev  (void *arg)
 213 {
 214   int fd;
 215   int r;
 216
 217   if (arg == NULL)
 218     fd = fds[1];
 219   else
 220     {
 221       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 222       tempfd = fd = mkstemp (fname);
 223       if (fd == -1)
 224         printf ("%s: mkstemp failed\n", __FUNCTION__);
 225       unlink (fname);
 226
 227       r = pthread_barrier_wait (&b2);
 228       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 229         {
 230           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 231           exit (1);
 232         }
 233     }
 234
 235   r = pthread_barrier_wait (&b2);
 236   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 237     {
 238       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 239       exit (1);
 240     }
 241
 242   ssize_t s;
 243   pthread_cleanup_push (cl, NULL);
 244
 245   char buf[WRITE_BUFFER_SIZE];
 246   memset (buf, '\0', sizeof (buf));
 247   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
 248   s = writev (fd, iov, 1);
 249
 250   pthread_cleanup_pop (0);
 251
 252   printf ("%s: writev returns with %zd\n", __FUNCTION__, s);
 253
 254   exit (1);
 255 }
 256
 257
 258 static void *
 259 tf_sleep (void *arg)
 260 {
 261   int r = pthread_barrier_wait (&b2);
 262   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 263     {
 264       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 265       exit (1);
 266     }
 267
 268   if (arg != NULL)
 269     {
 270       r = pthread_barrier_wait (&b2);
 271       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 272         {
 273           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 274           exit (1);
 275         }
 276     }
 277
 278   pthread_cleanup_push (cl, NULL);
 279
 280   sleep (arg == NULL ? 1000000 : 0);
 281
 282   pthread_cleanup_pop (0);
 283
 284   printf ("%s: sleep returns\n", __FUNCTION__);
 285
 286   exit (1);
 287 }
 288
 289
 290 static void *
 291 tf_usleep (void *arg)
 292 {
 293   int r = pthread_barrier_wait (&b2);
 294   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 295     {
 296       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 297       exit (1);
 298     }
 299
 300   if (arg != NULL)
 301     {
 302       r = pthread_barrier_wait (&b2);
 303       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 304         {
 305           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 306           exit (1);
 307         }
 308     }
 309
 310   pthread_cleanup_push (cl, NULL);
 311
 312   usleep (arg == NULL ? (useconds_t) ULONG_MAX : 0);
 313
 314   pthread_cleanup_pop (0);
 315
 316   printf ("%s: usleep returns\n", __FUNCTION__);
 317
 318   exit (1);
 319 }
 320
 321
 322 static void *
 323 tf_nanosleep (void *arg)
 324 {
 325   int r = pthread_barrier_wait (&b2);
 326   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 327     {
 328       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 329       exit (1);
 330     }
 331
 332   if (arg != NULL)
 333     {
 334       r = pthread_barrier_wait (&b2);
 335       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 336         {
 337           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 338           exit (1);
 339         }
 340     }
 341
 342   pthread_cleanup_push (cl, NULL);
 343
 344   struct timespec ts = { .tv_sec = arg == NULL ? 10000000 : 0, .tv_nsec = 0 };
 345   TEMP_FAILURE_RETRY (nanosleep (&ts, &ts));
 346
 347   pthread_cleanup_pop (0);
 348
 349   printf ("%s: nanosleep returns\n", __FUNCTION__);
 350
 351   exit (1);
 352 }
 353
 354
 355 static void *
 356 tf_select (void *arg)
 357 {
 358   int fd;
 359   int r;
 360
 361   if (arg == NULL)
 362     fd = fds[0];
 363   else
 364     {
 365       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 366       tempfd = fd = mkstemp (fname);
 367       if (fd == -1)
 368         printf ("%s: mkstemp failed\n", __FUNCTION__);
 369       unlink (fname);
 370
 371       r = pthread_barrier_wait (&b2);
 372       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 373         {
 374           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 375           exit (1);
 376         }
 377     }
 378
 379   r = pthread_barrier_wait (&b2);
 380   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 381     {
 382       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 383       exit (1);
 384     }
 385
 386   fd_set rfs;
 387   FD_ZERO (&rfs);
 388   FD_SET (fd, &rfs);
 389
 390   int s;
 391   pthread_cleanup_push (cl, NULL);
 392
 393   s = select (fd + 1, &rfs, NULL, NULL, NULL);
 394
 395   pthread_cleanup_pop (0);
 396
 397   printf ("%s: select returns with %d (%s)\n", __FUNCTION__, s,
 398           strerror (errno));
 399
 400   exit (1);
 401 }
 402
 403
 404 static void *
 405 tf_pselect (void *arg)
 406 {
 407   int fd;
 408   int r;
 409
 410   if (arg == NULL)
 411     fd = fds[0];
 412   else
 413     {
 414       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 415       tempfd = fd = mkstemp (fname);
 416       if (fd == -1)
 417         printf ("%s: mkstemp failed\n", __FUNCTION__);
 418       unlink (fname);
 419
 420       r = pthread_barrier_wait (&b2);
 421       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 422         {
 423           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 424           exit (1);
 425         }
 426     }
 427
 428   r = pthread_barrier_wait (&b2);
 429   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 430     {
 431       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 432       exit (1);
 433     }
 434
 435   fd_set rfs;
 436   FD_ZERO (&rfs);
 437   FD_SET (fd, &rfs);
 438
 439   int s;
 440   pthread_cleanup_push (cl, NULL);
 441
 442   s = pselect (fd + 1, &rfs, NULL, NULL, NULL, NULL);
 443
 444   pthread_cleanup_pop (0);
 445
 446   printf ("%s: pselect returns with %d (%s)\n", __FUNCTION__, s,
 447           strerror (errno));
 448
 449   exit (1);
 450 }
 451
 452
 453 static void *
 454 tf_poll (void *arg)
 455 {
 456   int fd;
 457   int r;
 458
 459   if (arg == NULL)
 460     fd = fds[0];
 461   else
 462     {
 463       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 464       tempfd = fd = mkstemp (fname);
 465       if (fd == -1)
 466         printf ("%s: mkstemp failed\n", __FUNCTION__);
 467       unlink (fname);
 468
 469       r = pthread_barrier_wait (&b2);
 470       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 471         {
 472           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 473           exit (1);
 474         }
 475     }
 476
 477   r = pthread_barrier_wait (&b2);
 478   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 479     {
 480       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 481       exit (1);
 482     }
 483
 484   struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
 485
 486   int s;
 487   pthread_cleanup_push (cl, NULL);
 488
 489   s = poll (rfs, 1, -1);
 490
 491   pthread_cleanup_pop (0);
 492
 493   printf ("%s: poll returns with %d (%s)\n", __FUNCTION__, s,
 494           strerror (errno));
 495
 496   exit (1);
 497 }
 498
 499
 500 static void *
 501 tf_ppoll (void *arg)
 502 {
 503   int fd;
 504   int r;
 505
 506   if (arg == NULL)
 507     fd = fds[0];
 508   else
 509     {
 510       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 511       tempfd = fd = mkstemp (fname);
 512       if (fd == -1)
 513         printf ("%s: mkstemp failed\n", __FUNCTION__);
 514       unlink (fname);
 515
 516       r = pthread_barrier_wait (&b2);
 517       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 518         {
 519           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 520           exit (1);
 521         }
 522     }
 523
 524   r = pthread_barrier_wait (&b2);
 525   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 526     {
 527       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 528       exit (1);
 529     }
 530
 531   struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
 532
 533   int s;
 534   pthread_cleanup_push (cl, NULL);
 535
 536   s = ppoll (rfs, 1, NULL, NULL);
 537
 538   pthread_cleanup_pop (0);
 539
 540   printf ("%s: ppoll returns with %d (%s)\n", __FUNCTION__, s,
 541           strerror (errno));
 542
 543   exit (1);
 544 }
 545
 546
 547 static void *
 548 tf_wait (void *arg)
 549 {
 550   pid_t pid = fork ();
 551   if (pid == -1)
 552     {
 553       puts ("fork failed");
 554       exit (1);
 555     }
 556
 557   if (pid == 0)
 558     {
 559       /* Make the program disappear after a while.  */
 560       if (arg == NULL)
 561         sleep (10);
 562       exit (0);
 563     }
 564
 565   int r;
 566   if (arg != NULL)
 567     {
 568       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 569       while (nanosleep (&ts, &ts) != 0)
 570         continue;
 571
 572       r = pthread_barrier_wait (&b2);
 573       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 574         {
 575           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 576           exit (1);
 577         }
 578     }
 579
 580   r = pthread_barrier_wait (&b2);
 581   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 582     {
 583       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 584       exit (1);
 585     }
 586
 587   int s;
 588   pthread_cleanup_push (cl, NULL);
 589
 590   s = wait (NULL);
 591
 592   pthread_cleanup_pop (0);
 593
 594   printf ("%s: wait returns with %d (%s)\n", __FUNCTION__, s,
 595           strerror (errno));
 596
 597   exit (1);
 598 }
 599
 600
 601 static void *
 602 tf_waitpid (void *arg)
 603 {
 604
 605   pid_t pid = fork ();
 606   if (pid == -1)
 607     {
 608       puts ("fork failed");
 609       exit (1);
 610     }
 611
 612   if (pid == 0)
 613     {
 614       /* Make the program disappear after a while.  */
 615       if (arg == NULL)
 616         sleep (10);
 617       exit (0);
 618     }
 619
 620   int r;
 621   if (arg != NULL)
 622     {
 623       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 624       while (nanosleep (&ts, &ts) != 0)
 625         continue;
 626
 627       r = pthread_barrier_wait (&b2);
 628       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 629         {
 630           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 631           exit (1);
 632         }
 633     }
 634
 635   r = pthread_barrier_wait (&b2);
 636   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 637     {
 638       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 639       exit (1);
 640     }
 641
 642   int s;
 643  pthread_cleanup_push (cl, NULL);
 644
 645   s = waitpid (-1, NULL, 0);
 646
 647   pthread_cleanup_pop (0);
 648
 649   printf ("%s: waitpid returns with %d (%s)\n", __FUNCTION__, s,
 650           strerror (errno));
 651
 652   exit (1);
 653 }
 654
 655
 656 static void *
 657 tf_waitid (void *arg)
 658 {
 659   pid_t pid = fork ();
 660   if (pid == -1)
 661     {
 662       puts ("fork failed");
 663       exit (1);
 664     }
 665
 666   if (pid == 0)
 667     {
 668       /* Make the program disappear after a while.  */
 669       if (arg == NULL)
 670         sleep (10);
 671       exit (0);
 672     }
 673
 674   int r;
 675   if (arg != NULL)
 676     {
 677       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 678       while (nanosleep (&ts, &ts) != 0)
 679         continue;
 680
 681       r = pthread_barrier_wait (&b2);
 682       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 683         {
 684           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 685           exit (1);
 686         }
 687     }
 688
 689   r = pthread_barrier_wait (&b2);
 690   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 691     {
 692       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 693       exit (1);
 694     }
 695
 696   int s;
 697   pthread_cleanup_push (cl, NULL);
 698
 699 #ifndef WEXITED
 700 # define WEXITED 0
 701 #endif
 702   siginfo_t si;
 703   s = waitid (P_PID, pid, &si, WEXITED);
 704
 705   pthread_cleanup_pop (0);
 706
 707   printf ("%s: waitid returns with %d (%s)\n", __FUNCTION__, s,
 708           strerror (errno));
 709
 710   exit (1);
 711 }
 712
 713
 714 static void *
 715 tf_sigpause (void *arg)
 716 {
 717   int r = pthread_barrier_wait (&b2);
 718   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 719     {
 720       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 721       exit (1);
 722     }
 723
 724   if (arg != NULL)
 725     {
 726       r = pthread_barrier_wait (&b2);
 727       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 728         {
 729           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 730           exit (1);
 731         }
 732     }
 733
 734   pthread_cleanup_push (cl, NULL);
 735
 736   sigpause (sigmask (SIGINT));
 737
 738   pthread_cleanup_pop (0);
 739
 740   printf ("%s: sigpause returned\n", __FUNCTION__);
 741
 742   exit (1);
 743 }
 744
 745
 746 static void *
 747 tf_sigsuspend (void *arg)
 748 {
 749   int r = pthread_barrier_wait (&b2);
 750   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 751     {
 752       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 753       exit (1);
 754     }
 755
 756   if (arg != NULL)
 757     {
 758       r = pthread_barrier_wait (&b2);
 759       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 760         {
 761           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 762           exit (1);
 763         }
 764     }
 765
 766   pthread_cleanup_push (cl, NULL);
 767
 768   /* Just for fun block all signals.  */
 769   sigset_t mask;
 770   sigfillset (&mask);
 771   sigsuspend (&mask);
 772
 773   pthread_cleanup_pop (0);
 774
 775   printf ("%s: sigsuspend returned\n", __FUNCTION__);
 776
 777   exit (1);
 778 }
 779
 780
 781 static void *
 782 tf_sigwait (void *arg)
 783 {
 784   int r = pthread_barrier_wait (&b2);
 785   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 786     {
 787       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 788       exit (1);
 789     }
 790
 791   if (arg != NULL)
 792     {
 793       r = pthread_barrier_wait (&b2);
 794       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 795         {
 796           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 797           exit (1);
 798         }
 799     }
 800
 801   /* Block SIGUSR1.  */
 802   sigset_t mask;
 803   sigemptyset (&mask);
 804   sigaddset (&mask, SIGUSR1);
 805   if (pthread_sigmask (SIG_BLOCK, &mask, NULL) != 0)
 806     {
 807       printf ("%s: pthread_sigmask failed\n", __FUNCTION__);
 808       exit (1);
 809     }
 810
 811   int sig;
 812   pthread_cleanup_push (cl, NULL);
 813
 814   /* Wait for SIGUSR1.  */
 815   sigwait (&mask, &sig);
 816
 817   pthread_cleanup_pop (0);
 818
 819   printf ("%s: sigwait returned with signal %d\n", __FUNCTION__, sig);
 820
 821   exit (1);
 822 }
 823
 824
 825 static void *
 826 tf_sigwaitinfo (void *arg)
 827 {
 828   int r = pthread_barrier_wait (&b2);
 829   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 830     {
 831       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 832       exit (1);
 833     }
 834
 835   if (arg != NULL)
 836     {
 837       r = pthread_barrier_wait (&b2);
 838       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 839         {
 840           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 841           exit (1);
 842         }
 843     }
 844
 845   /* Block SIGUSR1.  */
 846   sigset_t mask;
 847   sigemptyset (&mask);
 848   sigaddset (&mask, SIGUSR1);
 849   if (pthread_sigmask (SIG_BLOCK, &mask, NULL) != 0)
 850     {
 851       printf ("%s: pthread_sigmask failed\n", __FUNCTION__);
 852       exit (1);
 853     }
 854
 855   siginfo_t info;
 856   pthread_cleanup_push (cl, NULL);
 857
 858   /* Wait for SIGUSR1.  */
 859   sigwaitinfo (&mask, &info);
 860
 861   pthread_cleanup_pop (0);
 862
 863   printf ("%s: sigwaitinfo returned with signal %d\n", __FUNCTION__,
 864           info.si_signo);
 865
 866   exit (1);
 867 }
 868
 869
 870 static void *
 871 tf_sigtimedwait (void *arg)
 872 {
 873   int r = pthread_barrier_wait (&b2);
 874   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 875     {
 876       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 877       exit (1);
 878     }
 879
 880   if (arg != NULL)
 881     {
 882       r = pthread_barrier_wait (&b2);
 883       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 884         {
 885           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 886           exit (1);
 887         }
 888     }
 889
 890   /* Block SIGUSR1.  */
 891   sigset_t mask;
 892   sigemptyset (&mask);
 893   sigaddset (&mask, SIGUSR1);
 894   if (pthread_sigmask (SIG_BLOCK, &mask, NULL) != 0)
 895     {
 896       printf ("%s: pthread_sigmask failed\n", __FUNCTION__);
 897       exit (1);
 898     }
 899
 900   /* Wait for SIGUSR1.  */
 901   siginfo_t info;
 902   struct timespec ts = { .tv_sec = 60, .tv_nsec = 0 };
 903   pthread_cleanup_push (cl, NULL);
 904
 905   sigtimedwait (&mask, &info, &ts);
 906
 907   pthread_cleanup_pop (0);
 908
 909   printf ("%s: sigtimedwait returned with signal %d\n", __FUNCTION__,
 910           info.si_signo);
 911
 912   exit (1);
 913 }
 914
 915
 916 static void *
 917 tf_pause (void *arg)
 918 {
 919   int r = pthread_barrier_wait (&b2);
 920   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 921     {
 922       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 923       exit (1);
 924     }
 925
 926   if (arg != NULL)
 927     {
 928       r = pthread_barrier_wait (&b2);
 929       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 930         {
 931           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 932           exit (1);
 933         }
 934     }
 935
 936   pthread_cleanup_push (cl, NULL);
 937
 938   pause ();
 939
 940   pthread_cleanup_pop (0);
 941
 942   printf ("%s: pause returned\n", __FUNCTION__);
 943
 944   exit (1);
 945 }
 946
 947
 948 static void *
 949 tf_accept (void *arg)
 950 {
 951   struct sockaddr_un sun;
 952   /* To test a non-blocking accept call we make the call file by using
 953      a datagrame socket.  */
 954   int pf = arg == NULL ? SOCK_STREAM : SOCK_DGRAM;
 955
 956   tempfd = socket (AF_UNIX, pf, 0);
 957   if (tempfd == -1)
 958     {
 959       printf ("%s: socket call failed\n", __FUNCTION__);
 960       exit (1);
 961     }
 962
 963   int tries = 0;
 964   do
 965     {
 966       if (++tries > 10)
 967         {
 968           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
 969         }
 970
 971       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-1-XXXXXX");
 972       if (mktemp (sun.sun_path) == NULL)
 973         {
 974           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
 975           exit (1);
 976         }
 977
 978       sun.sun_family = AF_UNIX;
 979     }
 980   while (bind (tempfd, (struct sockaddr *) &sun,
 981                offsetof (struct sockaddr_un, sun_path)
 982                + strlen (sun.sun_path) + 1) != 0);
 983
 984   unlink (sun.sun_path);
 985
 986   listen (tempfd, 5);
 987
 988   socklen_t len = sizeof (sun);
 989
 990   int r = pthread_barrier_wait (&b2);
 991   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 992     {
 993       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 994       exit (1);
 995     }
 996
 997   if (arg != NULL)
 998     {
 999       r = pthread_barrier_wait (&b2);
1000       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1001         {
1002           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1003           exit (1);
1004         }
1005     }
1006
1007   pthread_cleanup_push (cl, NULL);
1008
1009   accept (tempfd, (struct sockaddr *) &sun, &len);
1010
1011   pthread_cleanup_pop (0);
1012
1013   printf ("%s: accept returned\n", __FUNCTION__);
1014
1015   exit (1);
1016 }
1017
1018
1019 static void *
1020 tf_send (void *arg)
1021 {
1022   struct sockaddr_un sun;
1023
1024   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1025   if (tempfd == -1)
1026     {
1027       printf ("%s: first socket call failed\n", __FUNCTION__);
1028       exit (1);
1029     }
1030
1031   int tries = 0;
1032   do
1033     {
1034       if (++tries > 10)
1035         {
1036           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1037         }
1038
1039       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
1040       if (mktemp (sun.sun_path) == NULL)
1041         {
1042           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1043           exit (1);
1044         }
1045
1046       sun.sun_family = AF_UNIX;
1047     }
1048   while (bind (tempfd, (struct sockaddr *) &sun,
1049                offsetof (struct sockaddr_un, sun_path)
1050                + strlen (sun.sun_path) + 1) != 0);
1051
1052   listen (tempfd, 5);
1053
1054   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1055   if (tempfd2 == -1)
1056     {
1057       printf ("%s: second socket call failed\n", __FUNCTION__);
1058       exit (1);
1059     }
1060
1061   if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
1062     {
1063       printf ("%s: connect failed\n", __FUNCTION__);
1064       exit(1);
1065     }
1066
1067   unlink (sun.sun_path);
1068
1069   int r = pthread_barrier_wait (&b2);
1070   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1071     {
1072       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1073       exit (1);
1074     }
1075
1076   if (arg != NULL)
1077     {
1078       r = pthread_barrier_wait (&b2);
1079       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1080         {
1081           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1082           exit (1);
1083         }
1084     }
1085
1086   pthread_cleanup_push (cl, NULL);
1087
1088   /* Very large block, so that the send call blocks.  */
1089   char mem[700000];
1090
1091   send (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0);
1092
1093   pthread_cleanup_pop (0);
1094
1095   printf ("%s: send returned\n", __FUNCTION__);
1096
1097   exit (1);
1098 }
1099
1100
1101 static void *
1102 tf_recv (void *arg)
1103 {
1104   struct sockaddr_un sun;
1105
1106   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1107   if (tempfd == -1)
1108     {
1109       printf ("%s: first socket call failed\n", __FUNCTION__);
1110       exit (1);
1111     }
1112
1113   int tries = 0;
1114   do
1115     {
1116       if (++tries > 10)
1117         {
1118           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1119         }
1120
1121       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-3-XXXXXX");
1122       if (mktemp (sun.sun_path) == NULL)
1123         {
1124           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1125           exit (1);
1126         }
1127
1128       sun.sun_family = AF_UNIX;
1129     }
1130   while (bind (tempfd, (struct sockaddr *) &sun,
1131                offsetof (struct sockaddr_un, sun_path)
1132                + strlen (sun.sun_path) + 1) != 0);
1133
1134   listen (tempfd, 5);
1135
1136   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1137   if (tempfd2 == -1)
1138     {
1139       printf ("%s: second socket call failed\n", __FUNCTION__);
1140       exit (1);
1141     }
1142
1143   if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
1144     {
1145       printf ("%s: connect failed\n", __FUNCTION__);
1146       exit(1);
1147     }
1148
1149   unlink (sun.sun_path);
1150
1151   int r = pthread_barrier_wait (&b2);
1152   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1153     {
1154       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1155       exit (1);
1156     }
1157
1158   if (arg != NULL)
1159     {
1160       r = pthread_barrier_wait (&b2);
1161       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1162         {
1163           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1164           exit (1);
1165         }
1166     }
1167
1168   pthread_cleanup_push (cl, NULL);
1169
1170   char mem[70];
1171
1172   recv (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0);
1173
1174   pthread_cleanup_pop (0);
1175
1176   printf ("%s: recv returned\n", __FUNCTION__);
1177
1178   exit (1);
1179 }
1180
1181
1182 static void *
1183 tf_recvfrom (void *arg)
1184 {
1185   struct sockaddr_un sun;
1186
1187   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
1188   if (tempfd == -1)
1189     {
1190       printf ("%s: first socket call failed\n", __FUNCTION__);
1191       exit (1);
1192     }
1193
1194   int tries = 0;
1195   do
1196     {
1197       if (++tries > 10)
1198         {
1199           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1200         }
1201
1202       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-4-XXXXXX");
1203       if (mktemp (sun.sun_path) == NULL)
1204         {
1205           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1206           exit (1);
1207         }
1208
1209       sun.sun_family = AF_UNIX;
1210     }
1211   while (bind (tempfd, (struct sockaddr *) &sun,
1212                offsetof (struct sockaddr_un, sun_path)
1213                + strlen (sun.sun_path) + 1) != 0);
1214
1215   tempfname = strdup (sun.sun_path);
1216
1217   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
1218   if (tempfd2 == -1)
1219     {
1220       printf ("%s: second socket call failed\n", __FUNCTION__);
1221       exit (1);
1222     }
1223
1224   int r = pthread_barrier_wait (&b2);
1225   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1226     {
1227       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1228       exit (1);
1229     }
1230
1231   if (arg != NULL)
1232     {
1233       r = pthread_barrier_wait (&b2);
1234       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1235         {
1236           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1237           exit (1);
1238         }
1239     }
1240
1241   pthread_cleanup_push (cl, NULL);
1242
1243   char mem[70];
1244   socklen_t len = sizeof (sun);
1245
1246   recvfrom (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0,
1247             (struct sockaddr *) &sun, &len);
1248
1249   pthread_cleanup_pop (0);
1250
1251   printf ("%s: recvfrom returned\n", __FUNCTION__);
1252
1253   exit (1);
1254 }
1255
1256
1257 static void *
1258 tf_recvmsg (void *arg)
1259 {
1260   struct sockaddr_un sun;
1261
1262   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
1263   if (tempfd == -1)
1264     {
1265       printf ("%s: first socket call failed\n", __FUNCTION__);
1266       exit (1);
1267     }
1268
1269   int tries = 0;
1270   do
1271     {
1272       if (++tries > 10)
1273         {
1274           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1275         }
1276
1277       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-5-XXXXXX");
1278       if (mktemp (sun.sun_path) == NULL)
1279         {
1280           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1281           exit (1);
1282         }
1283
1284       sun.sun_family = AF_UNIX;
1285     }
1286   while (bind (tempfd, (struct sockaddr *) &sun,
1287                offsetof (struct sockaddr_un, sun_path)
1288                + strlen (sun.sun_path) + 1) != 0);
1289
1290   tempfname = strdup (sun.sun_path);
1291
1292   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
1293   if (tempfd2 == -1)
1294     {
1295       printf ("%s: second socket call failed\n", __FUNCTION__);
1296       exit (1);
1297     }
1298
1299   int r = pthread_barrier_wait (&b2);
1300   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1301     {
1302       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1303       exit (1);
1304     }
1305
1306   if (arg != NULL)
1307     {
1308       r = pthread_barrier_wait (&b2);
1309       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1310         {
1311           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1312           exit (1);
1313         }
1314     }
1315
1316   pthread_cleanup_push (cl, NULL);
1317
1318   char mem[70];
1319   struct iovec iov[1];
1320   iov[0].iov_base = mem;
1321   iov[0].iov_len = arg == NULL ? sizeof (mem) : 0;
1322
1323   struct msghdr m;
1324   m.msg_name = &sun;
1325   m.msg_namelen = sizeof (sun);
1326   m.msg_iov = iov;
1327   m.msg_iovlen = 1;
1328   m.msg_control = NULL;
1329   m.msg_controllen = 0;
1330
1331   recvmsg (tempfd2, &m, 0);
1332
1333   pthread_cleanup_pop (0);
1334
1335   printf ("%s: recvmsg returned\n", __FUNCTION__);
1336
1337   exit (1);
1338 }
1339
1340 static void *
1341 tf_open (void *arg)
1342 {
1343   if (arg == NULL)
1344     {
1345       fifofd = mkfifo (fifoname, S_IWUSR | S_IRUSR);
1346       if (fifofd == -1)
1347         {
1348           printf ("%s: mkfifo failed: %m\n", __func__);
1349           exit (1);
1350         }
1351     }
1352   else
1353     {
1354       int r = pthread_barrier_wait (&b2);
1355       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1356         {
1357           printf ("%s: barrier_wait failed: %m\n", __func__);
1358           exit (1);
1359         }
1360     }
1361
1362   int r = pthread_barrier_wait (&b2);
1363   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1364     {
1365       printf ("%s: 2nd barrier_wait failed: %m\n", __func__);
1366       exit (1);
1367     }
1368
1369   pthread_cleanup_push (cl_fifo, NULL);
1370
1371   open (arg ? "Makefile" : fifoname, O_RDONLY);
1372
1373   pthread_cleanup_pop (0);
1374
1375   printf ("%s: open returned\n", __FUNCTION__);
1376
1377   exit (1);
1378 }
1379
1380
1381 static void *
1382 tf_close (void *arg)
1383 {
1384   if (arg == NULL)
1385     // XXX If somebody can provide a portable test case in which close()
1386     // blocks we can enable this test to run in both rounds.
1387     abort ();
1388
1389   char fname[] = "/tmp/tst-cancel-fd-XXXXXX";
1390   tempfd = mkstemp (fname);
1391   if (tempfd == -1)
1392     {
1393       printf ("%s: mkstemp failed\n", __FUNCTION__);
1394       exit (1);
1395     }
1396   unlink (fname);
1397
1398   int r = pthread_barrier_wait (&b2);
1399   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1400     {
1401       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1402       exit (1);
1403     }
1404
1405   r = pthread_barrier_wait (&b2);
1406   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1407     {
1408       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1409       exit (1);
1410     }
1411
1412   pthread_cleanup_push (cl, NULL);
1413
1414   close (tempfd);
1415
1416   pthread_cleanup_pop (0);
1417
1418   printf ("%s: close returned\n", __FUNCTION__);
1419
1420   exit (1);
1421 }
1422
1423
1424 static void *
1425 tf_pread (void *arg)
1426 {
1427   if (arg == NULL)
1428     // XXX If somebody can provide a portable test case in which pread()
1429     // blocks we can enable this test to run in both rounds.
1430     abort ();
1431
1432   tempfd = open ("Makefile", O_RDONLY);
1433   if (tempfd == -1)
1434     {
1435       printf ("%s: cannot open Makefile\n", __FUNCTION__);
1436       exit (1);
1437     }
1438
1439   int r = pthread_barrier_wait (&b2);
1440   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1441     {
1442       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1443       exit (1);
1444     }
1445
1446   r = pthread_barrier_wait (&b2);
1447   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1448     {
1449       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1450       exit (1);
1451     }
1452
1453   pthread_cleanup_push (cl, NULL);
1454
1455   char mem[10];
1456   pread (tempfd, mem, sizeof (mem), 0);
1457
1458   pthread_cleanup_pop (0);
1459
1460   printf ("%s: pread returned\n", __FUNCTION__);
1461
1462   exit (1);
1463 }
1464
1465
1466 static void *
1467 tf_pwrite (void *arg)
1468 {
1469   if (arg == NULL)
1470     // XXX If somebody can provide a portable test case in which pwrite()
1471     // blocks we can enable this test to run in both rounds.
1472     abort ();
1473
1474   char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1475   tempfd = mkstemp (fname);
1476   if (tempfd == -1)
1477     {
1478       printf ("%s: mkstemp failed\n", __FUNCTION__);
1479       exit (1);
1480     }
1481   unlink (fname);
1482
1483   int r = pthread_barrier_wait (&b2);
1484   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1485     {
1486       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1487       exit (1);
1488     }
1489
1490   r = pthread_barrier_wait (&b2);
1491   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1492     {
1493       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1494       exit (1);
1495     }
1496
1497   pthread_cleanup_push (cl, NULL);
1498
1499   char mem[10];
1500   pwrite (tempfd, mem, sizeof (mem), 0);
1501
1502   pthread_cleanup_pop (0);
1503
1504   printf ("%s: pwrite returned\n", __FUNCTION__);
1505
1506   exit (1);
1507 }
1508
1509 static void *
1510 tf_preadv (void *arg)
1511 {
1512   int fd;
1513   int r;
1514
1515   if (arg == NULL)
1516     /* XXX If somebody can provide a portable test case in which preadv
1517        blocks we can enable this test to run in both rounds.  */
1518     abort ();
1519
1520   char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1521   tempfd = fd = mkstemp (fname);
1522   if (fd == -1)
1523     printf ("%s: mkstemp failed\n", __FUNCTION__);
1524   unlink (fname);
1525
1526   r = pthread_barrier_wait (&b2);
1527   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1528     {
1529       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1530       exit (1);
1531     }
1532
1533   r = pthread_barrier_wait (&b2);
1534   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1535     {
1536       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1537       exit (1);
1538     }
1539
1540   ssize_t s;
1541   pthread_cleanup_push (cl, NULL);
1542
1543   char buf[100];
1544   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1545   s = preadv (fd, iov, 1, 0);
1546
1547   pthread_cleanup_pop (0);
1548
1549   printf ("%s: preadv returns with %zd\n", __FUNCTION__, s);
1550
1551   exit (1);
1552 }
1553
1554 static void *
1555 tf_pwritev (void *arg)
1556 {
1557   int fd;
1558   int r;
1559
1560   if (arg == NULL)
1561     /* XXX If somebody can provide a portable test case in which pwritev
1562        blocks we can enable this test to run in both rounds.  */
1563     abort ();
1564
1565   char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
1566   tempfd = fd = mkstemp (fname);
1567   if (fd == -1)
1568     printf ("%s: mkstemp failed\n", __FUNCTION__);
1569   unlink (fname);
1570
1571   r = pthread_barrier_wait (&b2);
1572   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1573     {
1574       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1575       exit (1);
1576     }
1577
1578   r = pthread_barrier_wait (&b2);
1579   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1580     {
1581       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1582       exit (1);
1583     }
1584
1585   ssize_t s;
1586   pthread_cleanup_push (cl, NULL);
1587
1588   char buf[WRITE_BUFFER_SIZE];
1589   memset (buf, '\0', sizeof (buf));
1590   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
1591   s = pwritev (fd, iov, 1, 0);
1592
1593   pthread_cleanup_pop (0);
1594
1595   printf ("%s: pwritev returns with %zd\n", __FUNCTION__, s);
1596
1597   exit (1);
1598 }
1599
1600 static void *
1601 tf_fsync (void *arg)
1602 {
1603   if (arg == NULL)
1604     // XXX If somebody can provide a portable test case in which fsync()
1605     // blocks we can enable this test to run in both rounds.
1606     abort ();
1607
1608   tempfd = open ("Makefile", O_RDONLY);
1609   if (tempfd == -1)
1610     {
1611       printf ("%s: cannot open Makefile\n", __FUNCTION__);
1612       exit (1);
1613     }
1614
1615   int r = pthread_barrier_wait (&b2);
1616   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1617     {
1618       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1619       exit (1);
1620     }
1621
1622   r = pthread_barrier_wait (&b2);
1623   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1624     {
1625       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1626       exit (1);
1627     }
1628
1629   pthread_cleanup_push (cl, NULL);
1630
1631   fsync (tempfd);
1632
1633   pthread_cleanup_pop (0);
1634
1635   printf ("%s: fsync returned\n", __FUNCTION__);
1636
1637   exit (1);
1638 }
1639
1640
1641 static void *
1642 tf_fdatasync (void *arg)
1643 {
1644   if (arg == NULL)
1645     // XXX If somebody can provide a portable test case in which fdatasync()
1646     // blocks we can enable this test to run in both rounds.
1647     abort ();
1648
1649   tempfd = open ("Makefile", O_RDONLY);
1650   if (tempfd == -1)
1651     {
1652       printf ("%s: cannot open Makefile\n", __FUNCTION__);
1653       exit (1);
1654     }
1655
1656   int r = pthread_barrier_wait (&b2);
1657   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1658     {
1659       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1660       exit (1);
1661     }
1662
1663   r = pthread_barrier_wait (&b2);
1664   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1665     {
1666       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1667       exit (1);
1668     }
1669
1670   pthread_cleanup_push (cl, NULL);
1671
1672   fdatasync (tempfd);
1673
1674   pthread_cleanup_pop (0);
1675
1676   printf ("%s: fdatasync returned\n", __FUNCTION__);
1677
1678   exit (1);
1679 }
1680
1681
1682 static void *
1683 tf_msync (void *arg)
1684 {
1685   if (arg == NULL)
1686     // XXX If somebody can provide a portable test case in which msync()
1687     // blocks we can enable this test to run in both rounds.
1688     abort ();
1689
1690   tempfd = open ("Makefile", O_RDONLY);
1691   if (tempfd == -1)
1692     {
1693       printf ("%s: cannot open Makefile\n", __FUNCTION__);
1694       exit (1);
1695     }
1696   void *p = mmap (NULL, 10, PROT_READ, MAP_SHARED, tempfd, 0);
1697   if (p == MAP_FAILED)
1698     {
1699       printf ("%s: mmap failed\n", __FUNCTION__);
1700       exit (1);
1701     }
1702
1703   int r = pthread_barrier_wait (&b2);
1704   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1705     {
1706       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1707       exit (1);
1708     }
1709
1710   r = pthread_barrier_wait (&b2);
1711   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1712     {
1713       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1714       exit (1);
1715     }
1716
1717   pthread_cleanup_push (cl, NULL);
1718
1719   msync (p, 10, 0);
1720
1721   pthread_cleanup_pop (0);
1722
1723   printf ("%s: msync returned\n", __FUNCTION__);
1724
1725   exit (1);
1726 }
1727
1728
1729 static void *
1730 tf_sendto (void *arg)
1731 {
1732   if (arg == NULL)
1733     // XXX If somebody can provide a portable test case in which sendto()
1734     // blocks we can enable this test to run in both rounds.
1735     abort ();
1736
1737   struct sockaddr_un sun;
1738
1739   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
1740   if (tempfd == -1)
1741     {
1742       printf ("%s: first socket call failed\n", __FUNCTION__);
1743       exit (1);
1744     }
1745
1746   int tries = 0;
1747   do
1748     {
1749       if (++tries > 10)
1750         {
1751           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1752         }
1753
1754       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-6-XXXXXX");
1755       if (mktemp (sun.sun_path) == NULL)
1756         {
1757           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1758           exit (1);
1759         }
1760
1761       sun.sun_family = AF_UNIX;
1762     }
1763   while (bind (tempfd, (struct sockaddr *) &sun,
1764                offsetof (struct sockaddr_un, sun_path)
1765                + strlen (sun.sun_path) + 1) != 0);
1766   tempfname = strdup (sun.sun_path);
1767
1768   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
1769   if (tempfd2 == -1)
1770     {
1771       printf ("%s: second socket call failed\n", __FUNCTION__);
1772       exit (1);
1773     }
1774
1775   int r = pthread_barrier_wait (&b2);
1776   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1777     {
1778       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1779       exit (1);
1780     }
1781
1782   r = pthread_barrier_wait (&b2);
1783   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1784     {
1785       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1786       exit (1);
1787     }
1788
1789   pthread_cleanup_push (cl, NULL);
1790
1791   char mem[1];
1792
1793   sendto (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0,
1794           (struct sockaddr *) &sun,
1795           offsetof (struct sockaddr_un, sun_path) + strlen (sun.sun_path) + 1);
1796
1797   pthread_cleanup_pop (0);
1798
1799   printf ("%s: sendto returned\n", __FUNCTION__);
1800
1801   exit (1);
1802 }
1803
1804
1805 static void *
1806 tf_sendmsg (void *arg)
1807 {
1808   if (arg == NULL)
1809     // XXX If somebody can provide a portable test case in which sendmsg()
1810     // blocks we can enable this test to run in both rounds.
1811     abort ();
1812
1813   struct sockaddr_un sun;
1814
1815   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
1816   if (tempfd == -1)
1817     {
1818       printf ("%s: first socket call failed\n", __FUNCTION__);
1819       exit (1);
1820     }
1821
1822   int tries = 0;
1823   do
1824     {
1825       if (++tries > 10)
1826         {
1827           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1828         }
1829
1830       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-7-XXXXXX");
1831       if (mktemp (sun.sun_path) == NULL)
1832         {
1833           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1834           exit (1);
1835         }
1836
1837       sun.sun_family = AF_UNIX;
1838     }
1839   while (bind (tempfd, (struct sockaddr *) &sun,
1840                offsetof (struct sockaddr_un, sun_path)
1841                + strlen (sun.sun_path) + 1) != 0);
1842   tempfname = strdup (sun.sun_path);
1843
1844   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
1845   if (tempfd2 == -1)
1846     {
1847       printf ("%s: second socket call failed\n", __FUNCTION__);
1848       exit (1);
1849     }
1850
1851   int r = pthread_barrier_wait (&b2);
1852   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1853     {
1854       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1855       exit (1);
1856     }
1857
1858   r = pthread_barrier_wait (&b2);
1859   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1860     {
1861       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1862       exit (1);
1863     }
1864
1865   pthread_cleanup_push (cl, NULL);
1866
1867   char mem[1];
1868   struct iovec iov[1];
1869   iov[0].iov_base = mem;
1870   iov[0].iov_len = 1;
1871
1872   struct msghdr m;
1873   m.msg_name = &sun;
1874   m.msg_namelen = (offsetof (struct sockaddr_un, sun_path)
1875                    + strlen (sun.sun_path) + 1);
1876   m.msg_iov = iov;
1877   m.msg_iovlen = 1;
1878   m.msg_control = NULL;
1879   m.msg_controllen = 0;
1880
1881   sendmsg (tempfd2, &m, 0);
1882
1883   pthread_cleanup_pop (0);
1884
1885   printf ("%s: sendmsg returned\n", __FUNCTION__);
1886
1887   exit (1);
1888 }
1889
1890
1891 static void *
1892 tf_creat (void *arg)
1893 {
1894   if (arg == NULL)
1895     // XXX If somebody can provide a portable test case in which sendmsg()
1896     // blocks we can enable this test to run in both rounds.
1897     abort ();
1898
1899   int r = pthread_barrier_wait (&b2);
1900   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1901     {
1902       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1903       exit (1);
1904     }
1905
1906   r = pthread_barrier_wait (&b2);
1907   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1908     {
1909       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1910       exit (1);
1911     }
1912
1913   pthread_cleanup_push (cl, NULL);
1914
1915   creat ("tmp/tst-cancel-4-should-not-exist", 0666);
1916
1917   pthread_cleanup_pop (0);
1918
1919   printf ("%s: creat returned\n", __FUNCTION__);
1920
1921   exit (1);
1922 }
1923
1924
1925 static void *
1926 tf_connect (void *arg)
1927 {
1928   if (arg == NULL)
1929     // XXX If somebody can provide a portable test case in which connect()
1930     // blocks we can enable this test to run in both rounds.
1931     abort ();
1932
1933   struct sockaddr_un sun;
1934
1935   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1936   if (tempfd == -1)
1937     {
1938       printf ("%s: first socket call failed\n", __FUNCTION__);
1939       exit (1);
1940     }
1941
1942   int tries = 0;
1943   do
1944     {
1945       if (++tries > 10)
1946         {
1947           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1948         }
1949
1950       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
1951       if (mktemp (sun.sun_path) == NULL)
1952         {
1953           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1954           exit (1);
1955         }
1956
1957       sun.sun_family = AF_UNIX;
1958     }
1959   while (bind (tempfd, (struct sockaddr *) &sun,
1960                offsetof (struct sockaddr_un, sun_path)
1961                + strlen (sun.sun_path) + 1) != 0);
1962   tempfname = strdup (sun.sun_path);
1963
1964   listen (tempfd, 5);
1965
1966   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1967   if (tempfd2 == -1)
1968     {
1969       printf ("%s: second socket call failed\n", __FUNCTION__);
1970       exit (1);
1971     }
1972
1973   int r = pthread_barrier_wait (&b2);
1974   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1975     {
1976       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1977       exit (1);
1978     }
1979
1980   if (arg != NULL)
1981     {
1982       r = pthread_barrier_wait (&b2);
1983       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1984         {
1985           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1986           exit (1);
1987         }
1988     }
1989
1990   pthread_cleanup_push (cl, NULL);
1991
1992   connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun));
1993
1994   pthread_cleanup_pop (0);
1995
1996   printf ("%s: connect returned\n", __FUNCTION__);
1997
1998   exit (1);
1999 }
2000
2001
2002 static void *
2003 tf_tcdrain (void *arg)
2004 {
2005   if (arg == NULL)
2006     // XXX If somebody can provide a portable test case in which tcdrain()
2007     // blocks we can enable this test to run in both rounds.
2008     abort ();
2009
2010   int r = pthread_barrier_wait (&b2);
2011   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
2012     {
2013       printf ("%s: barrier_wait failed\n", __FUNCTION__);
2014       exit (1);
2015     }
2016
2017   if (arg != NULL)
2018     {
2019       r = pthread_barrier_wait (&b2);
2020       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
2021         {
2022           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
2023           exit (1);
2024         }
2025     }
2026
2027   pthread_cleanup_push (cl, NULL);
2028
2029   /* Regardless of stderr being a terminal, the tcdrain call should be
2030      canceled.  */
2031   tcdrain (STDERR_FILENO);
2032
2033   pthread_cleanup_pop (0);
2034
2035   printf ("%s: tcdrain returned\n", __FUNCTION__);
2036
2037   exit (1);
2038 }
2039
2040
2041 static void *
2042 tf_msgrcv (void *arg)
2043 {
2044   tempmsg = msgget (IPC_PRIVATE, 0666 | IPC_CREAT);
2045   if (tempmsg == -1)
2046     {
2047       printf ("%s: msgget failed: %s\n", __FUNCTION__, strerror (errno));
2048       exit (1);
2049     }
2050
2051   int r = pthread_barrier_wait (&b2);
2052   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
2053     {
2054       printf ("%s: barrier_wait failed\n", __FUNCTION__);
2055       exit (1);
2056     }
2057
2058   if (arg != NULL)
2059     {
2060       r = pthread_barrier_wait (&b2);
2061       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
2062         {
2063           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
2064           exit (1);
2065         }
2066     }
2067
2068   ssize_t s;
2069
2070   pthread_cleanup_push (cl, NULL);
2071
2072   struct
2073   {
2074     long int type;
2075     char mem[10];
2076   } m;
2077   int randnr;
2078   /* We need a positive random number.  */
2079   do
2080     randnr = random () % 64000;
2081   while (randnr <= 0);
2082   do
2083     {
2084       errno = 0;
2085       s = msgrcv (tempmsg, (struct msgbuf *) &m, 10, randnr, 0);
2086     }
2087   while (errno == EIDRM || errno == EINTR);
2088
2089   pthread_cleanup_pop (0);
2090
2091   printf ("%s: msgrcv returned %zd with errno = %m\n", __FUNCTION__, s);
2092
2093   msgctl (tempmsg, IPC_RMID, NULL);
2094
2095   exit (1);
2096 }
2097
2098
2099 static void *
2100 tf_msgsnd (void *arg)
2101 {
2102   if (arg == NULL)
2103     // XXX If somebody can provide a portable test case in which msgsnd()
2104     // blocks we can enable this test to run in both rounds.
2105     abort ();
2106
2107   tempmsg = msgget (IPC_PRIVATE, 0666 | IPC_CREAT);
2108   if (tempmsg == -1)
2109     {
2110       printf ("%s: msgget failed: %s\n", __FUNCTION__, strerror (errno));
2111       exit (1);
2112     }
2113
2114   int r = pthread_barrier_wait (&b2);
2115   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
2116     {
2117       printf ("%s: barrier_wait failed\n", __FUNCTION__);
2118       exit (1);
2119     }
2120
2121   r = pthread_barrier_wait (&b2);
2122   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
2123     {
2124       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
2125       exit (1);
2126     }
2127
2128   pthread_cleanup_push (cl, NULL);
2129
2130   struct
2131   {
2132     long int type;
2133     char mem[1];
2134   } m;
2135   /* We need a positive random number.  */
2136   do
2137     m.type = random () % 64000;
2138   while (m.type <= 0);
2139   msgsnd (tempmsg, (struct msgbuf *) &m, sizeof (m.mem), 0);
2140
2141   pthread_cleanup_pop (0);
2142
2143   printf ("%s: msgsnd returned\n", __FUNCTION__);
2144
2145   msgctl (tempmsg, IPC_RMID, NULL);
2146
2147   exit (1);
2148 }
2149
2150
2151 struct cancel_tests tests[] =
2152 {
2153   ADD_TEST (read, 2, 0),
2154   ADD_TEST (readv, 2, 0),
2155   ADD_TEST (select, 2, 0),
2156   ADD_TEST (pselect, 2, 0),
2157   ADD_TEST (poll, 2, 0),
2158   ADD_TEST (ppoll, 2, 0),
2159   ADD_TEST (write, 2, 0),
2160   ADD_TEST (writev, 2, 0),
2161   ADD_TEST (sleep, 2, 0),
2162   ADD_TEST (usleep, 2, 0),
2163   ADD_TEST (nanosleep, 2, 0),
2164   ADD_TEST (wait, 2, 0),
2165   ADD_TEST (waitid, 2, 0),
2166   ADD_TEST (waitpid, 2, 0),
2167   ADD_TEST (sigpause, 2, 0),
2168   ADD_TEST (sigsuspend, 2, 0),
2169   ADD_TEST (sigwait, 2, 0),
2170   ADD_TEST (sigwaitinfo, 2, 0),
2171   ADD_TEST (sigtimedwait, 2, 0),
2172   ADD_TEST (pause, 2, 0),
2173   ADD_TEST (accept, 2, 0),
2174   ADD_TEST (send, 2, 0),
2175   ADD_TEST (recv, 2, 0),
2176   ADD_TEST (recvfrom, 2, 0),
2177   ADD_TEST (recvmsg, 2, 0),
2178   ADD_TEST (preadv, 2, 1),
2179   ADD_TEST (pwritev, 2, 1),
2180   ADD_TEST (open, 2, 1),
2181   ADD_TEST (close, 2, 1),
2182   ADD_TEST (pread, 2, 1),
2183   ADD_TEST (pwrite, 2, 1),
2184   ADD_TEST (fsync, 2, 1),
2185   ADD_TEST (fdatasync, 2, 1),
2186   ADD_TEST (msync, 2, 1),
2187   ADD_TEST (sendto, 2, 1),
2188   ADD_TEST (sendmsg, 2, 1),
2189   ADD_TEST (creat, 2, 1),
2190   ADD_TEST (connect, 2, 1),
2191   ADD_TEST (tcdrain, 2, 1),
2192   ADD_TEST (msgrcv, 2, 0),
2193   ADD_TEST (msgsnd, 2, 1),
2194 };
2195 #define ntest_tf (sizeof (tests) / sizeof (tests[0]))
2196
2197 #include "tst-cancel4-common.c"