mirror of
https://sourceware.org/git/glibc.git
synced 2025-07-29 11:41:21 +03:00
nptl: Add POSIX-proposed pthread_rwlock_clockrdlock & pthread_rwlock_clockwrlock
Add:
int pthread_rwlock_clockrdlock (pthread_rwlock_t *rwlock,
clockid_t clockid,
const struct timespec *abstime)
and:
int pthread_rwlock_clockwrlock (pthread_rwlock_t *rwlock,
clockid_t clockid,
const struct timespec *abstime)
which behave like pthread_rwlock_timedrdlock and
pthread_rwlock_timedwrlock respectively, except they always measure
abstime against the supplied clockid. The functions currently support
CLOCK_REALTIME and CLOCK_MONOTONIC and return EINVAL if any other
clock is specified.
* sysdeps/nptl/pthread.h: Add pthread_rwlock_clockrdlock and
pthread_wrlock_clockwrlock.
* nptl/Makefile: Build pthread_rwlock_clockrdlock.c and
pthread_rwlock_clockwrlock.c.
* nptl/pthread_rwlock_clockrdlock.c: Implement
pthread_rwlock_clockrdlock.
* nptl/pthread_rwlock_clockwrlock.c: Implement
pthread_rwlock_clockwrlock.
* nptl/pthread_rwlock_common.c (__pthread_rwlock_rdlock_full): Add
clockid parameter and verify that it indicates a supported clock on
entry so that we fail even if it doesn't end up being used. Pass
that clock on to futex_abstimed_wait when necessary.
(__pthread_rwlock_wrlock_full): Likewise.
* nptl/pthread_rwlock_rdlock.c: (__pthread_rwlock_rdlock): Pass
CLOCK_REALTIME to __pthread_rwlock_rdlock_full even though it won't
be used because there's no timeout.
* nptl/pthread_rwlock_wrlock.c (__pthread_rwlock_wrlock): Pass
CLOCK_REALTIME to __pthread_rwlock_wrlock_full even though it won't
be used because there is no timeout.
* nptl/pthread_rwlock_timedrdlock.c (pthread_rwlock_timedrdlock):
Pass CLOCK_REALTIME to __pthread_rwlock_rdlock_full since abstime
uses that clock.
* nptl/pthread_rwlock_timedwrlock.c (pthread_rwlock_timedwrlock):
Pass CLOCK_REALTIME to __pthread_rwlock_wrlock_full since abstime
uses that clock.
* sysdeps/unix/sysv/linux/aarch64/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/alpha/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/arm/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/csky/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/hppa/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/i386/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/ia64/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/m68k/coldfire/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/m68k/m680x0/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/microblaze/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/mips/mips32/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/mips/mips64/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/nios2/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc32/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc64/be/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/powerpc/powerpc64/le/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/riscv/rv64/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/s390/s390-32/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/s390/s390-64/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/sh/libpthread.abilist (GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/sparc/sparc32/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/sparc/sparc64/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/x86_64/64/libpthread.abilist
(GLIBC_2.30): Likewise.
* sysdeps/unix/sysv/linux/x86_64/x32/libpthread.abilist
(GLIBC_2.30): Likewise.
* nptl/tst-abstime.c (th): Add pthread_rwlock_clockrdlock and
pthread_rwlock_clockwrlock timeout tests to match the existing
pthread_rwlock_timedrdloock and pthread_rwlock_timedwrlock tests.
* nptl/tst-rwlock14.c (do_test): Likewise.
* nptl/tst-rwlock6.c Invent verbose_printf macro, and use for
ancillary output throughout. (tf): Accept thread_args structure so
that rwlock, a clockid and function name can be passed to the
thread. (do_test_clock): Rename from do_test. Accept clockid
parameter to specify test clock. Use the magic clockid value of
CLOCK_USE_TIMEDLOCK to indicate that pthread_rwlock_timedrdlock and
pthread_rwlock_timedwrlock should be tested, otherwise pass the
specified clockid to pthread_rwlock_clockrdlock and
pthread_rwlock_clockwrlock. Use xpthread_create and xpthread_join.
(do_test): Call do_test_clock to test each clockid in turn.
* nptl/tst-rwlock7.c: Likewise.
* nptl/tst-rwlock9.c (writer_thread, reader_thread): Accept
thread_args structure so that the (now int) thread number, the
clockid and the function name can be passed to the thread.
(do_test_clock): Renamed from do_test. Pass the necessary
thread_args when creating the reader and writer threads. Use
xpthread_create and xpthread_join.
(do_test): Call do_test_clock to test each clockid in turn.
* manual/threads.texi: Add documentation for
pthread_rwlock_clockrdlock and pthread_rwlock_clockwrclock.
Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>
This commit is contained in:
Mike Crowe
committed by
Adhemerval Zanella
Adhemerval Zanella
parent
600b4be4d9
commit
e996fa72a9
@ -278,17 +278,19 @@ __pthread_rwlock_rdunlock (pthread_rwlock_t *rwlock)
|
||||
|
||||
static __always_inline int
|
||||
__pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,
|
||||
clockid_t clockid,
|
||||
const struct timespec *abstime)
|
||||
{
|
||||
unsigned int r;
|
||||
|
||||
/* Make sure any passed in timeout value is valid. Note that the previous
|
||||
implementation assumed that this check *must* not be performed if there
|
||||
would in fact be no blocking; however, POSIX only requires that "the
|
||||
validity of the abstime parameter need not be checked if the lock can be
|
||||
immediately acquired" (i.e., we need not but may check it). */
|
||||
if (abstime
|
||||
&& __glibc_unlikely (abstime->tv_nsec >= 1000000000
|
||||
/* Make sure any passed in clockid and timeout value are valid. Note that
|
||||
the previous implementation assumed that this check *must* not be
|
||||
performed if there would in fact be no blocking; however, POSIX only
|
||||
requires that "the validity of the abstime parameter need not be checked
|
||||
if the lock can be immediately acquired" (i.e., we need not but may check
|
||||
it). */
|
||||
if (abstime && __glibc_unlikely (!futex_abstimed_supported_clockid (clockid)
|
||||
|| abstime->tv_nsec >= 1000000000
|
||||
|| abstime->tv_nsec < 0))
|
||||
return EINVAL;
|
||||
|
||||
@ -329,7 +331,7 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,
|
||||
{
|
||||
int private = __pthread_rwlock_get_private (rwlock);
|
||||
int err = futex_abstimed_wait (&rwlock->__data.__readers,
|
||||
r, CLOCK_REALTIME, abstime, private);
|
||||
r, clockid, abstime, private);
|
||||
/* We ignore EAGAIN and EINTR. On time-outs, we can just
|
||||
return because we don't need to clean up anything. */
|
||||
if (err == ETIMEDOUT)
|
||||
@ -457,7 +459,7 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,
|
||||
continue;
|
||||
int err = futex_abstimed_wait (&rwlock->__data.__wrphase_futex,
|
||||
1 | PTHREAD_RWLOCK_FUTEX_USED,
|
||||
CLOCK_REALTIME, abstime, private);
|
||||
clockid, abstime, private);
|
||||
if (err == ETIMEDOUT)
|
||||
{
|
||||
/* If we timed out, we need to unregister. If no read phase
|
||||
@ -584,15 +586,17 @@ __pthread_rwlock_wrunlock (pthread_rwlock_t *rwlock)
|
||||
|
||||
static __always_inline int
|
||||
__pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,
|
||||
clockid_t clockid,
|
||||
const struct timespec *abstime)
|
||||
{
|
||||
/* Make sure any passed in timeout value is valid. Note that the previous
|
||||
implementation assumed that this check *must* not be performed if there
|
||||
would in fact be no blocking; however, POSIX only requires that "the
|
||||
validity of the abstime parameter need not be checked if the lock can be
|
||||
immediately acquired" (i.e., we need not but may check it). */
|
||||
if (abstime
|
||||
&& __glibc_unlikely (abstime->tv_nsec >= 1000000000
|
||||
/* Make sure any passed in clockid and timeout value are valid. Note that
|
||||
the previous implementation assumed that this check *must* not be
|
||||
performed if there would in fact be no blocking; however, POSIX only
|
||||
requires that "the validity of the abstime parameter need not be checked
|
||||
if the lock can be immediately acquired" (i.e., we need not but may check
|
||||
it). */
|
||||
if (abstime && __glibc_unlikely (!futex_abstimed_supported_clockid (clockid)
|
||||
|| abstime->tv_nsec >= 1000000000
|
||||
|| abstime->tv_nsec < 0))
|
||||
return EINVAL;
|
||||
|
||||
@ -727,7 +731,7 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,
|
||||
may_share_futex_used_flag = true;
|
||||
int err = futex_abstimed_wait (&rwlock->__data.__writers_futex,
|
||||
1 | PTHREAD_RWLOCK_FUTEX_USED,
|
||||
CLOCK_REALTIME, abstime, private);
|
||||
clockid, abstime, private);
|
||||
if (err == ETIMEDOUT)
|
||||
{
|
||||
if (prefer_writer)
|
||||
@ -826,7 +830,7 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,
|
||||
continue;
|
||||
int err = futex_abstimed_wait (&rwlock->__data.__wrphase_futex,
|
||||
PTHREAD_RWLOCK_FUTEX_USED,
|
||||
CLOCK_REALTIME, abstime, private);
|
||||
clockid, abstime, private);
|
||||
if (err == ETIMEDOUT)
|
||||
{
|
||||
if (rwlock->__data.__flags != PTHREAD_RWLOCK_PREFER_READER_NP)
|
||||
|
||||
Reference in New Issue
Block a user