nptl/tst-cancel4.c

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