[v3,4/4] nptl: Add CLOCK_MONOTONIC support for PI mutexes

diff --git a/nptl/pthread_mutex_timedlock.c b/nptl/pthread_mutex_timedlock.c
index a695faeb7e..57f3f28869 100644
--- a/nptl/pthread_mutex_timedlock.c
+++ b/nptl/pthread_mutex_timedlock.c
@@ -299,13 +299,6 @@  __pthread_mutex_clocklock_common (pthread_mutex_t *mutex,
     case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:
     case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:
       {
-	/* Currently futex FUTEX_LOCK_PI operation only provides support for
-	   CLOCK_REALTIME and trying to emulate by converting a
-	   CLOCK_MONOTONIC to CLOCK_REALTIME will take in account possible
-	   changes to the wall clock.  */
-	if (__glibc_unlikely (clockid != CLOCK_REALTIME))
-	  return EINVAL;
-
 	int kind, robust;
 	{
 	  /* See concurrency notes regarding __kind in struct __pthread_mutex_s
diff --git a/nptl/tst-mutexpi10.c b/nptl/tst-mutexpi10.c
index da781d0d7a..34a7bea21b 100644
--- a/nptl/tst-mutexpi10.c
+++ b/nptl/tst-mutexpi10.c
@@ -38,29 +38,39 @@  do_test (void)
     PTHREAD_MUTEX_STALLED,
     PTHREAD_MUTEX_ROBUST
   };
-
+  const struct {
+    int clk;
+    int r;
+  } clocks[] = {
+    { CLOCK_REALTIME,         0 },
+    { CLOCK_MONOTONIC,        0 },
+    { CLOCK_REALTIME_COARSE,  EINVAL }
+  };
 
   for (int t = 0; t < array_length (types); t++)
     for (int r = 0; r < array_length (robust); r++)
-      {
-	pthread_mutexattr_t attr;
-
-	xpthread_mutexattr_init (&attr);
-	xpthread_mutexattr_setprotocol (&attr, PTHREAD_PRIO_INHERIT);
-	xpthread_mutexattr_settype (&attr, types[t]);
-	xpthread_mutexattr_setrobust (&attr, robust[r]);
+      for (int c = 0; c < array_length (clocks); c++)
+	{
+	  pthread_mutexattr_t attr;
+	  xpthread_mutexattr_init (&attr);
+	  xpthread_mutexattr_setprotocol (&attr, PTHREAD_PRIO_INHERIT);
+	  xpthread_mutexattr_settype (&attr, types[t]);
+	  xpthread_mutexattr_setrobust (&attr, robust[r]);
 
-	pthread_mutex_t mtx;
-	xpthread_mutex_init (&mtx, &attr);
+	  pthread_mutex_t mtx;
+	  xpthread_mutex_init (&mtx, &attr);
 
-	struct timespec tmo = timespec_add (xclock_now (CLOCK_MONOTONIC),
-					    make_timespec (0, 100000000));
+	  /* Uncontended case does not trigger any futex call.  */
+	  struct timespec tmo = timespec_add (xclock_now (clocks[c].clk),
+					      make_timespec (0, 100000000));
 
-	TEST_COMPARE (pthread_mutex_clocklock (&mtx, CLOCK_MONOTONIC, &tmo),
-		      EINVAL);
+	  TEST_COMPARE (pthread_mutex_clocklock (&mtx, clocks[c].clk, &tmo),
+			clocks[c].r);
+	  if (clocks[c].r == 0)
+	    TEST_COMPARE (pthread_mutex_unlock (&mtx), 0);
 
-	xpthread_mutex_destroy (&mtx);
-      }
+	  xpthread_mutex_destroy (&mtx);
+	}
 
   return 0;
 }
diff --git a/sysdeps/pthread/tst-mutex5.c b/sysdeps/pthread/tst-mutex5.c
index b2a06b3650..89ad03fd8f 100644
--- a/sysdeps/pthread/tst-mutex5.c
+++ b/sysdeps/pthread/tst-mutex5.c
@@ -25,6 +25,7 @@ 
 #include <config.h>
 #include <support/check.h>
 #include <support/timespec.h>
+#include <support/xthread.h>
 
 #ifdef ENABLE_PP
 #include "tst-tpp.h"
@@ -39,7 +40,7 @@ 
 #define CLOCK_USE_TIMEDLOCK (-1)
 
 static int
-do_test_clock (clockid_t clockid, const char *fnname)
+do_test_clock (clockid_t clockid, const char *fnname, int tmo_result)
 {
   pthread_mutex_t m;
   pthread_mutexattr_t a;
@@ -76,11 +77,12 @@  do_test_clock (clockid_t clockid, const char *fnname)
                                              make_timespec (2, 0));
 
   if (clockid == CLOCK_USE_TIMEDLOCK)
-    TEST_COMPARE (pthread_mutex_timedlock (&m, &ts_timeout), ETIMEDOUT);
+    TEST_COMPARE (pthread_mutex_timedlock (&m, &ts_timeout), tmo_result);
   else
     TEST_COMPARE (pthread_mutex_clocklock (&m, clockid, &ts_timeout),
-		  ETIMEDOUT);
-  TEST_TIMESPEC_BEFORE_NOW (ts_timeout, clockid_for_get);
+		  tmo_result);
+  if (tmo_result == ETIMEDOUT)
+    TEST_TIMESPEC_BEFORE_NOW (ts_timeout, clockid_for_get);
 
   /* The following makes the ts value invalid.  */
   ts_timeout.tv_nsec += 1000000000;
@@ -119,11 +121,16 @@  static int do_test (void)
   init_tpp_test ();
 #endif
 
-  do_test_clock (CLOCK_USE_TIMEDLOCK, "timedlock");
-  do_test_clock (CLOCK_REALTIME, "clocklock(realtime)");
-#ifndef ENABLE_PI
-  do_test_clock (CLOCK_MONOTONIC, "clocklock(monotonic)");
+  int monotonic_result =
+#ifdef ENABLE_PI
+    support_mutex_pi_monotonic () ? ETIMEDOUT : EINVAL;
+#else
+    ETIMEDOUT;
 #endif
+
+  do_test_clock (CLOCK_USE_TIMEDLOCK, "timedlock", ETIMEDOUT);
+  do_test_clock (CLOCK_REALTIME, "clocklock(realtime)", ETIMEDOUT);
+  do_test_clock (CLOCK_MONOTONIC, "clocklock(monotonic)", monotonic_result);
   return 0;
 }
 
diff --git a/sysdeps/pthread/tst-mutex9.c b/sysdeps/pthread/tst-mutex9.c
index 63bac69b6d..b29d6efcc8 100644
--- a/sysdeps/pthread/tst-mutex9.c
+++ b/sysdeps/pthread/tst-mutex9.c
@@ -28,6 +28,7 @@ 
 #include <support/check.h>
 #include <support/timespec.h>
 #include <support/xunistd.h>
+#include <support/xthread.h>
 
 #ifdef ENABLE_PP
 #include "tst-tpp.h"
@@ -39,7 +40,7 @@ 
 #define CLOCK_USE_TIMEDLOCK (-1)
 
 static void
-do_test_clock (clockid_t clockid)
+do_test_clock (clockid_t clockid, int tmo_result)
 {
   const clockid_t clockid_for_get =
     (clockid == CLOCK_USE_TIMEDLOCK) ? CLOCK_REALTIME : clockid;
@@ -111,9 +112,9 @@  do_test_clock (clockid_t clockid)
                                                make_timespec (0, 500000000));
 
       if (clockid == CLOCK_USE_TIMEDLOCK)
-        TEST_COMPARE (pthread_mutex_timedlock (m, &ts), ETIMEDOUT);
+        TEST_COMPARE (pthread_mutex_timedlock (m, &ts), tmo_result);
       else
-        TEST_COMPARE (pthread_mutex_clocklock (m, clockid, &ts), ETIMEDOUT);
+        TEST_COMPARE (pthread_mutex_clocklock (m, clockid, &ts), tmo_result);
 
       alarm (1);
 
@@ -141,11 +142,16 @@  do_test (void)
   init_tpp_test ();
 #endif
 
-  do_test_clock (CLOCK_USE_TIMEDLOCK);
-  do_test_clock (CLOCK_REALTIME);
-#ifndef ENABLE_PI
-  do_test_clock (CLOCK_MONOTONIC);
+  int monotonic_result =
+#ifdef ENABLE_PI
+    support_mutex_pi_monotonic () ? ETIMEDOUT : EINVAL;
+#else
+    ETIMEDOUT;
 #endif
+
+  do_test_clock (CLOCK_USE_TIMEDLOCK, ETIMEDOUT);
+  do_test_clock (CLOCK_REALTIME, ETIMEDOUT);
+  do_test_clock (CLOCK_MONOTONIC, monotonic_result);
   return 0;
 }