musl/src/thread/pthread_mutex_timedlock.c

#include "pthread_impl.h"

int pthread_mutex_timedlock(pthread_mutex_t *restrict m, const struct timespec *restrict at)
{
	int r, t;

	if (m->_m_type == PTHREAD_MUTEX_NORMAL && !a_cas(&m->_m_lock, 0, EBUSY))
		return 0;

	while ((r=pthread_mutex_trylock(m)) == EBUSY) {
		if (!(r=m->_m_lock) || (r&0x40000000)) continue;
		if ((m->_m_type&3) == PTHREAD_MUTEX_ERRORCHECK
		 && (r&0x1fffffff) == pthread_self()->tid)
			return EDEADLK;

		a_inc(&m->_m_waiters);
		t = r | 0x80000000;
		a_cas(&m->_m_lock, r, t);
		r = __timedwait(&m->_m_lock, t, CLOCK_REALTIME, at, 0, 0, 0);
		a_dec(&m->_m_waiters);
		if (r && r != EINTR) break;
	}
	return r;
}
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`#include "pthread_impl.h"`

use restrict everywhere it's required by c99 and/or posix 2008 to deal with the fact that the public headers may be used with pre-c99 compilers, __restrict is used in place of restrict, and defined appropriately for any supported compiler. we also avoid the form [restrict] since older versions of gcc rejected it due to a bug in the original c99 standard, and instead use the form *restrict. 2012-09-06 22:44:55 -04:00			`int pthread_mutex_timedlock(pthread_mutex_t restrict m, const struct timespec restrict at)`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`{`
avoid accessing mutex memory after atomic unlock this change is needed to fix a race condition and ensure that it's possible to unlock and destroy or unmap the mutex as soon as pthread_mutex_lock succeeds. POSIX explicitly gives such an example in the rationale and requires an implementation to allow such usage. 2011-08-02 20:31:15 -04:00			`int r, t;`

			`if (m->_m_type == PTHREAD_MUTEX_NORMAL && !a_cas(&m->_m_lock, 0, EBUSY))`
			`return 0;`

initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`while ((r=pthread_mutex_trylock(m)) == EBUSY) {`
implement robust mutexes some of this code should be cleaned up, e.g. using macros for some of the bit flags, masks, etc. nonetheless, the code is believed to be working and correct at this point. 2011-03-17 20:41:37 -04:00			`if (!(r=m->_m_lock) \|\| (r&0x40000000)) continue;`
avoid accessing mutex memory after atomic unlock this change is needed to fix a race condition and ensure that it's possible to unlock and destroy or unmap the mutex as soon as pthread_mutex_lock succeeds. POSIX explicitly gives such an example in the rationale and requires an implementation to allow such usage. 2011-08-02 20:31:15 -04:00			`if ((m->_m_type&3) == PTHREAD_MUTEX_ERRORCHECK`
			`&& (r&0x1fffffff) == pthread_self()->tid)`
			`return EDEADLK;`

			`a_inc(&m->_m_waiters);`
			`t = r \| 0x80000000;`
			`a_cas(&m->_m_lock, r, t);`
unify and overhaul timed futex waits new features: - FUTEX_WAIT_BITSET op will be used for timed waits if available. this saves a call to clock_gettime. - error checking for the timespec struct is now inside __timedwait so it doesn't need to be duplicated everywhere. cond_timedwait still needs to duplicate it to avoid unlocking the mutex, though. - pushing and popping the cancellation handler is delegated to __timedwait, and cancellable/non-cancellable waits are unified. 2011-08-02 21:11:36 -04:00			`r = __timedwait(&m->_m_lock, t, CLOCK_REALTIME, at, 0, 0, 0);`
avoid accessing mutex memory after atomic unlock this change is needed to fix a race condition and ensure that it's possible to unlock and destroy or unmap the mutex as soon as pthread_mutex_lock succeeds. POSIX explicitly gives such an example in the rationale and requires an implementation to allow such usage. 2011-08-02 20:31:15 -04:00			`a_dec(&m->_m_waiters);`
			`if (r && r != EINTR) break;`
initial check-in, version 0.5.0 2011-02-12 00:22:29 -05:00			`}`
			`return r;`
			`}`