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 #include "pthreadP.h"
  40
  41
  42 /* Since STREAMS are not supported in the standard Linux kernel and
  43    there we don't advertise STREAMS as supported is no need to test
  44    the STREAMS related functions.  This affects
  45      getmsg()              getpmsg()          putmsg()
  46      putpmsg()
  47
  48    lockf() and fcntl() are tested in tst-cancel16.
  49
  50    pthread_join() is tested in tst-join5.
  51
  52    pthread_testcancel()'s only purpose is to allow cancellation.  This
  53    is tested in several places.
  54
  55    sem_wait() and sem_timedwait() are checked in tst-cancel1[2345] tests.
  56
  57    mq_send(), mq_timedsend(), mq_receive() and mq_timedreceive() are checked
  58    in tst-mqueue8{,x} tests.
  59
  60    aio_suspend() is tested in tst-cancel17.
  61
  62    clock_nanosleep() is tested in tst-cancel18.
  63
  64    Linux sendmmsg and recvmmsg are checked in tst-cancel4_1.c and
  65    tst-cancel4_2.c respectively.
  66 */
  67
  68 #include "tst-cancel4-common.h"
  69
  70 #ifndef IPC_ADDVAL
  71 # define IPC_ADDVAL 0
  72 #endif
  73
  74
  75 static void *
  76 tf_read  (void *arg)
  77 {
  78   int fd;
  79   int r;
  80
  81   if (arg == NULL)
  82     fd = fds[0];
  83   else
  84     {
  85       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
  86       tempfd = fd = mkstemp (fname);
  87       if (fd == -1)
  88         printf ("%s: mkstemp failed\n", __FUNCTION__);
  89       unlink (fname);
  90
  91       r = pthread_barrier_wait (&b2);
  92       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
  93         {
  94           printf ("%s: barrier_wait failed\n", __FUNCTION__);
  95           exit (1);
  96         }
  97     }
  98
  99   r = pthread_barrier_wait (&b2);
 100   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 101     {
 102       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 103       exit (1);
 104     }
 105
 106   ssize_t s;
 107   pthread_cleanup_push (cl, NULL);
 108
 109   char buf[100];
 110   s = read (fd, buf, sizeof (buf));
 111
 112   pthread_cleanup_pop (0);
 113
 114   printf ("%s: read returns with %zd\n", __FUNCTION__, s);
 115
 116   exit (1);
 117 }
 118
 119
 120 static void *
 121 tf_readv  (void *arg)
 122 {
 123   int fd;
 124   int r;
 125
 126   if (arg == NULL)
 127     fd = fds[0];
 128   else
 129     {
 130       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 131       tempfd = fd = mkstemp (fname);
 132       if (fd == -1)
 133         printf ("%s: mkstemp failed\n", __FUNCTION__);
 134       unlink (fname);
 135
 136       r = pthread_barrier_wait (&b2);
 137       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 138         {
 139           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 140           exit (1);
 141         }
 142     }
 143
 144   r = pthread_barrier_wait (&b2);
 145   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 146     {
 147       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 148       exit (1);
 149     }
 150
 151   ssize_t s;
 152   pthread_cleanup_push (cl, NULL);
 153
 154   char buf[100];
 155   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
 156   s = readv (fd, iov, 1);
 157
 158   pthread_cleanup_pop (0);
 159
 160   printf ("%s: readv returns with %zd\n", __FUNCTION__, s);
 161
 162   exit (1);
 163 }
 164
 165
 166 static void *
 167 tf_write  (void *arg)
 168 {
 169   int fd;
 170   int r;
 171
 172   if (arg == NULL)
 173     fd = fds[1];
 174   else
 175     {
 176       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 177       tempfd = fd = mkstemp (fname);
 178       if (fd == -1)
 179         printf ("%s: mkstemp failed\n", __FUNCTION__);
 180       unlink (fname);
 181
 182       r = pthread_barrier_wait (&b2);
 183       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 184         {
 185           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 186           exit (1);
 187         }
 188     }
 189
 190   r = pthread_barrier_wait (&b2);
 191   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 192     {
 193       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 194       exit (1);
 195     }
 196
 197   ssize_t s;
 198   pthread_cleanup_push (cl, NULL);
 199
 200   char buf[WRITE_BUFFER_SIZE];
 201   memset (buf, '\0', sizeof (buf));
 202   s = write (fd, buf, sizeof (buf));
 203
 204   pthread_cleanup_pop (0);
 205
 206   printf ("%s: write returns with %zd\n", __FUNCTION__, s);
 207
 208   exit (1);
 209 }
 210
 211
 212 static void *
 213 tf_writev  (void *arg)
 214 {
 215   int fd;
 216   int r;
 217
 218   if (arg == NULL)
 219     fd = fds[1];
 220   else
 221     {
 222       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 223       tempfd = fd = mkstemp (fname);
 224       if (fd == -1)
 225         printf ("%s: mkstemp failed\n", __FUNCTION__);
 226       unlink (fname);
 227
 228       r = pthread_barrier_wait (&b2);
 229       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 230         {
 231           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 232           exit (1);
 233         }
 234     }
 235
 236   r = pthread_barrier_wait (&b2);
 237   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 238     {
 239       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 240       exit (1);
 241     }
 242
 243   ssize_t s;
 244   pthread_cleanup_push (cl, NULL);
 245
 246   char buf[WRITE_BUFFER_SIZE];
 247   memset (buf, '\0', sizeof (buf));
 248   struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
 249   s = writev (fd, iov, 1);
 250
 251   pthread_cleanup_pop (0);
 252
 253   printf ("%s: writev returns with %zd\n", __FUNCTION__, s);
 254
 255   exit (1);
 256 }
 257
 258
 259 static void *
 260 tf_sleep (void *arg)
 261 {
 262   int r = pthread_barrier_wait (&b2);
 263   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 264     {
 265       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 266       exit (1);
 267     }
 268
 269   if (arg != NULL)
 270     {
 271       r = pthread_barrier_wait (&b2);
 272       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 273         {
 274           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 275           exit (1);
 276         }
 277     }
 278
 279   pthread_cleanup_push (cl, NULL);
 280
 281   sleep (arg == NULL ? 1000000 : 0);
 282
 283   pthread_cleanup_pop (0);
 284
 285   printf ("%s: sleep returns\n", __FUNCTION__);
 286
 287   exit (1);
 288 }
 289
 290
 291 static void *
 292 tf_usleep (void *arg)
 293 {
 294   int r = pthread_barrier_wait (&b2);
 295   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 296     {
 297       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 298       exit (1);
 299     }
 300
 301   if (arg != NULL)
 302     {
 303       r = pthread_barrier_wait (&b2);
 304       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 305         {
 306           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 307           exit (1);
 308         }
 309     }
 310
 311   pthread_cleanup_push (cl, NULL);
 312
 313   usleep (arg == NULL ? (useconds_t) ULONG_MAX : 0);
 314
 315   pthread_cleanup_pop (0);
 316
 317   printf ("%s: usleep returns\n", __FUNCTION__);
 318
 319   exit (1);
 320 }
 321
 322
 323 static void *
 324 tf_nanosleep (void *arg)
 325 {
 326   int r = pthread_barrier_wait (&b2);
 327   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 328     {
 329       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 330       exit (1);
 331     }
 332
 333   if (arg != NULL)
 334     {
 335       r = pthread_barrier_wait (&b2);
 336       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 337         {
 338           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 339           exit (1);
 340         }
 341     }
 342
 343   pthread_cleanup_push (cl, NULL);
 344
 345   struct timespec ts = { .tv_sec = arg == NULL ? 10000000 : 0, .tv_nsec = 0 };
 346   TEMP_FAILURE_RETRY (nanosleep (&ts, &ts));
 347
 348   pthread_cleanup_pop (0);
 349
 350   printf ("%s: nanosleep returns\n", __FUNCTION__);
 351
 352   exit (1);
 353 }
 354
 355
 356 static void *
 357 tf_select (void *arg)
 358 {
 359   int fd;
 360   int r;
 361
 362   if (arg == NULL)
 363     fd = fds[0];
 364   else
 365     {
 366       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 367       tempfd = fd = mkstemp (fname);
 368       if (fd == -1)
 369         printf ("%s: mkstemp failed\n", __FUNCTION__);
 370       unlink (fname);
 371
 372       r = pthread_barrier_wait (&b2);
 373       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 374         {
 375           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 376           exit (1);
 377         }
 378     }
 379
 380   r = pthread_barrier_wait (&b2);
 381   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 382     {
 383       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 384       exit (1);
 385     }
 386
 387   fd_set rfs;
 388   FD_ZERO (&rfs);
 389   FD_SET (fd, &rfs);
 390
 391   int s;
 392   pthread_cleanup_push (cl, NULL);
 393
 394   s = select (fd + 1, &rfs, NULL, NULL, NULL);
 395
 396   pthread_cleanup_pop (0);
 397
 398   printf ("%s: select returns with %d (%s)\n", __FUNCTION__, s,
 399           strerror (errno));
 400
 401   exit (1);
 402 }
 403
 404
 405 static void *
 406 tf_pselect (void *arg)
 407 {
 408   int fd;
 409   int r;
 410
 411   if (arg == NULL)
 412     fd = fds[0];
 413   else
 414     {
 415       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 416       tempfd = fd = mkstemp (fname);
 417       if (fd == -1)
 418         printf ("%s: mkstemp failed\n", __FUNCTION__);
 419       unlink (fname);
 420
 421       r = pthread_barrier_wait (&b2);
 422       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 423         {
 424           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 425           exit (1);
 426         }
 427     }
 428
 429   r = pthread_barrier_wait (&b2);
 430   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 431     {
 432       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 433       exit (1);
 434     }
 435
 436   fd_set rfs;
 437   FD_ZERO (&rfs);
 438   FD_SET (fd, &rfs);
 439
 440   int s;
 441   pthread_cleanup_push (cl, NULL);
 442
 443   s = pselect (fd + 1, &rfs, NULL, NULL, NULL, NULL);
 444
 445   pthread_cleanup_pop (0);
 446
 447   printf ("%s: pselect returns with %d (%s)\n", __FUNCTION__, s,
 448           strerror (errno));
 449
 450   exit (1);
 451 }
 452
 453
 454 static void *
 455 tf_poll (void *arg)
 456 {
 457   int fd;
 458   int r;
 459
 460   if (arg == NULL)
 461     fd = fds[0];
 462   else
 463     {
 464       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 465       tempfd = fd = mkstemp (fname);
 466       if (fd == -1)
 467         printf ("%s: mkstemp failed\n", __FUNCTION__);
 468       unlink (fname);
 469
 470       r = pthread_barrier_wait (&b2);
 471       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 472         {
 473           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 474           exit (1);
 475         }
 476     }
 477
 478   r = pthread_barrier_wait (&b2);
 479   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 480     {
 481       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 482       exit (1);
 483     }
 484
 485   struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
 486
 487   int s;
 488   pthread_cleanup_push (cl, NULL);
 489
 490   s = poll (rfs, 1, -1);
 491
 492   pthread_cleanup_pop (0);
 493
 494   printf ("%s: poll returns with %d (%s)\n", __FUNCTION__, s,
 495           strerror (errno));
 496
 497   exit (1);
 498 }
 499
 500
 501 static void *
 502 tf_ppoll (void *arg)
 503 {
 504   int fd;
 505   int r;
 506
 507   if (arg == NULL)
 508     fd = fds[0];
 509   else
 510     {
 511       char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
 512       tempfd = fd = mkstemp (fname);
 513       if (fd == -1)
 514         printf ("%s: mkstemp failed\n", __FUNCTION__);
 515       unlink (fname);
 516
 517       r = pthread_barrier_wait (&b2);
 518       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 519         {
 520           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 521           exit (1);
 522         }
 523     }
 524
 525   r = pthread_barrier_wait (&b2);
 526   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 527     {
 528       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 529       exit (1);
 530     }
 531
 532   struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
 533
 534   int s;
 535   pthread_cleanup_push (cl, NULL);
 536
 537   s = ppoll (rfs, 1, NULL, NULL);
 538
 539   pthread_cleanup_pop (0);
 540
 541   printf ("%s: ppoll returns with %d (%s)\n", __FUNCTION__, s,
 542           strerror (errno));
 543
 544   exit (1);
 545 }
 546
 547
 548 static void *
 549 tf_wait (void *arg)
 550 {
 551   pid_t pid = fork ();
 552   if (pid == -1)
 553     {
 554       puts ("fork failed");
 555       exit (1);
 556     }
 557
 558   if (pid == 0)
 559     {
 560       /* Make the program disappear after a while.  */
 561       if (arg == NULL)
 562         sleep (10);
 563       exit (0);
 564     }
 565
 566   int r;
 567   if (arg != NULL)
 568     {
 569       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 570       while (nanosleep (&ts, &ts) != 0)
 571         continue;
 572
 573       r = pthread_barrier_wait (&b2);
 574       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 575         {
 576           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 577           exit (1);
 578         }
 579     }
 580
 581   r = pthread_barrier_wait (&b2);
 582   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 583     {
 584       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 585       exit (1);
 586     }
 587
 588   int s;
 589   pthread_cleanup_push (cl, NULL);
 590
 591   s = wait (NULL);
 592
 593   pthread_cleanup_pop (0);
 594
 595   printf ("%s: wait returns with %d (%s)\n", __FUNCTION__, s,
 596           strerror (errno));
 597
 598   exit (1);
 599 }
 600
 601
 602 static void *
 603 tf_waitpid (void *arg)
 604 {
 605
 606   pid_t pid = fork ();
 607   if (pid == -1)
 608     {
 609       puts ("fork failed");
 610       exit (1);
 611     }
 612
 613   if (pid == 0)
 614     {
 615       /* Make the program disappear after a while.  */
 616       if (arg == NULL)
 617         sleep (10);
 618       exit (0);
 619     }
 620
 621   int r;
 622   if (arg != NULL)
 623     {
 624       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 625       while (nanosleep (&ts, &ts) != 0)
 626         continue;
 627
 628       r = pthread_barrier_wait (&b2);
 629       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 630         {
 631           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 632           exit (1);
 633         }
 634     }
 635
 636   r = pthread_barrier_wait (&b2);
 637   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 638     {
 639       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 640       exit (1);
 641     }
 642
 643   int s;
 644  pthread_cleanup_push (cl, NULL);
 645
 646   s = waitpid (-1, NULL, 0);
 647
 648   pthread_cleanup_pop (0);
 649
 650   printf ("%s: waitpid returns with %d (%s)\n", __FUNCTION__, s,
 651           strerror (errno));
 652
 653   exit (1);
 654 }
 655
 656
 657 static void *
 658 tf_waitid (void *arg)
 659 {
 660   pid_t pid = fork ();
 661   if (pid == -1)
 662     {
 663       puts ("fork failed");
 664       exit (1);
 665     }
 666
 667   if (pid == 0)
 668     {
 669       /* Make the program disappear after a while.  */
 670       if (arg == NULL)
 671         sleep (10);
 672       exit (0);
 673     }
 674
 675   int r;
 676   if (arg != NULL)
 677     {
 678       struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
 679       while (nanosleep (&ts, &ts) != 0)
 680         continue;
 681
 682       r = pthread_barrier_wait (&b2);
 683       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 684         {
 685           printf ("%s: barrier_wait failed\n", __FUNCTION__);
 686           exit (1);
 687         }
 688     }
 689
 690   r = pthread_barrier_wait (&b2);
 691   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 692     {
 693       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 694       exit (1);
 695     }
 696
 697   int s;
 698   pthread_cleanup_push (cl, NULL);
 699
 700 #ifndef WEXITED
 701 # define WEXITED 0
 702 #endif
 703   siginfo_t si;
 704   s = waitid (P_PID, pid, &si, WEXITED);
 705
 706   pthread_cleanup_pop (0);
 707
 708   printf ("%s: waitid returns with %d (%s)\n", __FUNCTION__, s,
 709           strerror (errno));
 710
 711   exit (1);
 712 }
 713
 714
 715 static void *
 716 tf_sigpause (void *arg)
 717 {
 718   int r = pthread_barrier_wait (&b2);
 719   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 720     {
 721       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 722       exit (1);
 723     }
 724
 725   if (arg != NULL)
 726     {
 727       r = pthread_barrier_wait (&b2);
 728       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 729         {
 730           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 731           exit (1);
 732         }
 733     }
 734
 735   pthread_cleanup_push (cl, NULL);
 736
 737 #ifdef SIGCANCEL
 738   /* Just for fun block the cancellation signal.  We need to use
 739      __xpg_sigpause since otherwise we will get the BSD version.  */
 740   __xpg_sigpause (SIGCANCEL);
 741 #else
 742   pause ();
 743 #endif
 744
 745   pthread_cleanup_pop (0);
 746
 747   printf ("%s: sigpause returned\n", __FUNCTION__);
 748
 749   exit (1);
 750 }
 751
 752
 753 static void *
 754 tf_sigsuspend (void *arg)
 755 {
 756   int r = pthread_barrier_wait (&b2);
 757   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 758     {
 759       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 760       exit (1);
 761     }
 762
 763   if (arg != NULL)
 764     {
 765       r = pthread_barrier_wait (&b2);
 766       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 767         {
 768           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 769           exit (1);
 770         }
 771     }
 772
 773   pthread_cleanup_push (cl, NULL);
 774
 775   /* Just for fun block all signals.  */
 776   sigset_t mask;
 777   sigfillset (&mask);
 778   sigsuspend (&mask);
 779
 780   pthread_cleanup_pop (0);
 781
 782   printf ("%s: sigsuspend returned\n", __FUNCTION__);
 783
 784   exit (1);
 785 }
 786
 787
 788 static void *
 789 tf_sigwait (void *arg)
 790 {
 791   int r = pthread_barrier_wait (&b2);
 792   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 793     {
 794       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 795       exit (1);
 796     }
 797
 798   if (arg != NULL)
 799     {
 800       r = pthread_barrier_wait (&b2);
 801       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 802         {
 803           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 804           exit (1);
 805         }
 806     }
 807
 808   /* Block SIGUSR1.  */
 809   sigset_t mask;
 810   sigemptyset (&mask);
 811   sigaddset (&mask, SIGUSR1);
 812   if (pthread_sigmask (SIG_BLOCK, &mask, NULL) != 0)
 813     {
 814       printf ("%s: pthread_sigmask failed\n", __FUNCTION__);
 815       exit (1);
 816     }
 817
 818   int sig;
 819   pthread_cleanup_push (cl, NULL);
 820
 821   /* Wait for SIGUSR1.  */
 822   sigwait (&mask, &sig);
 823
 824   pthread_cleanup_pop (0);
 825
 826   printf ("%s: sigwait returned with signal %d\n", __FUNCTION__, sig);
 827
 828   exit (1);
 829 }
 830
 831
 832 static void *
 833 tf_sigwaitinfo (void *arg)
 834 {
 835   int r = pthread_barrier_wait (&b2);
 836   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 837     {
 838       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 839       exit (1);
 840     }
 841
 842   if (arg != NULL)
 843     {
 844       r = pthread_barrier_wait (&b2);
 845       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 846         {
 847           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 848           exit (1);
 849         }
 850     }
 851
 852   /* Block SIGUSR1.  */
 853   sigset_t mask;
 854   sigemptyset (&mask);
 855   sigaddset (&mask, SIGUSR1);
 856   if (pthread_sigmask (SIG_BLOCK, &mask, NULL) != 0)
 857     {
 858       printf ("%s: pthread_sigmask failed\n", __FUNCTION__);
 859       exit (1);
 860     }
 861
 862   siginfo_t info;
 863   pthread_cleanup_push (cl, NULL);
 864
 865   /* Wait for SIGUSR1.  */
 866   sigwaitinfo (&mask, &info);
 867
 868   pthread_cleanup_pop (0);
 869
 870   printf ("%s: sigwaitinfo returned with signal %d\n", __FUNCTION__,
 871           info.si_signo);
 872
 873   exit (1);
 874 }
 875
 876
 877 static void *
 878 tf_sigtimedwait (void *arg)
 879 {
 880   int r = pthread_barrier_wait (&b2);
 881   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 882     {
 883       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 884       exit (1);
 885     }
 886
 887   if (arg != NULL)
 888     {
 889       r = pthread_barrier_wait (&b2);
 890       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 891         {
 892           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 893           exit (1);
 894         }
 895     }
 896
 897   /* Block SIGUSR1.  */
 898   sigset_t mask;
 899   sigemptyset (&mask);
 900   sigaddset (&mask, SIGUSR1);
 901   if (pthread_sigmask (SIG_BLOCK, &mask, NULL) != 0)
 902     {
 903       printf ("%s: pthread_sigmask failed\n", __FUNCTION__);
 904       exit (1);
 905     }
 906
 907   /* Wait for SIGUSR1.  */
 908   siginfo_t info;
 909   struct timespec ts = { .tv_sec = 60, .tv_nsec = 0 };
 910   pthread_cleanup_push (cl, NULL);
 911
 912   sigtimedwait (&mask, &info, &ts);
 913
 914   pthread_cleanup_pop (0);
 915
 916   printf ("%s: sigtimedwait returned with signal %d\n", __FUNCTION__,
 917           info.si_signo);
 918
 919   exit (1);
 920 }
 921
 922
 923 static void *
 924 tf_pause (void *arg)
 925 {
 926   int r = pthread_barrier_wait (&b2);
 927   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 928     {
 929       printf ("%s: barrier_wait failed\n", __FUNCTION__);
 930       exit (1);
 931     }
 932
 933   if (arg != NULL)
 934     {
 935       r = pthread_barrier_wait (&b2);
 936       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 937         {
 938           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
 939           exit (1);
 940         }
 941     }
 942
 943   pthread_cleanup_push (cl, NULL);
 944
 945   pause ();
 946
 947   pthread_cleanup_pop (0);
 948
 949   printf ("%s: pause returned\n", __FUNCTION__);
 950
 951   exit (1);
 952 }
 953
 954
 955 static void *
 956 tf_accept (void *arg)
 957 {
 958   struct sockaddr_un sun;
 959   /* To test a non-blocking accept call we make the call file by using
 960      a datagrame socket.  */
 961   int pf = arg == NULL ? SOCK_STREAM : SOCK_DGRAM;
 962
 963   tempfd = socket (AF_UNIX, pf, 0);
 964   if (tempfd == -1)
 965     {
 966       printf ("%s: socket call failed\n", __FUNCTION__);
 967       exit (1);
 968     }
 969
 970   int tries = 0;
 971   do
 972     {
 973       if (++tries > 10)
 974         {
 975           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
 976         }
 977
 978       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-1-XXXXXX");
 979       if (mktemp (sun.sun_path) == NULL)
 980         {
 981           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
 982           exit (1);
 983         }
 984
 985       sun.sun_family = AF_UNIX;
 986     }
 987   while (bind (tempfd, (struct sockaddr *) &sun,
 988                offsetof (struct sockaddr_un, sun_path)
 989                + strlen (sun.sun_path) + 1) != 0);
 990
 991   unlink (sun.sun_path);
 992
 993   listen (tempfd, 5);
 994
 995   socklen_t len = sizeof (sun);
 996
 997   int r = pthread_barrier_wait (&b2);
 998   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
 999     {
1000       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1001       exit (1);
1002     }
1003
1004   if (arg != NULL)
1005     {
1006       r = pthread_barrier_wait (&b2);
1007       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1008         {
1009           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1010           exit (1);
1011         }
1012     }
1013
1014   pthread_cleanup_push (cl, NULL);
1015
1016   accept (tempfd, (struct sockaddr *) &sun, &len);
1017
1018   pthread_cleanup_pop (0);
1019
1020   printf ("%s: accept returned\n", __FUNCTION__);
1021
1022   exit (1);
1023 }
1024
1025
1026 static void *
1027 tf_send (void *arg)
1028 {
1029   struct sockaddr_un sun;
1030
1031   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1032   if (tempfd == -1)
1033     {
1034       printf ("%s: first socket call failed\n", __FUNCTION__);
1035       exit (1);
1036     }
1037
1038   int tries = 0;
1039   do
1040     {
1041       if (++tries > 10)
1042         {
1043           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1044         }
1045
1046       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
1047       if (mktemp (sun.sun_path) == NULL)
1048         {
1049           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1050           exit (1);
1051         }
1052
1053       sun.sun_family = AF_UNIX;
1054     }
1055   while (bind (tempfd, (struct sockaddr *) &sun,
1056                offsetof (struct sockaddr_un, sun_path)
1057                + strlen (sun.sun_path) + 1) != 0);
1058
1059   listen (tempfd, 5);
1060
1061   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1062   if (tempfd2 == -1)
1063     {
1064       printf ("%s: second socket call failed\n", __FUNCTION__);
1065       exit (1);
1066     }
1067
1068   if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
1069     {
1070       printf ("%s: connect failed\n", __FUNCTION__);
1071       exit(1);
1072     }
1073
1074   unlink (sun.sun_path);
1075
1076   int r = pthread_barrier_wait (&b2);
1077   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1078     {
1079       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1080       exit (1);
1081     }
1082
1083   if (arg != NULL)
1084     {
1085       r = pthread_barrier_wait (&b2);
1086       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1087         {
1088           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1089           exit (1);
1090         }
1091     }
1092
1093   pthread_cleanup_push (cl, NULL);
1094
1095   /* Very large block, so that the send call blocks.  */
1096   char mem[700000];
1097
1098   send (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0);
1099
1100   pthread_cleanup_pop (0);
1101
1102   printf ("%s: send returned\n", __FUNCTION__);
1103
1104   exit (1);
1105 }
1106
1107
1108 static void *
1109 tf_recv (void *arg)
1110 {
1111   struct sockaddr_un sun;
1112
1113   tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
1114   if (tempfd == -1)
1115     {
1116       printf ("%s: first socket call failed\n", __FUNCTION__);
1117       exit (1);
1118     }
1119
1120   int tries = 0;
1121   do
1122     {
1123       if (++tries > 10)
1124         {
1125           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1126         }
1127
1128       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-3-XXXXXX");
1129       if (mktemp (sun.sun_path) == NULL)
1130         {
1131           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1132           exit (1);
1133         }
1134
1135       sun.sun_family = AF_UNIX;
1136     }
1137   while (bind (tempfd, (struct sockaddr *) &sun,
1138                offsetof (struct sockaddr_un, sun_path)
1139                + strlen (sun.sun_path) + 1) != 0);
1140
1141   listen (tempfd, 5);
1142
1143   tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
1144   if (tempfd2 == -1)
1145     {
1146       printf ("%s: second socket call failed\n", __FUNCTION__);
1147       exit (1);
1148     }
1149
1150   if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
1151     {
1152       printf ("%s: connect failed\n", __FUNCTION__);
1153       exit(1);
1154     }
1155
1156   unlink (sun.sun_path);
1157
1158   int r = pthread_barrier_wait (&b2);
1159   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1160     {
1161       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1162       exit (1);
1163     }
1164
1165   if (arg != NULL)
1166     {
1167       r = pthread_barrier_wait (&b2);
1168       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1169         {
1170           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1171           exit (1);
1172         }
1173     }
1174
1175   pthread_cleanup_push (cl, NULL);
1176
1177   char mem[70];
1178
1179   recv (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0);
1180
1181   pthread_cleanup_pop (0);
1182
1183   printf ("%s: recv returned\n", __FUNCTION__);
1184
1185   exit (1);
1186 }
1187
1188
1189 static void *
1190 tf_recvfrom (void *arg)
1191 {
1192   struct sockaddr_un sun;
1193
1194   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
1195   if (tempfd == -1)
1196     {
1197       printf ("%s: first socket call failed\n", __FUNCTION__);
1198       exit (1);
1199     }
1200
1201   int tries = 0;
1202   do
1203     {
1204       if (++tries > 10)
1205         {
1206           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1207         }
1208
1209       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-4-XXXXXX");
1210       if (mktemp (sun.sun_path) == NULL)
1211         {
1212           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1213           exit (1);
1214         }
1215
1216       sun.sun_family = AF_UNIX;
1217     }
1218   while (bind (tempfd, (struct sockaddr *) &sun,
1219                offsetof (struct sockaddr_un, sun_path)
1220                + strlen (sun.sun_path) + 1) != 0);
1221
1222   tempfname = strdup (sun.sun_path);
1223
1224   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
1225   if (tempfd2 == -1)
1226     {
1227       printf ("%s: second socket call failed\n", __FUNCTION__);
1228       exit (1);
1229     }
1230
1231   int r = pthread_barrier_wait (&b2);
1232   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1233     {
1234       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1235       exit (1);
1236     }
1237
1238   if (arg != NULL)
1239     {
1240       r = pthread_barrier_wait (&b2);
1241       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1242         {
1243           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1244           exit (1);
1245         }
1246     }
1247
1248   pthread_cleanup_push (cl, NULL);
1249
1250   char mem[70];
1251   socklen_t len = sizeof (sun);
1252
1253   recvfrom (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0,
1254             (struct sockaddr *) &sun, &len);
1255
1256   pthread_cleanup_pop (0);
1257
1258   printf ("%s: recvfrom returned\n", __FUNCTION__);
1259
1260   exit (1);
1261 }
1262
1263
1264 static void *
1265 tf_recvmsg (void *arg)
1266 {
1267   struct sockaddr_un sun;
1268
1269   tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
1270   if (tempfd == -1)
1271     {
1272       printf ("%s: first socket call failed\n", __FUNCTION__);
1273       exit (1);
1274     }
1275
1276   int tries = 0;
1277   do
1278     {
1279       if (++tries > 10)
1280         {
1281           printf ("%s: too many unsuccessful bind calls\n", __FUNCTION__);
1282         }
1283
1284       strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-5-XXXXXX");
1285       if (mktemp (sun.sun_path) == NULL)
1286         {
1287           printf ("%s: cannot generate temp file name\n", __FUNCTION__);
1288           exit (1);
1289         }
1290
1291       sun.sun_family = AF_UNIX;
1292     }
1293   while (bind (tempfd, (struct sockaddr *) &sun,
1294                offsetof (struct sockaddr_un, sun_path)
1295                + strlen (sun.sun_path) + 1) != 0);
1296
1297   tempfname = strdup (sun.sun_path);
1298
1299   tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
1300   if (tempfd2 == -1)
1301     {
1302       printf ("%s: second socket call failed\n", __FUNCTION__);
1303       exit (1);
1304     }
1305
1306   int r = pthread_barrier_wait (&b2);
1307   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1308     {
1309       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1310       exit (1);
1311     }
1312
1313   if (arg != NULL)
1314     {
1315       r = pthread_barrier_wait (&b2);
1316       if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1317         {
1318           printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1319           exit (1);
1320         }
1321     }
1322
1323   pthread_cleanup_push (cl, NULL);
1324
1325   char mem[70];
1326   struct iovec iov[1];
1327   iov[0].iov_base = mem;
1328   iov[0].iov_len = arg == NULL ? sizeof (mem) : 0;
1329
1330   struct msghdr m;
1331   m.msg_name = &sun;
1332   m.msg_namelen = sizeof (sun);
1333   m.msg_iov = iov;
1334   m.msg_iovlen = 1;
1335   m.msg_control = NULL;
1336   m.msg_controllen = 0;
1337
1338   recvmsg (tempfd2, &m, 0);
1339
1340   pthread_cleanup_pop (0);
1341
1342   printf ("%s: recvmsg returned\n", __FUNCTION__);
1343
1344   exit (1);
1345 }
1346
1347 static void *
1348 tf_open (void *arg)
1349 {
1350   if (arg == NULL)
1351     // XXX If somebody can provide a portable test case in which open()
1352     // blocks we can enable this test to run in both rounds.
1353     abort ();
1354
1355   int r = pthread_barrier_wait (&b2);
1356   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1357     {
1358       printf ("%s: barrier_wait failed\n", __FUNCTION__);
1359       exit (1);
1360     }
1361
1362   r = pthread_barrier_wait (&b2);
1363   if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
1364     {
1365       printf ("%s: 2nd barrier_wait failed\n", __FUNCTION__);
1366       exit (1);
1367     }
1368
1369   pthread_cleanup_push (cl, NULL);
1370
1371   open ("Makefile", 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"