mirror of
https://sourceware.org/git/glibc.git
synced 2025-07-29 11:41:21 +03:00
robust mutexes: Fix broken x86 assembly by removing it
lll_robust_unlock on i386 and x86_64 first sets the futex word to FUTEX_WAITERS|0 before calling __lll_unlock_wake, which will set the futex word to 0. If the thread is killed between these steps, then the futex word will be FUTEX_WAITERS|0, and the kernel (at least current upstream) will not set it to FUTEX_OWNER_DIED|FUTEX_WAITERS because 0 is not equal to the TID of the crashed thread. The lll_robust_lock assembly code on i386 and x86_64 is not prepared to deal with this case because the fastpath tries to only CAS 0 to TID and not FUTEX_WAITERS|0 to TID; the slowpath simply waits until it can CAS 0 to TID or the futex_word has the FUTEX_OWNER_DIED bit set. This issue is fixed by removing the custom x86 assembly code and using the generic C code instead. However, instead of adding more duplicate code to the custom x86 lowlevellock.h, the code of the lll_robust* functions is inlined into the single call sites that exist for each of these functions in the pthread_mutex_* functions. The robust mutex paths in the latter have been slightly reorganized to make them simpler. This patch is meant to be easy to backport, so C11-style atomics are not used. [BZ #20985] * nptl/Makefile: Adapt. * nptl/pthread_mutex_cond_lock.c (LLL_ROBUST_MUTEX_LOCK): Remove. (LLL_ROBUST_MUTEX_LOCK_MODIFIER): New. * nptl/pthread_mutex_lock.c (LLL_ROBUST_MUTEX_LOCK): Remove. (LLL_ROBUST_MUTEX_LOCK_MODIFIER): New. (__pthread_mutex_lock_full): Inline lll_robust* functions and adapt. * nptl/pthread_mutex_timedlock.c (pthread_mutex_timedlock): Inline lll_robust* functions and adapt. * nptl/pthread_mutex_unlock.c (__pthread_mutex_unlock_full): Likewise. * sysdeps/nptl/lowlevellock.h (__lll_robust_lock_wait, __lll_robust_lock, lll_robust_cond_lock, __lll_robust_timedlock_wait, __lll_robust_timedlock, __lll_robust_unlock): Remove. * sysdeps/unix/sysv/linux/i386/lowlevellock.h (lll_robust_lock, lll_robust_cond_lock, lll_robust_timedlock, lll_robust_unlock): Remove. * sysdeps/unix/sysv/linux/x86_64/lowlevellock.h (lll_robust_lock, lll_robust_cond_lock, lll_robust_timedlock, lll_robust_unlock): Remove. * sysdeps/unix/sysv/linux/sparc/lowlevellock.h (__lll_robust_lock_wait, __lll_robust_lock, lll_robust_cond_lock, __lll_robust_timedlock_wait, __lll_robust_timedlock, __lll_robust_unlock): Remove. * nptl/lowlevelrobustlock.c: Remove file. * nptl/lowlevelrobustlock.sym: Likewise. * sysdeps/unix/sysv/linux/i386/lowlevelrobustlock.S: Likewise. * sysdeps/unix/sysv/linux/x86_64/lowlevelrobustlock.S: Likewise.
This commit is contained in:
Torvald Riegel
@ -147,9 +147,16 @@ pthread_mutex_timedlock (pthread_mutex_t *mutex,
|
||||
set to avoid lost wake-ups. We have the same requirement in the
|
||||
simple mutex algorithm. */
|
||||
unsigned int assume_other_futex_waiters = 0;
|
||||
do
|
||||
while (1)
|
||||
{
|
||||
again:
|
||||
/* Try to acquire the lock through a CAS from 0 (not acquired) to
|
||||
our TID | assume_other_futex_waiters. */
|
||||
if (__glibc_likely ((oldval == 0)
|
||||
&& (atomic_compare_and_exchange_bool_acq
|
||||
(&mutex->__data.__lock,
|
||||
id | assume_other_futex_waiters, 0) == 0)))
|
||||
break;
|
||||
|
||||
if ((oldval & FUTEX_OWNER_DIED) != 0)
|
||||
{
|
||||
/* The previous owner died. Try locking the mutex. */
|
||||
@ -162,7 +169,7 @@ pthread_mutex_timedlock (pthread_mutex_t *mutex,
|
||||
if (newval != oldval)
|
||||
{
|
||||
oldval = newval;
|
||||
goto again;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* We got the mutex. */
|
||||
@ -209,30 +216,87 @@ pthread_mutex_timedlock (pthread_mutex_t *mutex,
|
||||
}
|
||||
}
|
||||
|
||||
result = lll_robust_timedlock (mutex->__data.__lock, abstime,
|
||||
id | assume_other_futex_waiters,
|
||||
PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
|
||||
/* See above. We set FUTEX_WAITERS and might have shared this flag
|
||||
with other threads; thus, we need to preserve it. */
|
||||
assume_other_futex_waiters = FUTEX_WAITERS;
|
||||
/* We are about to block; check whether the timeout is invalid. */
|
||||
if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
|
||||
return EINVAL;
|
||||
/* Work around the fact that the kernel rejects negative timeout
|
||||
values despite them being valid. */
|
||||
if (__glibc_unlikely (abstime->tv_sec < 0))
|
||||
return ETIMEDOUT;
|
||||
#if (!defined __ASSUME_FUTEX_CLOCK_REALTIME \
|
||||
|| !defined lll_futex_timed_wait_bitset)
|
||||
struct timeval tv;
|
||||
struct timespec rt;
|
||||
|
||||
if (__builtin_expect (mutex->__data.__owner
|
||||
== PTHREAD_MUTEX_NOTRECOVERABLE, 0))
|
||||
/* Get the current time. */
|
||||
(void) __gettimeofday (&tv, NULL);
|
||||
|
||||
/* Compute relative timeout. */
|
||||
rt.tv_sec = abstime->tv_sec - tv.tv_sec;
|
||||
rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
|
||||
if (rt.tv_nsec < 0)
|
||||
{
|
||||
/* This mutex is now not recoverable. */
|
||||
mutex->__data.__count = 0;
|
||||
lll_unlock (mutex->__data.__lock,
|
||||
PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
|
||||
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
|
||||
return ENOTRECOVERABLE;
|
||||
rt.tv_nsec += 1000000000;
|
||||
--rt.tv_sec;
|
||||
}
|
||||
|
||||
if (result == ETIMEDOUT || result == EINVAL)
|
||||
goto out;
|
||||
/* Already timed out? */
|
||||
if (rt.tv_sec < 0)
|
||||
return ETIMEDOUT;
|
||||
#endif
|
||||
|
||||
oldval = result;
|
||||
/* We cannot acquire the mutex nor has its owner died. Thus, try
|
||||
to block using futexes. Set FUTEX_WAITERS if necessary so that
|
||||
other threads are aware that there are potentially threads
|
||||
blocked on the futex. Restart if oldval changed in the
|
||||
meantime. */
|
||||
if ((oldval & FUTEX_WAITERS) == 0)
|
||||
{
|
||||
if (atomic_compare_and_exchange_bool_acq (&mutex->__data.__lock,
|
||||
oldval | FUTEX_WAITERS,
|
||||
oldval)
|
||||
!= 0)
|
||||
{
|
||||
oldval = mutex->__data.__lock;
|
||||
continue;
|
||||
}
|
||||
oldval |= FUTEX_WAITERS;
|
||||
}
|
||||
|
||||
/* It is now possible that we share the FUTEX_WAITERS flag with
|
||||
another thread; therefore, update assume_other_futex_waiters so
|
||||
that we do not forget about this when handling other cases
|
||||
above and thus do not cause lost wake-ups. */
|
||||
assume_other_futex_waiters |= FUTEX_WAITERS;
|
||||
|
||||
/* Block using the futex. */
|
||||
#if (!defined __ASSUME_FUTEX_CLOCK_REALTIME \
|
||||
|| !defined lll_futex_timed_wait_bitset)
|
||||
lll_futex_timed wait (&mutex->__data.__lock, oldval,
|
||||
&rt, PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
|
||||
#else
|
||||
int err = lll_futex_timed_wait_bitset (&mutex->__data.__lock,
|
||||
oldval, abstime, FUTEX_CLOCK_REALTIME,
|
||||
PTHREAD_ROBUST_MUTEX_PSHARED (mutex));
|
||||
/* The futex call timed out. */
|
||||
if (err == -ETIMEDOUT)
|
||||
return -err;
|
||||
#endif
|
||||
/* Reload current lock value. */
|
||||
oldval = mutex->__data.__lock;
|
||||
}
|
||||
|
||||
/* We have acquired the mutex; check if it is still consistent. */
|
||||
if (__builtin_expect (mutex->__data.__owner
|
||||
== PTHREAD_MUTEX_NOTRECOVERABLE, 0))
|
||||
{
|
||||
/* This mutex is now not recoverable. */
|
||||
mutex->__data.__count = 0;
|
||||
int private = PTHREAD_ROBUST_MUTEX_PSHARED (mutex);
|
||||
lll_unlock (mutex->__data.__lock, private);
|
||||
THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);
|
||||
return ENOTRECOVERABLE;
|
||||
}
|
||||
while ((oldval & FUTEX_OWNER_DIED) != 0);
|
||||
|
||||
mutex->__data.__count = 1;
|
||||
ENQUEUE_MUTEX (mutex);
|
||||
|
||||
Reference in New Issue
Block a user