htl: Enable tst-cancelx?[45]

* nptl/{tst-cancel4-common.c, tst-cancel4-common.h, tst-cancel4.c,
tst-cancel5.c, tst-cancelx4.c, tst-cancelx5.c}: Move to sysdeps/pthread/
* nptl/Makefile: Move corresponding rules to...
* sysdeps/pthread/Makefile: ... here.

7 files changed, 1991 insertions, 1 deletions

diff --git a/sysdeps/pthread/Makefile b/sysdeps/pthread/Makefile
index 920d875420..45a15b0b1a 100644
--- a/sysdeps/pthread/Makefile
+++ b/sysdeps/pthread/Makefile
@@ -54,6 +54,7 @@ tests += tst-cnd-basic tst-mtx-trylock tst-cnd-broadcast \
 	 tst-cancel-self tst-cancel-self-cancelstate \
 	 tst-cancel-self-canceltype tst-cancel-self-testcancel \
 	 tst-cancel1 tst-cancel2 tst-cancel3 \
+	 tst-cancel4 tst-cancel5 \
 	 tst-cancel6 tst-cancel8 tst-cancel9 tst-cancel10 tst-cancel11 \
 	 tst-cancel12 tst-cancel13 tst-cancel14 tst-cancel15 tst-cancel16 \
 	 tst-cancel18 tst-cancel19 tst-cancel20 tst-cancel21 \
@@ -117,6 +118,7 @@ CFLAGS-tst-cleanup2.c += -fno-builtin
 CFLAGS-tst-cleanupx2.c += -fno-builtin
 
 tests += tst-cancelx2 tst-cancelx3 tst-cancelx6 tst-cancelx8 tst-cancelx9 \
+	 tst-cancelx4 tst-cancelx5 \
 	 tst-cancelx10 tst-cancelx11 tst-cancelx12 tst-cancelx13 tst-cancelx14 \
 	 tst-cancelx15 tst-cancelx16 tst-cancelx18 tst-cancelx20 tst-cancelx21 \
 	 tst-cleanupx0 tst-cleanupx1 tst-cleanupx2 tst-cleanupx3
@@ -143,7 +145,7 @@ tests-static += tst-locale1 tst-locale2 tst-cancel21-static
 tests += tst-cancel21-static tst-cond11-static
 
 # These tests are linked with libc before libpthread
-tests-reverse += tst-cancel23 tst-vfork1x tst-vfork2x
+tests-reverse += tst-cancel5 tst-cancel23 tst-vfork1x tst-vfork2x
 
 ifeq ($(run-built-tests),yes)
 ifeq ($(build-shared),yes)
@@ -151,10 +153,19 @@ tests-special += $(objpfx)tst-cleanup0-cmp.out
 endif
 endif
 
+# The sigmask macro is deprecated and triggers are compiler warning
+# which cannot be suppressed (as of GCC 9).
+CFLAGS-tst-cancel4.c += -Wno-error
+CFLAGS-tst-cancel5.c += -Wno-error
+CFLAGS-tst-cancelx4.c += -Wno-error
+CFLAGS-tst-cancelx5.c += -Wno-error
+
 # Run the cancellation and cleanup tests also for the modern, exception-based
 # implementation.  For this we have to pass the -fexceptions parameter.
 CFLAGS-tst-cancelx2.c += -fexceptions
 CFLAGS-tst-cancelx3.c += -fexceptions
+CFLAGS-tst-cancelx4.c += -fexceptions
+CFLAGS-tst-cancelx5.c += -fexceptions
 CFLAGS-tst-cancelx6.c += -fexceptions
 CFLAGS-tst-cancelx8.c += -fexceptions
 CFLAGS-tst-cancelx9.c += -fexceptions
diff --git a/sysdeps/pthread/tst-cancel4-common.c b/sysdeps/pthread/tst-cancel4-common.c
new file mode 100644
index 0000000000..9a6924c1c6
--- /dev/null
+++ b/sysdeps/pthread/tst-cancel4-common.c
@@ -0,0 +1,246 @@
+/* Common file for all tst-cancel4_*
+
+   Copyright (C) 2016-2020 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+static int
+do_test (void)
+{
+  if (socketpair (AF_UNIX, SOCK_STREAM, 0, fds) != 0)
+    {
+      perror ("socketpair");
+      exit (1);
+    }
+
+  set_socket_buffer (fds[1]);
+
+  if (mktemp (fifoname) == NULL)
+    {
+      printf ("%s: cannot generate temp file name: %m\n", __func__);
+      exit (1);
+    }
+
+  int result = 0;
+  size_t cnt;
+  for (cnt = 0; cnt < ntest_tf; ++cnt)
+    {
+      if (tests[cnt].only_early)
+	continue;
+
+      if (pthread_barrier_init (&b2, NULL, tests[cnt].nb) != 0)
+	{
+	  puts ("b2 init failed");
+	  exit (1);
+	}
+
+      /* Reset the counter for the cleanup handler.  */
+      cl_called = 0;
+
+      pthread_t th;
+      if (pthread_create (&th, NULL, tests[cnt].tf, NULL) != 0)
+	{
+	  printf ("create for '%s' test failed\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+
+      int r = pthread_barrier_wait (&b2);
+      if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
+	{
+	  printf ("%s: barrier_wait failed\n", __func__);
+	  result = 1;
+	  continue;
+	}
+
+      struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
+      while (nanosleep (&ts, &ts) != 0)
+	continue;
+
+      if (pthread_cancel (th) != 0)
+	{
+	  printf ("cancel for '%s' failed\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+
+      void *status;
+      if (pthread_join (th, &status) != 0)
+	{
+	  printf ("join for '%s' failed\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+      if (status != PTHREAD_CANCELED)
+	{
+	  printf ("thread for '%s' not canceled\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+
+      if (pthread_barrier_destroy (&b2) != 0)
+	{
+	  puts ("barrier_destroy failed");
+	  result = 1;
+	  continue;
+	}
+
+      if (cl_called == 0)
+	{
+	  printf ("cleanup handler not called for '%s'\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+      if (cl_called > 1)
+	{
+	  printf ("cleanup handler called more than once for '%s'\n",
+		  tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+
+      printf ("in-time cancel test of '%s' successful\n", tests[cnt].name);
+
+      if (tempfd != -1)
+	{
+	  close (tempfd);
+	  tempfd = -1;
+	}
+      if (tempfd2 != -1)
+	{
+	  close (tempfd2);
+	  tempfd2 = -1;
+	}
+      if (tempfname != NULL)
+	{
+	  unlink (tempfname);
+	  free (tempfname);
+	  tempfname = NULL;
+	}
+      if (tempmsg != -1)
+	{
+	  msgctl (tempmsg, IPC_RMID, NULL);
+	  tempmsg = -1;
+	}
+    }
+
+  for (cnt = 0; cnt < ntest_tf; ++cnt)
+    {
+      if (pthread_barrier_init (&b2, NULL, tests[cnt].nb) != 0)
+	{
+	  puts ("b2 init failed");
+	  exit (1);
+	}
+
+      /* Reset the counter for the cleanup handler.  */
+      cl_called = 0;
+
+      pthread_t th;
+      if (pthread_create (&th, NULL, tests[cnt].tf, (void *) 1l) != 0)
+	{
+	  printf ("create for '%s' test failed\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+
+      int r = pthread_barrier_wait (&b2);
+      if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
+	{
+	  printf ("%s: barrier_wait failed\n", __func__);
+	  result = 1;
+	  continue;
+	}
+
+      if (pthread_cancel (th) != 0)
+	{
+	  printf ("cancel for '%s' failed\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+
+      r = pthread_barrier_wait (&b2);
+      if (r != 0 && r != PTHREAD_BARRIER_SERIAL_THREAD)
+	{
+	  printf ("%s: barrier_wait failed\n", __func__);
+	  result = 1;
+	  continue;
+	}
+
+      void *status;
+      if (pthread_join (th, &status) != 0)
+	{
+	  printf ("join for '%s' failed\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+      if (status != PTHREAD_CANCELED)
+	{
+	  printf ("thread for '%s' not canceled\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+
+      if (pthread_barrier_destroy (&b2) != 0)
+	{
+	  puts ("barrier_destroy failed");
+	  result = 1;
+	  continue;
+	}
+
+      if (cl_called == 0)
+	{
+	  printf ("cleanup handler not called for '%s'\n", tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+      if (cl_called > 1)
+	{
+	  printf ("cleanup handler called more than once for '%s'\n",
+		  tests[cnt].name);
+	  result = 1;
+	  continue;
+	}
+
+      printf ("early cancel test of '%s' successful\n", tests[cnt].name);
+
+      if (tempfd != -1)
+	{
+	  close (tempfd);
+	  tempfd = -1;
+	}
+      if (tempfd2 != -1)
+	{
+	  close (tempfd2);
+	  tempfd2 = -1;
+	}
+      if (tempfname != NULL)
+	{
+	  unlink (tempfname);
+	  free (tempfname);
+	  tempfname = NULL;
+	}
+      if (tempmsg != -1)
+	{
+	  msgctl (tempmsg, IPC_RMID, NULL);
+	  tempmsg = -1;
+	}
+    }
+
+  return result;
+}
+
+#define TIMEOUT 60
+#include <support/test-driver.c>
diff --git a/sysdeps/pthread/tst-cancel4-common.h b/sysdeps/pthread/tst-cancel4-common.h
new file mode 100644
index 0000000000..507d3393c1
--- /dev/null
+++ b/sysdeps/pthread/tst-cancel4-common.h
@@ -0,0 +1,112 @@
+/* Common definition for tst-cancel4_* tests.
+
+   Copyright (C) 2016-2020 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <pthread.h>
+
+#include <support/check.h>
+#include <support/xthread.h>
+#include <support/xunistd.h>
+
+/* Pipe descriptors.  */
+static int fds[2];
+
+/* Temporary file descriptor, to be closed after each round.  */
+static int tempfd = -1;
+static int tempfd2 = -1;
+/* Name of temporary file to be removed after each round.  */
+static char *tempfname;
+/* Temporary message queue.  */
+static int tempmsg = -1;
+
+/* Often used barrier for two threads.  */
+static pthread_barrier_t b2;
+
+/* The WRITE_BUFFER_SIZE value needs to be chosen such that if we set
+   the socket send buffer size to '1', a write of this size on that
+   socket will block.
+
+   The Linux kernel imposes a minimum send socket buffer size which
+   has changed over the years.  As of Linux 3.10 the value is:
+
+     2 * (2048 + SKB_DATA_ALIGN(sizeof(struct sk_buff)))
+
+   which is attempting to make sure that with standard MTUs,
+   TCP can always queue up at least 2 full sized packets.
+
+   Furthermore, there is logic in the socket send paths that
+   will allow one more packet (of any size) to be queued up as
+   long as some socket buffer space remains.   Blocking only
+   occurs when we try to queue up a new packet and the send
+   buffer space has already been fully consumed.
+
+   Therefore we must set this value to the largest possible value of
+   the formula above (and since it depends upon the size of "struct
+   sk_buff", it is dependent upon machine word size etc.) plus some
+   slack space.  */
+
+#define WRITE_BUFFER_SIZE 16384
+
+/* Set the send buffer of socket S to 1 byte so any send operation
+   done with WRITE_BUFFER_SIZE bytes will force syscall blocking.  */
+static void
+set_socket_buffer (int s)
+{
+  int val = 1;
+  socklen_t len = sizeof (val);
+
+  TEST_VERIFY_EXIT (setsockopt (s, SOL_SOCKET, SO_SNDBUF, &val,
+		    sizeof (val)) == 0);
+  TEST_VERIFY_EXIT (getsockopt (s, SOL_SOCKET, SO_SNDBUF, &val, &len) == 0);
+  TEST_VERIFY_EXIT (val < WRITE_BUFFER_SIZE);
+  printf("got size %d\n", val);
+}
+
+/* Cleanup handling test.  */
+static int cl_called;
+
+static void
+cl (void *arg)
+{
+  ++cl_called;
+}
+
+/* Named pipe used to check for blocking open.  It should be closed
+   after the cancellation handling.  */
+static char fifoname[] = "/tmp/tst-cancel4-fifo-XXXXXX";
+static int fifofd;
+
+static void
+__attribute__ ((used))
+cl_fifo (void *arg)
+{
+  ++cl_called;
+
+  unlink (fifoname);
+  close (fifofd);
+  fifofd = -1;
+}
+
+struct cancel_tests
+{
+  const char *name;
+  void *(*tf) (void *);
+  int nb;
+  int only_early;
+};
+#define ADD_TEST(name, nbar, early) { #name, tf_##name, nbar, early }
diff --git a/sysdeps/pthread/tst-cancel4.c b/sysdeps/pthread/tst-cancel4.c
new file mode 100644
index 0000000000..41275262ca
--- /dev/null
+++ b/sysdeps/pthread/tst-cancel4.c
@@ -0,0 +1,1618 @@
+/* Copyright (C) 2002-2020 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+/* NOTE: this tests functionality beyond POSIX.  POSIX does not allow
+   exit to be called more than once.  */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+#include <unistd.h>
+#include <errno.h>
+#include <limits.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <sys/mman.h>
+#include <sys/poll.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <sys/uio.h>
+#include <libc-diag.h>
+
+
+/* Since STREAMS are not supported in the standard Linux kernel and
+   there we don't advertise STREAMS as supported is no need to test
+   the STREAMS related functions.  This affects
+     getmsg()              getpmsg()          putmsg()
+     putpmsg()
+
+   lockf() and fcntl() are tested in tst-cancel16.
+
+   pthread_join() is tested in tst-join5.
+
+   pthread_testcancel()'s only purpose is to allow cancellation.  This
+   is tested in several places.
+
+   sem_wait() and sem_timedwait() are checked in tst-cancel1[2345] tests.
+
+   mq_send(), mq_timedsend(), mq_receive() and mq_timedreceive() are checked
+   in tst-mqueue8{,x} tests.
+
+   aio_suspend() is tested in tst-cancel17.
+
+   clock_nanosleep() is tested in tst-cancel18.
+
+   Linux sendmmsg and recvmmsg are checked in tst-cancel4_1.c and
+   tst-cancel4_2.c respectively.
+*/
+
+#include "tst-cancel4-common.h"
+
+
+#ifndef IPC_ADDVAL
+# define IPC_ADDVAL 0
+#endif
+
+
+static void *
+tf_read  (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    fd = fds[0];
+  else
+    {
+      char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+      tempfd = fd = mkstemp (fname);
+      if (fd == -1)
+	FAIL_EXIT1 ("mkstemp failed: %m");
+      unlink (fname);
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+  pthread_cleanup_push (cl, NULL);
+
+  char buf[100];
+  s = read (fd, buf, sizeof (buf));
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("read returns with %zd", s);
+}
+
+
+static void *
+tf_readv  (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    fd = fds[0];
+  else
+    {
+      char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+      tempfd = fd = mkstemp (fname);
+      if (fd == -1)
+	FAIL_EXIT1 ("mkstemp failed: %m");
+      unlink (fname);
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+  pthread_cleanup_push (cl, NULL);
+
+  char buf[100];
+  struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
+  s = readv (fd, iov, 1);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("readv returns with %zd", s);
+}
+
+
+static void *
+tf_write  (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    fd = fds[1];
+  else
+    {
+      char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+      tempfd = fd = mkstemp (fname);
+      if (fd == -1)
+	FAIL_EXIT1 ("mkstemp failed: %m");
+      unlink (fname);
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+  pthread_cleanup_push (cl, NULL);
+
+  char buf[WRITE_BUFFER_SIZE];
+  memset (buf, '\0', sizeof (buf));
+  s = write (fd, buf, sizeof (buf));
+  /* The write can return a value higher than 0 (meaning partial write)
+     due to the SIGCANCEL, but the thread may still be pending
+     cancellation.  */
+  pthread_testcancel ();
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("write returns with %zd", s);
+}
+
+
+static void *
+tf_writev  (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    fd = fds[1];
+  else
+    {
+      char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+      tempfd = fd = mkstemp (fname);
+      if (fd == -1)
+	FAIL_EXIT1 ("mkstemp failed: %m");
+      unlink (fname);
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+  pthread_cleanup_push (cl, NULL);
+
+  char buf[WRITE_BUFFER_SIZE];
+  memset (buf, '\0', sizeof (buf));
+  struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
+  s = writev (fd, iov, 1);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("writev returns with %zd", s);
+}
+
+
+static void *
+tf_sleep (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  sleep (arg == NULL ? 1000000 : 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("sleep returns");
+}
+
+
+static void *
+tf_usleep (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  usleep (arg == NULL ? (useconds_t) ULONG_MAX : 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("usleep returns");
+}
+
+
+static void *
+tf_nanosleep (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  struct timespec ts = { .tv_sec = arg == NULL ? 10000000 : 0, .tv_nsec = 0 };
+  TEMP_FAILURE_RETRY (nanosleep (&ts, &ts));
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("nanosleep returns");
+}
+
+
+static void *
+tf_select (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    fd = fds[0];
+  else
+    {
+      char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+      tempfd = fd = mkstemp (fname);
+      if (fd == -1)
+	FAIL_EXIT1 ("mkstemp failed: %m");
+      unlink (fname);
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  fd_set rfs;
+  FD_ZERO (&rfs);
+  FD_SET (fd, &rfs);
+
+  int s;
+  pthread_cleanup_push (cl, NULL);
+
+  s = select (fd + 1, &rfs, NULL, NULL, NULL);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("select returns with %d: %m", s);
+}
+
+
+static void *
+tf_pselect (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    fd = fds[0];
+  else
+    {
+      char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+      tempfd = fd = mkstemp (fname);
+      if (fd == -1)
+	FAIL_EXIT1 ("mkstemp failed: %m");
+      unlink (fname);
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  fd_set rfs;
+  FD_ZERO (&rfs);
+  FD_SET (fd, &rfs);
+
+  int s;
+  pthread_cleanup_push (cl, NULL);
+
+  s = pselect (fd + 1, &rfs, NULL, NULL, NULL, NULL);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("pselect returns with %d: %m", s);
+}
+
+
+static void *
+tf_poll (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    fd = fds[0];
+  else
+    {
+      char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+      tempfd = fd = mkstemp (fname);
+      if (fd == -1)
+	FAIL_EXIT1 ("mkstemp failed: %m");
+      unlink (fname);
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
+
+  int s;
+  pthread_cleanup_push (cl, NULL);
+
+  s = poll (rfs, 1, -1);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("poll returns with %d: %m", s);
+}
+
+
+static void *
+tf_ppoll (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    fd = fds[0];
+  else
+    {
+      char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+      tempfd = fd = mkstemp (fname);
+      if (fd == -1)
+	FAIL_EXIT1 ("mkstemp failed: %m");
+      unlink (fname);
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  struct pollfd rfs[1] = { [0] = { .fd = fd, .events = POLLIN } };
+
+  int s;
+  pthread_cleanup_push (cl, NULL);
+
+  s = ppoll (rfs, 1, NULL, NULL);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("ppoll returns with %d: %m", s);
+}
+
+
+static void *
+tf_wait (void *arg)
+{
+  pid_t pid = fork ();
+  if (pid == -1)
+    FAIL_EXIT1 ("fork: %m");
+
+  if (pid == 0)
+    {
+      /* Make the program disappear after a while.  */
+      if (arg == NULL)
+	sleep (10);
+      exit (0);
+    }
+
+  if (arg != NULL)
+    {
+      struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
+      while (nanosleep (&ts, &ts) != 0)
+	continue;
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  int s;
+  pthread_cleanup_push (cl, NULL);
+
+  s = wait (NULL);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("wait returns with %d: %m", s);
+}
+
+
+static void *
+tf_waitpid (void *arg)
+{
+  pid_t pid = fork ();
+  if (pid == -1)
+    FAIL_EXIT1 ("fork: %m");
+
+  if (pid == 0)
+    {
+      /* Make the program disappear after a while.  */
+      if (arg == NULL)
+	sleep (10);
+      exit (0);
+    }
+
+  if (arg != NULL)
+    {
+      struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
+      while (nanosleep (&ts, &ts) != 0)
+	continue;
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  int s;
+  pthread_cleanup_push (cl, NULL);
+
+  s = waitpid (-1, NULL, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("waitpid returns with %d: %m", s);
+}
+
+
+static void *
+tf_waitid (void *arg)
+{
+  pid_t pid = fork ();
+  if (pid == -1)
+    FAIL_EXIT1 ("fork: %m");
+
+  if (pid == 0)
+    {
+      /* Make the program disappear after a while.  */
+      if (arg == NULL)
+	sleep (10);
+      exit (0);
+    }
+
+  if (arg != NULL)
+    {
+      struct timespec  ts = { .tv_sec = 0, .tv_nsec = 100000000 };
+      while (nanosleep (&ts, &ts) != 0)
+	continue;
+
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  int s;
+  pthread_cleanup_push (cl, NULL);
+
+#ifndef WEXITED
+# define WEXITED 0
+#endif
+  siginfo_t si;
+  s = waitid (P_PID, pid, &si, WEXITED);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("waitid returns with %d: %m", s);
+}
+
+
+static void *
+tf_sigpause (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  /* This tests the deprecated sigpause and sigmask functions.  The
+     file is compiled with -Wno-errno so that the sigmask deprecation
+     warning is not fatal.  */
+  DIAG_PUSH_NEEDS_COMMENT;
+  DIAG_IGNORE_NEEDS_COMMENT (4.9, "-Wdeprecated-declarations");
+  sigpause (sigmask (SIGINT));
+  DIAG_POP_NEEDS_COMMENT;
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("sigpause returned");
+}
+
+
+static void *
+tf_sigsuspend (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  /* Just for fun block all signals.  */
+  sigset_t mask;
+  sigfillset (&mask);
+  sigsuspend (&mask);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("sigsuspend returned");
+}
+
+
+static void *
+tf_sigwait (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  /* Block SIGUSR1.  */
+  sigset_t mask;
+  sigemptyset (&mask);
+  sigaddset (&mask, SIGUSR1);
+  TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
+
+  int sig;
+  pthread_cleanup_push (cl, NULL);
+
+  /* Wait for SIGUSR1.  */
+  sigwait (&mask, &sig);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("sigwait returned with signal %d", sig);
+}
+
+
+static void *
+tf_sigwaitinfo (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  /* Block SIGUSR1.  */
+  sigset_t mask;
+  sigemptyset (&mask);
+  sigaddset (&mask, SIGUSR1);
+  TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
+
+  siginfo_t info;
+  pthread_cleanup_push (cl, NULL);
+
+  /* Wait for SIGUSR1.  */
+  int ret;
+  ret = sigwaitinfo (&mask, &info);
+  if (ret == -1 && errno == ENOSYS)
+    {
+      int sig;
+
+      printf ("sigwaitinfo not supported\n");
+      sigwait (&mask, &sig);
+    }
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("sigwaitinfo returned with signal %d", info.si_signo);
+}
+
+
+static void *
+tf_sigtimedwait (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  /* Block SIGUSR1.  */
+  sigset_t mask;
+  sigemptyset (&mask);
+  sigaddset (&mask, SIGUSR1);
+  TEST_VERIFY_EXIT (pthread_sigmask (SIG_BLOCK, &mask, NULL) == 0);
+
+  /* Wait for SIGUSR1.  */
+  siginfo_t info;
+  struct timespec ts = { .tv_sec = 60, .tv_nsec = 0 };
+  pthread_cleanup_push (cl, NULL);
+
+  int ret;
+  ret = sigtimedwait (&mask, &info, &ts);
+  if (ret == -1 && errno == ENOSYS)
+    {
+      int sig;
+      printf ("sigtimedwait not supported\n");
+
+      sigwait (&mask, &sig);
+    }
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("sigtimedwait returned with signal %d", info.si_signo);
+}
+
+
+static void *
+tf_pause (void *arg)
+{
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  pause ();
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("pause returned");
+}
+
+
+static void *
+tf_accept (void *arg)
+{
+  struct sockaddr_un sun;
+  /* To test a non-blocking accept call we make the call file by using
+     a datagrame socket.  */
+  int pf = arg == NULL ? SOCK_STREAM : SOCK_DGRAM;
+
+  tempfd = socket (AF_UNIX, pf, 0);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, %s, 0): %m", arg == NULL ? "SOCK_STREAM"
+					       : "SOCK_DGRAM");
+
+  int tries = 0;
+  do
+    {
+      TEST_VERIFY_EXIT (tries++ < 10);
+
+      strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-1-XXXXXX");
+      TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
+
+      sun.sun_family = AF_UNIX;
+    }
+  while (bind (tempfd, (struct sockaddr *) &sun,
+	       offsetof (struct sockaddr_un, sun_path)
+	       + strlen (sun.sun_path) + 1) != 0);
+
+  unlink (sun.sun_path);
+
+  listen (tempfd, 5);
+
+  socklen_t len = sizeof (sun);
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  accept (tempfd, (struct sockaddr *) &sun, &len);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("accept returned");
+}
+
+
+static void *
+tf_send (void *arg)
+{
+  struct sockaddr_un sun;
+
+  tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
+
+  int tries = 0;
+  do
+    {
+      TEST_VERIFY_EXIT (tries++ < 10);
+
+      strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
+      TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
+
+      sun.sun_family = AF_UNIX;
+    }
+  while (bind (tempfd, (struct sockaddr *) &sun,
+	       offsetof (struct sockaddr_un, sun_path)
+	       + strlen (sun.sun_path) + 1) != 0);
+
+  listen (tempfd, 5);
+
+  tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (tempfd2 == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
+
+  if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
+    FAIL_EXIT1 ("connect: %m");
+
+  unlink (sun.sun_path);
+
+  set_socket_buffer (tempfd2);
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  char mem[WRITE_BUFFER_SIZE];
+
+  size_t s = send (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0);
+  /* The send can return a value higher than 0 (meaning partial send)
+     due to the SIGCANCEL, but the thread may still be pending
+     cancellation.  */
+  pthread_testcancel ();
+  printf("send returned %zd\n", s);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("send returned");
+}
+
+
+static void *
+tf_recv (void *arg)
+{
+  struct sockaddr_un sun;
+
+  tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
+
+  int tries = 0;
+  do
+    {
+      TEST_VERIFY_EXIT (tries++ < 10);
+
+      strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-3-XXXXXX");
+      TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
+
+      sun.sun_family = AF_UNIX;
+    }
+  while (bind (tempfd, (struct sockaddr *) &sun,
+	       offsetof (struct sockaddr_un, sun_path)
+	       + strlen (sun.sun_path) + 1) != 0);
+
+  listen (tempfd, 5);
+
+  tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (tempfd2 == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
+
+  if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
+    FAIL_EXIT1 ("connect: %m");
+
+  unlink (sun.sun_path);
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  char mem[70];
+
+  recv (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("recv returned");
+}
+
+
+static void *
+tf_recvfrom (void *arg)
+{
+  struct sockaddr_un sun;
+
+  tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
+
+  int tries = 0;
+  do
+    {
+      TEST_VERIFY_EXIT (tries++ < 10);
+
+      strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-4-XXXXXX");
+      TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
+
+      sun.sun_family = AF_UNIX;
+    }
+  while (bind (tempfd, (struct sockaddr *) &sun,
+	       offsetof (struct sockaddr_un, sun_path)
+	       + strlen (sun.sun_path) + 1) != 0);
+
+  tempfname = strdup (sun.sun_path);
+
+  tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
+  if (tempfd2 == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  char mem[70];
+  socklen_t len = sizeof (sun);
+
+  recvfrom (tempfd2, mem, arg == NULL ? sizeof (mem) : 0, 0,
+	    (struct sockaddr *) &sun, &len);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("recvfrom returned");
+}
+
+
+static void *
+tf_recvmsg (void *arg)
+{
+  struct sockaddr_un sun;
+
+  tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
+
+  int tries = 0;
+  do
+    {
+      TEST_VERIFY_EXIT (tries++ < 10);
+
+      strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-5-XXXXXX");
+      TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
+
+      sun.sun_family = AF_UNIX;
+    }
+  while (bind (tempfd, (struct sockaddr *) &sun,
+	       offsetof (struct sockaddr_un, sun_path)
+	       + strlen (sun.sun_path) + 1) != 0);
+
+  tempfname = strdup (sun.sun_path);
+
+  tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
+  if (tempfd2 == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  char mem[70];
+  struct iovec iov[1];
+  iov[0].iov_base = mem;
+  iov[0].iov_len = arg == NULL ? sizeof (mem) : 0;
+
+  struct msghdr m;
+  m.msg_name = &sun;
+  m.msg_namelen = sizeof (sun);
+  m.msg_iov = iov;
+  m.msg_iovlen = 1;
+  m.msg_control = NULL;
+  m.msg_controllen = 0;
+
+  recvmsg (tempfd2, &m, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("recvmsg returned");
+}
+
+static void *
+tf_open (void *arg)
+{
+  if (arg == NULL)
+    {
+      fifofd = mkfifo (fifoname, S_IWUSR | S_IRUSR);
+      if (fifofd == -1)
+	FAIL_EXIT1 ("mkfifo: %m");
+    }
+  else
+    {
+      xpthread_barrier_wait (&b2);
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl_fifo, NULL);
+
+  open (arg ? "Makefile" : fifoname, O_RDONLY);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("open returned");
+}
+
+
+static void *
+tf_close (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which close()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  char fname[] = "/tmp/tst-cancel-fd-XXXXXX";
+  tempfd = mkstemp (fname);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("mkstemp failed: %m");
+  unlink (fname);
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  close (tempfd);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("close returned");
+}
+
+
+static void *
+tf_pread (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which pread()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  tempfd = open ("Makefile", O_RDONLY);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  char mem[10];
+  pread (tempfd, mem, sizeof (mem), 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("pread returned");
+}
+
+
+static void *
+tf_pwrite (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which pwrite()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+  tempfd = mkstemp (fname);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("mkstemp failed: %m");
+  unlink (fname);
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  char mem[10];
+  pwrite (tempfd, mem, sizeof (mem), 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("pwrite returned");
+}
+
+static void *
+tf_preadv (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    /* XXX If somebody can provide a portable test case in which preadv
+       blocks we can enable this test to run in both rounds.  */
+    abort ();
+
+  char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+  tempfd = fd = mkstemp (fname);
+  if (fd == -1)
+    FAIL_EXIT1 ("mkstemp failed: %m");
+  unlink (fname);
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+  pthread_cleanup_push (cl, NULL);
+
+  char buf[100];
+  struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
+  s = preadv (fd, iov, 1, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("preadv returns with %zd", s);
+}
+
+static void *
+tf_pwritev (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    /* XXX If somebody can provide a portable test case in which pwritev
+       blocks we can enable this test to run in both rounds.  */
+    abort ();
+
+  char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+  tempfd = fd = mkstemp (fname);
+  if (fd == -1)
+    FAIL_EXIT1 ("mkstemp failed: %m");
+  unlink (fname);
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+  pthread_cleanup_push (cl, NULL);
+
+  char buf[WRITE_BUFFER_SIZE];
+  memset (buf, '\0', sizeof (buf));
+  struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
+  s = pwritev (fd, iov, 1, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("pwritev returns with %zd", s);
+}
+
+static void *
+tf_pwritev2 (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    /* XXX If somebody can provide a portable test case in which pwritev2
+       blocks we can enable this test to run in both rounds.  */
+    abort ();
+
+  errno = 0;
+
+  char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+  tempfd = fd = mkstemp (fname);
+  if (fd == -1)
+    FAIL_EXIT1 ("mkstemp: %m");
+  unlink (fname);
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+  pthread_cleanup_push (cl, NULL);
+
+  char buf[WRITE_BUFFER_SIZE];
+  memset (buf, '\0', sizeof (buf));
+  struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
+  s = pwritev2 (fd, iov, 1, 0, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("pwritev2 returns with %zd", s);
+}
+
+static void *
+tf_preadv2 (void *arg)
+{
+  int fd;
+
+  if (arg == NULL)
+    /* XXX If somebody can provide a portable test case in which preadv2
+       blocks we can enable this test to run in both rounds.  */
+    abort ();
+
+  errno = 0;
+
+  char fname[] = "/tmp/tst-cancel4-fd-XXXXXX";
+  tempfd = fd = mkstemp (fname);
+  if (fd == -1)
+    FAIL_EXIT1 ("mkstemp failed: %m");
+  unlink (fname);
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+  pthread_cleanup_push (cl, NULL);
+
+  char buf[100];
+  struct iovec iov[1] = { [0] = { .iov_base = buf, .iov_len = sizeof (buf) } };
+  s = preadv2 (fd, iov, 1, 0, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("preadv2 returns with %zd", s);
+}
+
+static void *
+tf_fsync (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which fsync()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  tempfd = open ("Makefile", O_RDONLY);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  fsync (tempfd);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("fsync returned");
+}
+
+
+static void *
+tf_fdatasync (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which fdatasync()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  tempfd = open ("Makefile", O_RDONLY);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  fdatasync (tempfd);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("fdatasync returned");
+}
+
+
+static void *
+tf_msync (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which msync()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  tempfd = open ("Makefile", O_RDONLY);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("open (\"Makefile\", O_RDONLY): %m");
+
+  void *p = xmmap (NULL, 10, PROT_READ, MAP_SHARED, tempfd);
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  msync (p, 10, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("msync returned");
+}
+
+
+static void *
+tf_sendto (void *arg)
+{
+  struct sockaddr_un sun;
+
+  tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
+
+  int tries = 0;
+  do
+    {
+      TEST_VERIFY_EXIT (tries++ < 10);
+
+      strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-6-XXXXXX");
+      TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
+
+      sun.sun_family = AF_UNIX;
+    }
+  while (bind (tempfd, (struct sockaddr *) &sun,
+	       offsetof (struct sockaddr_un, sun_path)
+	       + strlen (sun.sun_path) + 1) != 0);
+
+  listen (tempfd, 5);
+
+  tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (tempfd2 == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
+
+  if (connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun)) != 0)
+    FAIL_EXIT1 ("connect: %m");
+
+  unlink (sun.sun_path);
+
+  set_socket_buffer (tempfd2);
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  char mem[WRITE_BUFFER_SIZE];
+
+  sendto (tempfd2, mem, arg == NULL ? sizeof (mem) : 1, 0, NULL, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("sendto returned");
+}
+
+
+static void *
+tf_sendmsg (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which sendmsg()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  struct sockaddr_un sun;
+
+  tempfd = socket (AF_UNIX, SOCK_DGRAM, 0);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
+
+  int tries = 0;
+  do
+    {
+      TEST_VERIFY_EXIT (tries++ < 10);
+
+      strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-7-XXXXXX");
+      TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
+
+      sun.sun_family = AF_UNIX;
+    }
+  while (bind (tempfd, (struct sockaddr *) &sun,
+	       offsetof (struct sockaddr_un, sun_path)
+	       + strlen (sun.sun_path) + 1) != 0);
+  tempfname = strdup (sun.sun_path);
+
+  tempfd2 = socket (AF_UNIX, SOCK_DGRAM, 0);
+  if (tempfd2 == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_DGRAM, 0): %m");
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  char mem[1];
+  struct iovec iov[1];
+  iov[0].iov_base = mem;
+  iov[0].iov_len = 1;
+
+  struct msghdr m;
+  m.msg_name = &sun;
+  m.msg_namelen = (offsetof (struct sockaddr_un, sun_path)
+		   + strlen (sun.sun_path) + 1);
+  m.msg_iov = iov;
+  m.msg_iovlen = 1;
+  m.msg_control = NULL;
+  m.msg_controllen = 0;
+
+  sendmsg (tempfd2, &m, 0);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("sendmsg returned");
+}
+
+
+static void *
+tf_creat (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which sendmsg()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  creat ("tmp/tst-cancel-4-should-not-exist", 0666);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("creat returned");
+}
+
+
+static void *
+tf_connect (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which connect()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  struct sockaddr_un sun;
+
+  tempfd = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (tempfd == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
+
+  int tries = 0;
+  do
+    {
+      TEST_VERIFY_EXIT (tries++ < 10);
+
+      strcpy (sun.sun_path, "/tmp/tst-cancel4-socket-2-XXXXXX");
+      TEST_VERIFY_EXIT (mktemp (sun.sun_path) != NULL);
+
+      sun.sun_family = AF_UNIX;
+    }
+  while (bind (tempfd, (struct sockaddr *) &sun,
+	       offsetof (struct sockaddr_un, sun_path)
+	       + strlen (sun.sun_path) + 1) != 0);
+  tempfname = strdup (sun.sun_path);
+
+  listen (tempfd, 5);
+
+  tempfd2 = socket (AF_UNIX, SOCK_STREAM, 0);
+  if (tempfd2 == -1)
+    FAIL_EXIT1 ("socket (AF_UNIX, SOCK_STREAM, 0): %m");
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  connect (tempfd2, (struct sockaddr *) &sun, sizeof (sun));
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("connect returned");
+}
+
+
+static void *
+tf_tcdrain (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which tcdrain()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  /* Regardless of stderr being a terminal, the tcdrain call should be
+     canceled.  */
+  tcdrain (STDERR_FILENO);
+
+  pthread_cleanup_pop (0);
+
+  FAIL_EXIT1 ("tcdrain returned");
+}
+
+
+static void *
+tf_msgrcv (void *arg)
+{
+  tempmsg = msgget (IPC_PRIVATE, 0666 | IPC_CREAT);
+  if (tempmsg == -1)
+    {
+      if (errno == ENOSYS)
+	{
+	  printf ("msgget not supported\n");
+	  tf_usleep (arg);
+	  pthread_exit (NULL);
+	}
+      else
+	FAIL_EXIT1 ("msgget (IPC_PRIVATE, 0666 | IPC_CREAT): %m");
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  if (arg != NULL)
+    xpthread_barrier_wait (&b2);
+
+  ssize_t s;
+
+  pthread_cleanup_push (cl, NULL);
+
+  struct
+  {
+    long int type;
+    char mem[10];
+  } m;
+  int randnr;
+  /* We need a positive random number.  */
+  do
+    randnr = random () % 64000;
+  while (randnr <= 0);
+  do
+    {
+      errno = 0;
+      s = msgrcv (tempmsg, (struct msgbuf *) &m, 10, randnr, 0);
+    }
+  while (errno == EIDRM || errno == EINTR);
+
+  pthread_cleanup_pop (0);
+
+  msgctl (tempmsg, IPC_RMID, NULL);
+
+  FAIL_EXIT1 ("msgrcv returned %zd", s);
+}
+
+
+static void *
+tf_msgsnd (void *arg)
+{
+  if (arg == NULL)
+    // XXX If somebody can provide a portable test case in which msgsnd()
+    // blocks we can enable this test to run in both rounds.
+    abort ();
+
+  tempmsg = msgget (IPC_PRIVATE, 0666 | IPC_CREAT);
+  if (tempmsg == -1)
+    {
+      if (errno == ENOSYS)
+	{
+	  printf ("msgget not supported\n");
+	  tf_usleep (arg);
+	  pthread_exit (NULL);
+	}
+      else
+	FAIL_EXIT1 ("msgget (IPC_PRIVATE, 0666 | IPC_CREAT): %m");
+    }
+
+  xpthread_barrier_wait (&b2);
+
+  xpthread_barrier_wait (&b2);
+
+  pthread_cleanup_push (cl, NULL);
+
+  struct
+  {
+    long int type;
+    char mem[1];
+  } m;
+  /* We need a positive random number.  */
+  do
+    m.type = random () % 64000;
+  while (m.type <= 0);
+  msgsnd (tempmsg, (struct msgbuf *) &m, sizeof (m.mem), 0);
+
+  pthread_cleanup_pop (0);
+
+  msgctl (tempmsg, IPC_RMID, NULL);
+
+  FAIL_EXIT1 ("msgsnd returned");
+}
+
+
+struct cancel_tests tests[] =
+{
+  ADD_TEST (read, 2, 0),
+  ADD_TEST (readv, 2, 0),
+  ADD_TEST (select, 2, 0),
+  ADD_TEST (pselect, 2, 0),
+  ADD_TEST (poll, 2, 0),
+  ADD_TEST (ppoll, 2, 0),
+  ADD_TEST (write, 2, 0),
+  ADD_TEST (writev, 2, 0),
+  ADD_TEST (sleep, 2, 0),
+  ADD_TEST (usleep, 2, 0),
+  ADD_TEST (nanosleep, 2, 0),
+  ADD_TEST (wait, 2, 0),
+  ADD_TEST (waitid, 2, 0),
+  ADD_TEST (waitpid, 2, 0),
+  ADD_TEST (sigpause, 2, 0),
+  ADD_TEST (sigsuspend, 2, 0),
+  ADD_TEST (sigwait, 2, 0),
+  ADD_TEST (sigwaitinfo, 2, 0),
+  ADD_TEST (sigtimedwait, 2, 0),
+  ADD_TEST (pause, 2, 0),
+  ADD_TEST (accept, 2, 0),
+  ADD_TEST (send, 2, 0),
+  ADD_TEST (recv, 2, 0),
+  ADD_TEST (recvfrom, 2, 0),
+  ADD_TEST (recvmsg, 2, 0),
+  ADD_TEST (preadv, 2, 1),
+  ADD_TEST (preadv2, 2, 1),
+  ADD_TEST (pwritev, 2, 1),
+  ADD_TEST (pwritev2, 2, 1),
+  ADD_TEST (open, 2, 1),
+  ADD_TEST (close, 2, 1),
+  ADD_TEST (pread, 2, 1),
+  ADD_TEST (pwrite, 2, 1),
+  ADD_TEST (fsync, 2, 1),
+  ADD_TEST (fdatasync, 2, 1),
+  ADD_TEST (msync, 2, 1),
+  ADD_TEST (sendto, 2, 1),
+  ADD_TEST (sendmsg, 2, 1),
+  ADD_TEST (creat, 2, 1),
+  ADD_TEST (connect, 2, 1),
+  ADD_TEST (tcdrain, 2, 1),
+  ADD_TEST (msgrcv, 2, 0),
+  ADD_TEST (msgsnd, 2, 1),
+};
+#define ntest_tf (sizeof (tests) / sizeof (tests[0]))
+
+#include "tst-cancel4-common.c"
diff --git a/sysdeps/pthread/tst-cancel5.c b/sysdeps/pthread/tst-cancel5.c
new file mode 100644
index 0000000000..1c879eba8b
--- /dev/null
+++ b/sysdeps/pthread/tst-cancel5.c
@@ -0,0 +1 @@
+#include "tst-cancel4.c"
diff --git a/sysdeps/pthread/tst-cancelx4.c b/sysdeps/pthread/tst-cancelx4.c
new file mode 100644
index 0000000000..1c879eba8b
--- /dev/null
+++ b/sysdeps/pthread/tst-cancelx4.c
@@ -0,0 +1 @@
+#include "tst-cancel4.c"
diff --git a/sysdeps/pthread/tst-cancelx5.c b/sysdeps/pthread/tst-cancelx5.c
new file mode 100644
index 0000000000..c0a18840a0
--- /dev/null
+++ b/sysdeps/pthread/tst-cancelx5.c
@@ -0,0 +1 @@
+#include "tst-cancel5.c"