nptl: Add CLOCK_MONOTONIC support for PI mutexes

Linux added FUTEX_LOCK_PI2 to support clock selection
(commit bf22a6976897977b0a3f1aeba6823c959fc4fdae).  With the new
flag we can now proper support CLOCK_MONOTONIC for
pthread_mutex_clocklock with Priority Inheritance.  If kernel
does not support, EINVAL is returned instead.

The difference is the futex operation will be issued and the kernel
will advertise the missing support (instead of hard-code error
return).

Checked on x86_64-linux-gnu and i686-linux-gnu on Linux 5.14, 5.11,
and 4.15.

diff --git a/nptl/pthread_mutex_timedlock.c b/nptl/pthread_mutex_timedlock.c
index a695faeb7e955a6354e66467277a5ffe5c7429fa..57f3f2886912487f267b31dc45898760d4ca40dc 100644 (file)
--- 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 da781d0d7a9322cfc2fe99735ba573b340ccd3ca..34a7bea21bcf5bee91d6bd1775bba64d205802e9 100644 (file)
--- 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 b2a06b36501a4392bd04081a3965075defde75b8..89ad03fd8f7e51154ed55bda897018fd692b1583 100644 (file)
--- 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 63bac69b6dd14a01eb89185455beb1f32632f4ed..b29d6efcc848282e336f688af865038d8686940e 100644 (file)
--- 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;
 }