| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| #include <pthread.h> |
| |
| #include <errno.h> |
| #include <limits.h> |
| #include <stdatomic.h> |
| #include <string.h> |
| #include <sys/cdefs.h> |
| #include <sys/mman.h> |
| #include <unistd.h> |
| |
| #include "pthread_internal.h" |
| |
| #include "private/bionic_constants.h" |
| #include "private/bionic_futex.h" |
| #include "private/bionic_systrace.h" |
| #include "private/bionic_time_conversions.h" |
| #include "private/bionic_tls.h" |
| |
| /* a mutex is implemented as a 32-bit integer holding the following fields |
| * |
| * bits: name description |
| * 31-16 tid owner thread's tid (recursive and errorcheck only) |
| * 15-14 type mutex type |
| * 13 shared process-shared flag |
| * 12-2 counter counter of recursive mutexes |
| * 1-0 state lock state (0, 1 or 2) |
| */ |
| |
| /* Convenience macro, creates a mask of 'bits' bits that starts from |
| * the 'shift'-th least significant bit in a 32-bit word. |
| * |
| * Examples: FIELD_MASK(0,4) -> 0xf |
| * FIELD_MASK(16,9) -> 0x1ff0000 |
| */ |
| #define FIELD_MASK(shift,bits) (((1 << (bits))-1) << (shift)) |
| |
| /* This one is used to create a bit pattern from a given field value */ |
| #define FIELD_TO_BITS(val,shift,bits) (((val) & ((1 << (bits))-1)) << (shift)) |
| |
| /* And this one does the opposite, i.e. extract a field's value from a bit pattern */ |
| #define FIELD_FROM_BITS(val,shift,bits) (((val) >> (shift)) & ((1 << (bits))-1)) |
| |
| /* Mutex state: |
| * |
| * 0 for unlocked |
| * 1 for locked, no waiters |
| * 2 for locked, maybe waiters |
| */ |
| #define MUTEX_STATE_SHIFT 0 |
| #define MUTEX_STATE_LEN 2 |
| |
| #define MUTEX_STATE_MASK FIELD_MASK(MUTEX_STATE_SHIFT, MUTEX_STATE_LEN) |
| #define MUTEX_STATE_FROM_BITS(v) FIELD_FROM_BITS(v, MUTEX_STATE_SHIFT, MUTEX_STATE_LEN) |
| #define MUTEX_STATE_TO_BITS(v) FIELD_TO_BITS(v, MUTEX_STATE_SHIFT, MUTEX_STATE_LEN) |
| |
| #define MUTEX_STATE_UNLOCKED 0 /* must be 0 to match PTHREAD_MUTEX_INITIALIZER */ |
| #define MUTEX_STATE_LOCKED_UNCONTENDED 1 /* must be 1 due to atomic dec in unlock operation */ |
| #define MUTEX_STATE_LOCKED_CONTENDED 2 /* must be 1 + LOCKED_UNCONTENDED due to atomic dec */ |
| |
| #define MUTEX_STATE_BITS_UNLOCKED MUTEX_STATE_TO_BITS(MUTEX_STATE_UNLOCKED) |
| #define MUTEX_STATE_BITS_LOCKED_UNCONTENDED MUTEX_STATE_TO_BITS(MUTEX_STATE_LOCKED_UNCONTENDED) |
| #define MUTEX_STATE_BITS_LOCKED_CONTENDED MUTEX_STATE_TO_BITS(MUTEX_STATE_LOCKED_CONTENDED) |
| |
| /* return true iff the mutex if locked with no waiters */ |
| #define MUTEX_STATE_BITS_IS_LOCKED_UNCONTENDED(v) (((v) & MUTEX_STATE_MASK) == MUTEX_STATE_BITS_LOCKED_UNCONTENDED) |
| |
| /* return true iff the mutex if locked with maybe waiters */ |
| #define MUTEX_STATE_BITS_IS_LOCKED_CONTENDED(v) (((v) & MUTEX_STATE_MASK) == MUTEX_STATE_BITS_LOCKED_CONTENDED) |
| |
| /* used to flip from LOCKED_UNCONTENDED to LOCKED_CONTENDED */ |
| #define MUTEX_STATE_BITS_FLIP_CONTENTION(v) ((v) ^ (MUTEX_STATE_BITS_LOCKED_CONTENDED ^ MUTEX_STATE_BITS_LOCKED_UNCONTENDED)) |
| |
| /* Mutex counter: |
| * |
| * We need to check for overflow before incrementing, and we also need to |
| * detect when the counter is 0 |
| */ |
| #define MUTEX_COUNTER_SHIFT 2 |
| #define MUTEX_COUNTER_LEN 11 |
| #define MUTEX_COUNTER_MASK FIELD_MASK(MUTEX_COUNTER_SHIFT, MUTEX_COUNTER_LEN) |
| |
| #define MUTEX_COUNTER_BITS_WILL_OVERFLOW(v) (((v) & MUTEX_COUNTER_MASK) == MUTEX_COUNTER_MASK) |
| #define MUTEX_COUNTER_BITS_IS_ZERO(v) (((v) & MUTEX_COUNTER_MASK) == 0) |
| |
| /* Used to increment the counter directly after overflow has been checked */ |
| #define MUTEX_COUNTER_BITS_ONE FIELD_TO_BITS(1, MUTEX_COUNTER_SHIFT,MUTEX_COUNTER_LEN) |
| |
| /* Mutex shared bit flag |
| * |
| * This flag is set to indicate that the mutex is shared among processes. |
| * This changes the futex opcode we use for futex wait/wake operations |
| * (non-shared operations are much faster). |
| */ |
| #define MUTEX_SHARED_SHIFT 13 |
| #define MUTEX_SHARED_MASK FIELD_MASK(MUTEX_SHARED_SHIFT,1) |
| |
| /* Mutex type: |
| * We support normal, recursive and errorcheck mutexes. |
| */ |
| #define MUTEX_TYPE_SHIFT 14 |
| #define MUTEX_TYPE_LEN 2 |
| #define MUTEX_TYPE_MASK FIELD_MASK(MUTEX_TYPE_SHIFT,MUTEX_TYPE_LEN) |
| |
| #define MUTEX_TYPE_TO_BITS(t) FIELD_TO_BITS(t, MUTEX_TYPE_SHIFT, MUTEX_TYPE_LEN) |
| |
| #define MUTEX_TYPE_BITS_NORMAL MUTEX_TYPE_TO_BITS(PTHREAD_MUTEX_NORMAL) |
| #define MUTEX_TYPE_BITS_RECURSIVE MUTEX_TYPE_TO_BITS(PTHREAD_MUTEX_RECURSIVE) |
| #define MUTEX_TYPE_BITS_ERRORCHECK MUTEX_TYPE_TO_BITS(PTHREAD_MUTEX_ERRORCHECK) |
| |
| /* Mutex owner field: |
| * |
| * This is only used for recursive and errorcheck mutexes. It holds the |
| * tid of the owning thread. We use 16 bits to represent tid here, |
| * so the highest tid is 65535. There is a test to check /proc/sys/kernel/pid_max |
| * to make sure it will not exceed our limit. |
| */ |
| #define MUTEX_OWNER_SHIFT 16 |
| #define MUTEX_OWNER_LEN 16 |
| |
| #define MUTEX_OWNER_FROM_BITS(v) FIELD_FROM_BITS(v,MUTEX_OWNER_SHIFT,MUTEX_OWNER_LEN) |
| #define MUTEX_OWNER_TO_BITS(v) FIELD_TO_BITS(v,MUTEX_OWNER_SHIFT,MUTEX_OWNER_LEN) |
| |
| /* Convenience macros. |
| * |
| * These are used to form or modify the bit pattern of a given mutex value |
| */ |
| |
| |
| |
| /* a mutex attribute holds the following fields |
| * |
| * bits: name description |
| * 0-3 type type of mutex |
| * 4 shared process-shared flag |
| */ |
| #define MUTEXATTR_TYPE_MASK 0x000f |
| #define MUTEXATTR_SHARED_MASK 0x0010 |
| |
| |
| int pthread_mutexattr_init(pthread_mutexattr_t *attr) |
| { |
| *attr = PTHREAD_MUTEX_DEFAULT; |
| return 0; |
| } |
| |
| int pthread_mutexattr_destroy(pthread_mutexattr_t *attr) |
| { |
| *attr = -1; |
| return 0; |
| } |
| |
| int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type_p) |
| { |
| int type = (*attr & MUTEXATTR_TYPE_MASK); |
| |
| if (type < PTHREAD_MUTEX_NORMAL || type > PTHREAD_MUTEX_ERRORCHECK) { |
| return EINVAL; |
| } |
| |
| *type_p = type; |
| return 0; |
| } |
| |
| int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type) |
| { |
| if (type < PTHREAD_MUTEX_NORMAL || type > PTHREAD_MUTEX_ERRORCHECK ) { |
| return EINVAL; |
| } |
| |
| *attr = (*attr & ~MUTEXATTR_TYPE_MASK) | type; |
| return 0; |
| } |
| |
| /* process-shared mutexes are not supported at the moment */ |
| |
| int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr, int pshared) |
| { |
| switch (pshared) { |
| case PTHREAD_PROCESS_PRIVATE: |
| *attr &= ~MUTEXATTR_SHARED_MASK; |
| return 0; |
| |
| case PTHREAD_PROCESS_SHARED: |
| /* our current implementation of pthread actually supports shared |
| * mutexes but won't cleanup if a process dies with the mutex held. |
| * Nevertheless, it's better than nothing. Shared mutexes are used |
| * by surfaceflinger and audioflinger. |
| */ |
| *attr |= MUTEXATTR_SHARED_MASK; |
| return 0; |
| } |
| return EINVAL; |
| } |
| |
| int pthread_mutexattr_getpshared(const pthread_mutexattr_t* attr, int* pshared) { |
| *pshared = (*attr & MUTEXATTR_SHARED_MASK) ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE; |
| return 0; |
| } |
| |
| struct pthread_mutex_internal_t { |
| atomic_int state; |
| #if defined(__LP64__) |
| char __reserved[36]; |
| #endif |
| }; |
| |
| static_assert(sizeof(pthread_mutex_t) == sizeof(pthread_mutex_internal_t), |
| "pthread_mutex_t should actually be pthread_mutex_internal_t in implementation."); |
| |
| // For binary compatibility with old version of pthread_mutex_t, we can't use more strict alignment |
| // than 4-byte alignment. |
| static_assert(alignof(pthread_mutex_t) == 4, |
| "pthread_mutex_t should fulfill the alignment of pthread_mutex_internal_t."); |
| |
| static inline pthread_mutex_internal_t* __get_internal_mutex(pthread_mutex_t* mutex_interface) { |
| return reinterpret_cast<pthread_mutex_internal_t*>(mutex_interface); |
| } |
| |
| int pthread_mutex_init(pthread_mutex_t* mutex_interface, const pthread_mutexattr_t* attr) { |
| pthread_mutex_internal_t* mutex = __get_internal_mutex(mutex_interface); |
| |
| memset(mutex, 0, sizeof(pthread_mutex_internal_t)); |
| |
| if (__predict_true(attr == NULL)) { |
| atomic_init(&mutex->state, MUTEX_TYPE_BITS_NORMAL); |
| return 0; |
| } |
| |
| int state = 0; |
| if ((*attr & MUTEXATTR_SHARED_MASK) != 0) { |
| state |= MUTEX_SHARED_MASK; |
| } |
| |
| switch (*attr & MUTEXATTR_TYPE_MASK) { |
| case PTHREAD_MUTEX_NORMAL: |
| state |= MUTEX_TYPE_BITS_NORMAL; |
| break; |
| case PTHREAD_MUTEX_RECURSIVE: |
| state |= MUTEX_TYPE_BITS_RECURSIVE; |
| break; |
| case PTHREAD_MUTEX_ERRORCHECK: |
| state |= MUTEX_TYPE_BITS_ERRORCHECK; |
| break; |
| default: |
| return EINVAL; |
| } |
| |
| atomic_init(&mutex->state, state); |
| return 0; |
| } |
| |
| static inline __always_inline int __pthread_normal_mutex_trylock(pthread_mutex_internal_t* mutex, |
| int shared) { |
| const int unlocked = shared | MUTEX_STATE_BITS_UNLOCKED; |
| const int locked_uncontended = shared | MUTEX_STATE_BITS_LOCKED_UNCONTENDED; |
| |
| int old_state = unlocked; |
| if (__predict_true(atomic_compare_exchange_strong_explicit(&mutex->state, &old_state, |
| locked_uncontended, memory_order_acquire, memory_order_relaxed))) { |
| return 0; |
| } |
| return EBUSY; |
| } |
| |
| /* |
| * Lock a mutex of type NORMAL. |
| * |
| * As noted above, there are three states: |
| * 0 (unlocked, no contention) |
| * 1 (locked, no contention) |
| * 2 (locked, contention) |
| * |
| * Non-recursive mutexes don't use the thread-id or counter fields, and the |
| * "type" value is zero, so the only bits that will be set are the ones in |
| * the lock state field. |
| */ |
| static inline __always_inline int __pthread_normal_mutex_lock(pthread_mutex_internal_t* mutex, |
| int shared, |
| const timespec* abs_timeout_or_null, |
| clockid_t clock) { |
| if (__predict_true(__pthread_normal_mutex_trylock(mutex, shared) == 0)) { |
| return 0; |
| } |
| |
| ScopedTrace trace("Contending for pthread mutex"); |
| |
| const int unlocked = shared | MUTEX_STATE_BITS_UNLOCKED; |
| const int locked_contended = shared | MUTEX_STATE_BITS_LOCKED_CONTENDED; |
| |
| // We want to go to sleep until the mutex is available, which requires |
| // promoting it to locked_contended. We need to swap in the new state |
| // and then wait until somebody wakes us up. |
| // An atomic_exchange is used to compete with other threads for the lock. |
| // If it returns unlocked, we have acquired the lock, otherwise another |
| // thread still holds the lock and we should wait again. |
| // If lock is acquired, an acquire fence is needed to make all memory accesses |
| // made by other threads visible to the current CPU. |
| while (atomic_exchange_explicit(&mutex->state, locked_contended, |
| memory_order_acquire) != unlocked) { |
| timespec ts; |
| timespec* rel_timeout = NULL; |
| if (abs_timeout_or_null != NULL) { |
| rel_timeout = &ts; |
| if (!timespec_from_absolute_timespec(*rel_timeout, *abs_timeout_or_null, clock)) { |
| return ETIMEDOUT; |
| } |
| } |
| if (__futex_wait_ex(&mutex->state, shared, locked_contended, rel_timeout) == -ETIMEDOUT) { |
| return ETIMEDOUT; |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| * Release a mutex of type NORMAL. The caller is responsible for determining |
| * that we are in fact the owner of this lock. |
| */ |
| static inline __always_inline void __pthread_normal_mutex_unlock(pthread_mutex_internal_t* mutex, |
| int shared) { |
| const int unlocked = shared | MUTEX_STATE_BITS_UNLOCKED; |
| const int locked_contended = shared | MUTEX_STATE_BITS_LOCKED_CONTENDED; |
| |
| // We use an atomic_exchange to release the lock. If locked_contended state |
| // is returned, some threads is waiting for the lock and we need to wake up |
| // one of them. |
| // A release fence is required to make previous stores visible to next |
| // lock owner threads. |
| if (atomic_exchange_explicit(&mutex->state, unlocked, |
| memory_order_release) == locked_contended) { |
| // Wake up one waiting thread. We don't know which thread will be |
| // woken or when it'll start executing -- futexes make no guarantees |
| // here. There may not even be a thread waiting. |
| // |
| // The newly-woken thread will replace the unlocked state we just set above |
| // with locked_contended state, which means that when it eventually releases |
| // the mutex it will also call FUTEX_WAKE. This results in one extra wake |
| // call whenever a lock is contended, but let us avoid forgetting anyone |
| // without requiring us to track the number of sleepers. |
| // |
| // It's possible for another thread to sneak in and grab the lock between |
| // the exchange above and the wake call below. If the new thread is "slow" |
| // and holds the lock for a while, we'll wake up a sleeper, which will swap |
| // in locked_uncontended state and then go back to sleep since the lock is |
| // still held. If the new thread is "fast", running to completion before |
| // we call wake, the thread we eventually wake will find an unlocked mutex |
| // and will execute. Either way we have correct behavior and nobody is |
| // orphaned on the wait queue. |
| __futex_wake_ex(&mutex->state, shared, 1); |
| } |
| } |
| |
| /* This common inlined function is used to increment the counter of a recursive mutex. |
| * |
| * If the counter overflows, it will return EAGAIN. |
| * Otherwise, it atomically increments the counter and returns 0. |
| * |
| */ |
| static inline __always_inline int __recursive_increment(pthread_mutex_internal_t* mutex, |
| int old_state) { |
| // Detect recursive lock overflow and return EAGAIN. |
| // This is safe because only the owner thread can modify the |
| // counter bits in the mutex value. |
| if (MUTEX_COUNTER_BITS_WILL_OVERFLOW(old_state)) { |
| return EAGAIN; |
| } |
| |
| // We own the mutex, but other threads are able to change the lower bits |
| // (e.g. promoting it to "contended"), so we need to use an atomic exchange |
| // loop to update the counter. The counter will not overflow in the loop, |
| // as only the owner thread can change it. |
| // The mutex is still locked, so we don't need a release fence. |
| atomic_fetch_add_explicit(&mutex->state, MUTEX_COUNTER_BITS_ONE, memory_order_relaxed); |
| return 0; |
| } |
| |
| static int __pthread_mutex_lock_with_timeout(pthread_mutex_internal_t* mutex, |
| const timespec* abs_timeout_or_null, clockid_t clock) { |
| int old_state, mtype, tid, shared; |
| |
| old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed); |
| mtype = (old_state & MUTEX_TYPE_MASK); |
| shared = (old_state & MUTEX_SHARED_MASK); |
| |
| // Handle common case first. |
| if ( __predict_true(mtype == MUTEX_TYPE_BITS_NORMAL) ) { |
| return __pthread_normal_mutex_lock(mutex, shared, abs_timeout_or_null, clock); |
| } |
| |
| // Do we already own this recursive or error-check mutex? |
| tid = __get_thread()->tid; |
| if (tid == MUTEX_OWNER_FROM_BITS(old_state)) { |
| if (mtype == MUTEX_TYPE_BITS_ERRORCHECK) { |
| return EDEADLK; |
| } |
| return __recursive_increment(mutex, old_state); |
| } |
| |
| const int unlocked = mtype | shared | MUTEX_STATE_BITS_UNLOCKED; |
| const int locked_uncontended = mtype | shared | MUTEX_STATE_BITS_LOCKED_UNCONTENDED; |
| const int locked_contended = mtype | shared | MUTEX_STATE_BITS_LOCKED_CONTENDED; |
| |
| // First, if the mutex is unlocked, try to quickly acquire it. |
| // In the optimistic case where this works, set the state to locked_uncontended. |
| if (old_state == unlocked) { |
| int new_state = MUTEX_OWNER_TO_BITS(tid) | locked_uncontended; |
| // If exchanged successfully, an acquire fence is required to make |
| // all memory accesses made by other threads visible to the current CPU. |
| if (__predict_true(atomic_compare_exchange_strong_explicit(&mutex->state, &old_state, |
| new_state, memory_order_acquire, memory_order_relaxed))) { |
| return 0; |
| } |
| } |
| |
| ScopedTrace trace("Contending for pthread mutex"); |
| |
| while (true) { |
| if (old_state == unlocked) { |
| // NOTE: We put the state to locked_contended since we _know_ there |
| // is contention when we are in this loop. This ensures all waiters |
| // will be unlocked. |
| |
| int new_state = MUTEX_OWNER_TO_BITS(tid) | locked_contended; |
| // If exchanged successfully, an acquire fence is required to make |
| // all memory accesses made by other threads visible to the current CPU. |
| if (__predict_true(atomic_compare_exchange_weak_explicit(&mutex->state, |
| &old_state, new_state, |
| memory_order_acquire, |
| memory_order_relaxed))) { |
| return 0; |
| } |
| continue; |
| } else if (MUTEX_STATE_BITS_IS_LOCKED_UNCONTENDED(old_state)) { |
| // We should set it to locked_contended beforing going to sleep. This can make |
| // sure waiters will be woken up eventually. |
| |
| int new_state = MUTEX_STATE_BITS_FLIP_CONTENTION(old_state); |
| if (__predict_false(!atomic_compare_exchange_weak_explicit(&mutex->state, |
| &old_state, new_state, |
| memory_order_relaxed, |
| memory_order_relaxed))) { |
| continue; |
| } |
| old_state = new_state; |
| } |
| |
| // We are in locked_contended state, sleep until someone wakes us up. |
| timespec ts; |
| timespec* rel_timeout = NULL; |
| if (abs_timeout_or_null != NULL) { |
| rel_timeout = &ts; |
| if (!timespec_from_absolute_timespec(*rel_timeout, *abs_timeout_or_null, clock)) { |
| return ETIMEDOUT; |
| } |
| } |
| if (__futex_wait_ex(&mutex->state, shared, old_state, rel_timeout) == -ETIMEDOUT) { |
| return ETIMEDOUT; |
| } |
| old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed); |
| } |
| } |
| |
| int pthread_mutex_lock(pthread_mutex_t* mutex_interface) { |
| pthread_mutex_internal_t* mutex = __get_internal_mutex(mutex_interface); |
| |
| int old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed); |
| int mtype = (old_state & MUTEX_TYPE_MASK); |
| int shared = (old_state & MUTEX_SHARED_MASK); |
| // Avoid slowing down fast path of normal mutex lock operation. |
| if (__predict_true(mtype == MUTEX_TYPE_BITS_NORMAL)) { |
| if (__predict_true(__pthread_normal_mutex_trylock(mutex, shared) == 0)) { |
| return 0; |
| } |
| } |
| return __pthread_mutex_lock_with_timeout(mutex, NULL, 0); |
| } |
| |
| int pthread_mutex_unlock(pthread_mutex_t* mutex_interface) { |
| pthread_mutex_internal_t* mutex = __get_internal_mutex(mutex_interface); |
| |
| int old_state, mtype, tid, shared; |
| |
| old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed); |
| mtype = (old_state & MUTEX_TYPE_MASK); |
| shared = (old_state & MUTEX_SHARED_MASK); |
| |
| // Handle common case first. |
| if (__predict_true(mtype == MUTEX_TYPE_BITS_NORMAL)) { |
| __pthread_normal_mutex_unlock(mutex, shared); |
| return 0; |
| } |
| |
| // Do we already own this recursive or error-check mutex? |
| tid = __get_thread()->tid; |
| if ( tid != MUTEX_OWNER_FROM_BITS(old_state) ) |
| return EPERM; |
| |
| // If the counter is > 0, we can simply decrement it atomically. |
| // Since other threads can mutate the lower state bits (and only the |
| // lower state bits), use a compare_exchange loop to do it. |
| if (!MUTEX_COUNTER_BITS_IS_ZERO(old_state)) { |
| // We still own the mutex, so a release fence is not needed. |
| atomic_fetch_sub_explicit(&mutex->state, MUTEX_COUNTER_BITS_ONE, memory_order_relaxed); |
| return 0; |
| } |
| |
| // The counter is 0, so we'are going to unlock the mutex by resetting its |
| // state to unlocked, we need to perform a atomic_exchange inorder to read |
| // the current state, which will be locked_contended if there may have waiters |
| // to awake. |
| // A release fence is required to make previous stores visible to next |
| // lock owner threads. |
| const int unlocked = mtype | shared | MUTEX_STATE_BITS_UNLOCKED; |
| old_state = atomic_exchange_explicit(&mutex->state, unlocked, memory_order_release); |
| if (MUTEX_STATE_BITS_IS_LOCKED_CONTENDED(old_state)) { |
| __futex_wake_ex(&mutex->state, shared, 1); |
| } |
| |
| return 0; |
| } |
| |
| int pthread_mutex_trylock(pthread_mutex_t* mutex_interface) { |
| pthread_mutex_internal_t* mutex = __get_internal_mutex(mutex_interface); |
| |
| int old_state = atomic_load_explicit(&mutex->state, memory_order_relaxed); |
| int mtype = (old_state & MUTEX_TYPE_MASK); |
| int shared = (old_state & MUTEX_SHARED_MASK); |
| |
| const int unlocked = mtype | shared | MUTEX_STATE_BITS_UNLOCKED; |
| const int locked_uncontended = mtype | shared | MUTEX_STATE_BITS_LOCKED_UNCONTENDED; |
| |
| // Handle common case first. |
| if (__predict_true(mtype == MUTEX_TYPE_BITS_NORMAL)) { |
| return __pthread_normal_mutex_trylock(mutex, shared); |
| } |
| |
| // Do we already own this recursive or error-check mutex? |
| pid_t tid = __get_thread()->tid; |
| if (tid == MUTEX_OWNER_FROM_BITS(old_state)) { |
| if (mtype == MUTEX_TYPE_BITS_ERRORCHECK) { |
| return EBUSY; |
| } |
| return __recursive_increment(mutex, old_state); |
| } |
| |
| // Same as pthread_mutex_lock, except that we don't want to wait, and |
| // the only operation that can succeed is a single compare_exchange to acquire the |
| // lock if it is released / not owned by anyone. No need for a complex loop. |
| // If exchanged successfully, an acquire fence is required to make |
| // all memory accesses made by other threads visible to the current CPU. |
| old_state = unlocked; |
| int new_state = MUTEX_OWNER_TO_BITS(tid) | locked_uncontended; |
| if (__predict_true(atomic_compare_exchange_strong_explicit(&mutex->state, &old_state, new_state, |
| memory_order_acquire, |
| memory_order_relaxed))) { |
| return 0; |
| } |
| return EBUSY; |
| } |
| |
| #if !defined(__LP64__) |
| extern "C" int pthread_mutex_lock_timeout_np(pthread_mutex_t* mutex_interface, unsigned ms) { |
| timespec abs_timeout; |
| clock_gettime(CLOCK_MONOTONIC, &abs_timeout); |
| abs_timeout.tv_sec += ms / 1000; |
| abs_timeout.tv_nsec += (ms % 1000) * 1000000; |
| if (abs_timeout.tv_nsec >= NS_PER_S) { |
| abs_timeout.tv_sec++; |
| abs_timeout.tv_nsec -= NS_PER_S; |
| } |
| |
| int error = __pthread_mutex_lock_with_timeout(__get_internal_mutex(mutex_interface), |
| &abs_timeout, CLOCK_MONOTONIC); |
| if (error == ETIMEDOUT) { |
| error = EBUSY; |
| } |
| return error; |
| } |
| #endif |
| |
| int pthread_mutex_timedlock(pthread_mutex_t* mutex_interface, const timespec* abs_timeout) { |
| return __pthread_mutex_lock_with_timeout(__get_internal_mutex(mutex_interface), |
| abs_timeout, CLOCK_REALTIME); |
| } |
| |
| int pthread_mutex_destroy(pthread_mutex_t* mutex_interface) { |
| // Use trylock to ensure that the mutex is valid and not already locked. |
| int error = pthread_mutex_trylock(mutex_interface); |
| if (error != 0) { |
| return error; |
| } |
| |
| pthread_mutex_internal_t* mutex = __get_internal_mutex(mutex_interface); |
| atomic_store_explicit(&mutex->state, 0xdead10cc, memory_order_relaxed); |
| return 0; |
| } |