diff mbox series

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

Message ID 20210811200133.3869287-5-adhemerval.zanella@linaro.org
State Superseded
Headers show
Series Add CLOCK_MONOTONIC support for PI mutexes | expand

Checks

Context Check Description
dj/TryBot-apply_patch success Patch applied to master at the time it was sent
dj/TryBot-32bit success Build for i686

Commit Message

Adhemerval Zanella Aug. 11, 2021, 8:01 p.m. UTC
With FUTEX_LOCK_PI2 support we can now proper support CLOCK_MONOTONIC
for pthread_mutex_clocklock with Priority Inheritance.  If kernel
does not support, EINVAL is returned instead as previously.  The
difference is the futex operation will be issued and the kernel will
advertise the missing support.

Checked on x86_64-linux-gnu and i686-linux-gnu on Linux 5.14, 5.11,
and 4.15.
---
 nptl/pthread_mutex_timedlock.c |  7 ------
 nptl/tst-mutexpi10.c           | 42 +++++++++++++++++++++-------------
 sysdeps/pthread/tst-mutex5.c   | 23 ++++++++++++-------
 sysdeps/pthread/tst-mutex9.c   | 20 ++++++++++------
 4 files changed, 54 insertions(+), 38 deletions(-)
diff mbox series

Patch

diff --git a/nptl/pthread_mutex_timedlock.c b/nptl/pthread_mutex_timedlock.c
index ca51da6f6c..a2fd1ada7b 100644
--- a/nptl/pthread_mutex_timedlock.c
+++ b/nptl/pthread_mutex_timedlock.c
@@ -300,13 +300,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 7dc5331cfc..5ca8a45eda 100644
--- a/sysdeps/pthread/tst-mutex5.c
+++ b/sysdeps/pthread/tst-mutex5.c
@@ -26,6 +26,7 @@ 
 #include <config.h>
 #include <support/check.h>
 #include <support/timespec.h>
+#include <support/xthread.h>
 
 #ifdef ENABLE_PP
 #include "tst-tpp.h"
@@ -40,7 +41,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;
@@ -77,11 +78,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;
@@ -120,11 +122,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
+    xpthread_mutex_pi_support_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 58c3a1aec2..5448e4ec16 100644
--- a/sysdeps/pthread/tst-mutex9.c
+++ b/sysdeps/pthread/tst-mutex9.c
@@ -29,6 +29,7 @@ 
 #include <support/check.h>
 #include <support/timespec.h>
 #include <support/xunistd.h>
+#include <support/xthread.h>
 
 #ifdef ENABLE_PP
 #include "tst-tpp.h"
@@ -40,7 +41,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;
@@ -112,9 +113,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);
 
@@ -142,11 +143,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
+    xpthread_mutex_pi_support_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;
 }