AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-11-08 22:30:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

nptl: Add CLOCK_MONOTONIC support for PI mutexes

Browse Source 
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.
This commit is contained in:
Adhemerval Zanella 2021-08-11 18:17:41 +00:00
parent 9cba3fa34b
commit 2313ab153d
4 changed files with 54 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
nptl/pthread_mutex_timedlock.c
View File

@ -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

42
nptl/tst-mutexpi10.c
View File

@ -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;
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]);
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);
/* Uncontended case does not trigger any futex call. */
struct timespec tmo = timespec_add (xclock_now (clocks[c].clk),
make_timespec (0, 100000000));
struct timespec tmo = timespec_add (xclock_now (CLOCK_MONOTONIC),
make_timespec (0, 100000000));
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);
TEST_COMPARE (pthread_mutex_clocklock (&mtx, CLOCK_MONOTONIC, &tmo),
EINVAL);
xpthread_mutex_destroy (&mtx);
}
xpthread_mutex_destroy (&mtx);
}
return 0;
}

23
sysdeps/pthread/tst-mutex5.c
View File

@ -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;
}

20
sysdeps/pthread/tst-mutex9.c
View File

@ -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;
}