nptl: Add pthread_clockjoin_np

Introduce pthread_clockjoin_np as a version of pthread_timedjoin_np that
accepts a clockid_t parameter to indicate which clock the timeout should be
measured against. This mirrors the recently-added POSIX-proposed "clock"
wait functions.

Checked on x86_64-linux-gnu.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

15 files changed, 181 insertions, 28 deletions

diff --git a/nptl/Makefile b/nptl/Makefile
index 41f8f5e8d2..bbb281e733 100644
--- a/nptl/Makefile
+++ b/nptl/Makefile
@@ -53,7 +53,7 @@ pthread-compat-wrappers = \
 libpthread-routines = nptl-init nptlfreeres vars events version pt-interp \
 		      pthread_create pthread_exit pthread_detach \
 		      pthread_join pthread_tryjoin pthread_timedjoin \
-		      pthread_join_common pthread_yield \
+		      pthread_clockjoin pthread_join_common pthread_yield \
 		      pthread_getconcurrency pthread_setconcurrency \
 		      pthread_getschedparam pthread_setschedparam \
 		      pthread_setschedprio \
@@ -189,6 +189,7 @@ CFLAGS-forward.c += -fexceptions
 CFLAGS-pthread_testcancel.c += -fexceptions
 CFLAGS-pthread_join.c += -fexceptions -fasynchronous-unwind-tables
 CFLAGS-pthread_timedjoin.c += -fexceptions -fasynchronous-unwind-tables
+CFLAGS-pthread_clockjoin.c += -fexceptions -fasynchronous-unwind-tables
 CFLAGS-pthread_once.c += $(uses-callbacks) -fexceptions \
 			-fasynchronous-unwind-tables
 CFLAGS-pthread_cond_wait.c += -fexceptions -fasynchronous-unwind-tables
@@ -273,7 +274,7 @@ tests = tst-attr1 tst-attr2 tst-attr3 tst-default-attr \
 	tst-kill1 tst-kill2 tst-kill3 tst-kill4 tst-kill5 tst-kill6 \
 	tst-raise1 \
 	tst-join1 tst-join2 tst-join3 tst-join4 tst-join5 tst-join6 tst-join7 \
-	tst-join8 tst-join9 \
+	tst-join8 tst-join9 tst-join10 tst-join11 tst-join12 tst-join13 \
 	tst-detach1 \
 	tst-eintr2 tst-eintr3 tst-eintr4 tst-eintr5 \
 	tst-tsd1 tst-tsd2 tst-tsd3 tst-tsd4 tst-tsd5 tst-tsd6 \
diff --git a/nptl/Versions b/nptl/Versions
index be7e810875..adbd4fa589 100644
--- a/nptl/Versions
+++ b/nptl/Versions
@@ -277,6 +277,10 @@ libpthread {
     pthread_mutex_clocklock;
   }
 
+  GLIBC_2.31 {
+    pthread_clockjoin_np;
+  }
+
   GLIBC_PRIVATE {
     __pthread_initialize_minimal;
     __pthread_clock_gettime; __pthread_clock_settime;
diff --git a/nptl/pthreadP.h b/nptl/pthreadP.h
index 070b3afa8d..bbb2bf0222 100644
--- a/nptl/pthreadP.h
+++ b/nptl/pthreadP.h
@@ -475,8 +475,10 @@ extern int __pthread_setcanceltype (int type, int *oldtype);
 extern int __pthread_enable_asynccancel (void) attribute_hidden;
 extern void __pthread_disable_asynccancel (int oldtype) attribute_hidden;
 extern void __pthread_testcancel (void);
-extern int __pthread_timedjoin_ex (pthread_t, void **, const struct timespec *,
-				   bool);
+extern int __pthread_clockjoin_ex (pthread_t, void **, clockid_t,
+				   const struct timespec *, bool)
+  attribute_hidden;
+
 
 #if IS_IN (libpthread)
 hidden_proto (__pthread_mutex_init)
@@ -495,7 +497,6 @@ hidden_proto (__pthread_setcancelstate)
 hidden_proto (__pthread_testcancel)
 hidden_proto (__pthread_mutexattr_init)
 hidden_proto (__pthread_mutexattr_settype)
-hidden_proto (__pthread_timedjoin_ex)
 #endif
 
 extern int __pthread_cond_broadcast_2_0 (pthread_cond_2_0_t *cond);
diff --git a/nptl/pthread_clockjoin.c b/nptl/pthread_clockjoin.c
new file mode 100644
index 0000000000..7c8c3ac564
--- /dev/null
+++ b/nptl/pthread_clockjoin.c
@@ -0,0 +1,29 @@
+/* Join with a terminated thread using an specific clock.
+   Copyright (C) 2019 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
+   <http://www.gnu.org/licenses/>.  */
+
+#include "pthreadP.h"
+
+int
+__pthread_clockjoin_np (pthread_t threadid, void **thread_return,
+			clockid_t clockid,
+			const struct timespec *abstime)
+{
+  return __pthread_clockjoin_ex (threadid, thread_return,
+                                 clockid, abstime, true);
+}
+weak_alias (__pthread_clockjoin_np, pthread_clockjoin_np)
diff --git a/nptl/pthread_join.c b/nptl/pthread_join.c
index 3523b20fe5..c7ff5a393b 100644
--- a/nptl/pthread_join.c
+++ b/nptl/pthread_join.c
@@ -21,6 +21,7 @@
 int
 __pthread_join (pthread_t threadid, void **thread_return)
 {
-  return __pthread_timedjoin_ex (threadid, thread_return, NULL, true);
+  return __pthread_clockjoin_ex (threadid, thread_return, 0 /* Ignored */,
+				 NULL, true);
 }
 weak_alias (__pthread_join, pthread_join)
diff --git a/nptl/pthread_join_common.c b/nptl/pthread_join_common.c
index 4d91c6fbf2..998d227e2c 100644
--- a/nptl/pthread_join_common.c
+++ b/nptl/pthread_join_common.c
@@ -37,7 +37,7 @@ cleanup (void *arg)
    afterwards.  The kernel up to version 3.16.3 does not use the private futex
    operations for futex wake-up when the clone terminates.  */
 static int
-timedwait_tid (pid_t *tidp, const struct timespec *abstime)
+clockwait_tid (pid_t *tidp, clockid_t clockid, const struct timespec *abstime)
 {
   pid_t tid;
 
@@ -49,8 +49,10 @@ timedwait_tid (pid_t *tidp, const struct timespec *abstime)
     {
       struct timespec rt;
 
-      /* Get the current time.  */
-      __clock_gettime (CLOCK_REALTIME, &rt);
+      /* Get the current time. This can only fail if clockid is
+         invalid. */
+      if (__glibc_unlikely (__clock_gettime (clockid, &rt)))
+        return EINVAL;
 
       /* Compute relative timeout.  */
       rt.tv_sec = abstime->tv_sec - rt.tv_sec;
@@ -77,7 +79,8 @@ timedwait_tid (pid_t *tidp, const struct timespec *abstime)
 }
 
 int
-__pthread_timedjoin_ex (pthread_t threadid, void **thread_return,
+__pthread_clockjoin_ex (pthread_t threadid, void **thread_return,
+			clockid_t clockid,
 			const struct timespec *abstime, bool block)
 {
   struct pthread *pd = (struct pthread *) threadid;
@@ -122,7 +125,7 @@ __pthread_timedjoin_ex (pthread_t threadid, void **thread_return,
 
   /* BLOCK waits either indefinitely or based on an absolute time.  POSIX also
      states a cancellation point shall occur for pthread_join, and we use the
-     same rationale for posix_timedjoin_np.  Both timedwait_tid and the futex
+     same rationale for posix_timedjoin_np.  Both clockwait_tid and the futex
      call use the cancellable variant.  */
   if (block)
     {
@@ -132,7 +135,7 @@ __pthread_timedjoin_ex (pthread_t threadid, void **thread_return,
       pthread_cleanup_push (cleanup, &pd->joinid);
 
       if (abstime != NULL)
-	result = timedwait_tid (&pd->tid, abstime);
+	result = clockwait_tid (&pd->tid, clockid, abstime);
       else
 	{
 	  pid_t tid;
@@ -165,4 +168,3 @@ __pthread_timedjoin_ex (pthread_t threadid, void **thread_return,
 
   return result;
 }
-hidden_def (__pthread_timedjoin_ex)
diff --git a/nptl/pthread_timedjoin.c b/nptl/pthread_timedjoin.c
index bb48a1e3cf..1890d1aec6 100644
--- a/nptl/pthread_timedjoin.c
+++ b/nptl/pthread_timedjoin.c
@@ -22,6 +22,7 @@ int
 __pthread_timedjoin_np (pthread_t threadid, void **thread_return,
 			const struct timespec *abstime)
 {
-  return __pthread_timedjoin_ex (threadid, thread_return, abstime, true);
+  return __pthread_clockjoin_ex (threadid, thread_return,
+                                 CLOCK_REALTIME, abstime, true);
 }
 weak_alias (__pthread_timedjoin_np, pthread_timedjoin_np)
diff --git a/nptl/pthread_tryjoin.c b/nptl/pthread_tryjoin.c
index 28e765ba60..a15fd5fab0 100644
--- a/nptl/pthread_tryjoin.c
+++ b/nptl/pthread_tryjoin.c
@@ -28,5 +28,6 @@ pthread_tryjoin_np (pthread_t threadid, void **thread_return)
 
   /* If pd->tid == 0 then lll_wait_tid will not block on futex
      operation.  */
-  return __pthread_timedjoin_ex (threadid, thread_return, NULL, false);
+  return __pthread_clockjoin_ex (threadid, thread_return, 0 /* Ignored */,
+				 NULL, false);
 }
diff --git a/nptl/thrd_join.c b/nptl/thrd_join.c
index 497d0d2173..10d9a72cc8 100644
--- a/nptl/thrd_join.c
+++ b/nptl/thrd_join.c
@@ -22,7 +22,7 @@ int
 thrd_join (thrd_t thr, int *res)
 {
   void *pthread_res;
-  int err_code = __pthread_timedjoin_ex (thr, &pthread_res, NULL, true);
+  int err_code = __pthread_clockjoin_ex (thr, &pthread_res, 0, NULL, true);
   if (res)
    *res = (int) (uintptr_t) pthread_res;
 
diff --git a/nptl/tst-join10.c b/nptl/tst-join10.c
new file mode 100644
index 0000000000..a222dd1f70
--- /dev/null
+++ b/nptl/tst-join10.c
@@ -0,0 +1,20 @@
+/* Check if pthread_clockjoin_np is a cancellation entrypoint.
+   Copyright (C) 2019 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
+   <http://www.gnu.org/licenses/>.  */
+
+#define USE_PTHREAD_CLOCKJOIN_NP_REALTIME 1
+#include <nptl/tst-join5.c>
diff --git a/nptl/tst-join11.c b/nptl/tst-join11.c
new file mode 100644
index 0000000000..341588a3cb
--- /dev/null
+++ b/nptl/tst-join11.c
@@ -0,0 +1,21 @@
+/* Check if pthread_clockjoin_np is a cancellation entrypoint.
+   Copyright (C) 2019 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
+   <http://www.gnu.org/licenses/>.  */
+
+#define USE_PTHREAD_CLOCKJOIN_NP_REALTIME 1
+#define WAIT_IN_CHILD 1
+#include <nptl/tst-join5.c>
diff --git a/nptl/tst-join12.c b/nptl/tst-join12.c
new file mode 100644
index 0000000000..44592dc546
--- /dev/null
+++ b/nptl/tst-join12.c
@@ -0,0 +1,20 @@
+/* Check if pthread_clockjoin_np is a cancellation entrypoint.
+   Copyright (C) 2019 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
+   <http://www.gnu.org/licenses/>.  */
+
+#define USE_PTHREAD_CLOCKJOIN_NP_MONOTONIC 1
+#include <nptl/tst-join5.c>
diff --git a/nptl/tst-join13.c b/nptl/tst-join13.c
new file mode 100644
index 0000000000..d4e49d58e6
--- /dev/null
+++ b/nptl/tst-join13.c
@@ -0,0 +1,21 @@
+/* Check if pthread_clockjoin_np is a cancellation entrypoint.
+   Copyright (C) 2019 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
+   <http://www.gnu.org/licenses/>.  */
+
+#define USE_PTHREAD_CLOCKJOIN_NP_MONOTONIC 1
+#define WAIT_IN_CHILD 1
+#include <nptl/tst-join5.c>
diff --git a/nptl/tst-join3.c b/nptl/tst-join3.c
index a4ae459543..faf7683eaa 100644
--- a/nptl/tst-join3.c
+++ b/nptl/tst-join3.c
@@ -28,6 +28,8 @@
 #include <support/xtime.h>
 
 
+#define CLOCK_USE_TIMEDJOIN (-1)
+
 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
 
@@ -35,32 +37,44 @@ static void *
 tf (void *arg)
 {
   xpthread_mutex_lock (&lock);
+  xpthread_mutex_unlock (&lock);
 
   return (void *) 42l;
 }
 
 
 static int
-do_test (void)
+do_test_clock (clockid_t clockid)
 {
+  const clockid_t clockid_for_get =
+    (clockid == CLOCK_USE_TIMEDJOIN) ? CLOCK_REALTIME : clockid;
+
   xpthread_mutex_lock (&lock);
   pthread_t th = xpthread_create (NULL, tf, NULL);
 
   void *status;
-  struct timespec timeout = timespec_add (xclock_now (CLOCK_REALTIME),
+  struct timespec timeout = timespec_add (xclock_now (clockid_for_get),
                                           make_timespec (0, 200000000));
 
-  int val = pthread_timedjoin_np (th, &status, &timeout);
+  int val;
+  if (clockid == CLOCK_USE_TIMEDJOIN)
+    val = pthread_timedjoin_np (th, &status, &timeout);
+  else
+    val = pthread_clockjoin_np (th, &status, clockid, &timeout);
+
   TEST_COMPARE (val, ETIMEDOUT);
 
   xpthread_mutex_unlock (&lock);
 
   while (1)
     {
-      timeout = timespec_add (xclock_now (CLOCK_REALTIME),
+      timeout = timespec_add (xclock_now (clockid_for_get),
                               make_timespec (0, 200000000));
 
-      val = pthread_timedjoin_np (th, &status, &timeout);
+      if (clockid == CLOCK_USE_TIMEDJOIN)
+        val = pthread_timedjoin_np (th, &status, &timeout);
+      else
+        val = pthread_clockjoin_np (th, &status, clockid, &timeout);
       if (val == 0)
 	break;
 
@@ -73,4 +87,13 @@ do_test (void)
   return 0;
 }
 
+static int
+do_test (void)
+{
+  do_test_clock (CLOCK_USE_TIMEDJOIN);
+  do_test_clock (CLOCK_REALTIME);
+  do_test_clock (CLOCK_MONOTONIC);
+  return 0;
+}
+
 #include <support/test-driver.c>
diff --git a/nptl/tst-join5.c b/nptl/tst-join5.c
index 41cacf1251..2fa178cc90 100644
--- a/nptl/tst-join5.c
+++ b/nptl/tst-join5.c
@@ -24,7 +24,9 @@
 #include <unistd.h>
 
 #include <support/check.h>
+#include <support/timespec.h>
 #include <support/xthread.h>
+#include <support/xtime.h>
 
 static void
 wait_code (void)
@@ -42,14 +44,20 @@ static pthread_barrier_t b;
 static int
 thread_join (pthread_t thread, void **retval)
 {
-#ifdef USE_PTHREAD_TIMEDJOIN_NP
-  struct timespec tv;
-  TEST_COMPARE (clock_gettime (CLOCK_REALTIME, &tv), 0);
-  /* Arbitrary large timeout to make it act as pthread_join.  */
-  tv.tv_sec += 1000;
-  return pthread_timedjoin_np ((pthread_t) thread, retval, &tv);
+#if defined USE_PTHREAD_TIMEDJOIN_NP
+  const struct timespec ts = timespec_add (xclock_now (CLOCK_REALTIME),
+                                           make_timespec (1000, 0));
+  return pthread_timedjoin_np (thread, retval, &ts);
+#elif defined USE_PTHREAD_CLOCKJOIN_NP_REALTIME
+  const struct timespec ts = timespec_add (xclock_now (CLOCK_REALTIME),
+                                           make_timespec (1000, 0));
+  return pthread_clockjoin_np (thread, retval, CLOCK_REALTIME, &ts);
+#elif defined USE_PTHREAD_CLOCKJOIN_NP_MONOTONIC
+  const struct timespec ts = timespec_add (xclock_now (CLOCK_MONOTONIC),
+                                           make_timespec (1000, 0));
+  return pthread_clockjoin_np (thread, retval, CLOCK_MONOTONIC, &ts);
 #else
-  return pthread_join ((pthread_t) thread, retval);
+  return pthread_join (thread, retval);
 #endif
 }