nptl/tst-cancel4.c

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