BOOL pthread_win32_thread_detach_np () { if (ptw32_processInitialized) { /* * Don't use pthread_self() - to avoid creating an implicit POSIX thread handle * unnecessarily. */ ptw32_thread_t * sp = (ptw32_thread_t *) pthread_getspecific (ptw32_selfThreadKey); if (sp != NULL) // otherwise Win32 thread with no implicit POSIX handle. { ptw32_mcs_local_node_t stateLock; ptw32_callUserDestroyRoutines (sp->ptHandle); ptw32_mcs_lock_acquire (&sp->stateLock, &stateLock); sp->state = PThreadStateLast; /* * If the thread is joinable at this point then it MUST be joined * or detached explicitly by the application. */ ptw32_mcs_lock_release (&stateLock); /* * Robust Mutexes */ while (sp->robustMxList != NULL) { pthread_mutex_t mx = sp->robustMxList->mx; ptw32_robust_mutex_remove(&mx, sp); (void) PTW32_INTERLOCKED_EXCHANGE_LONG( (PTW32_INTERLOCKED_LONGPTR)&mx->robustNode->stateInconsistent, (PTW32_INTERLOCKED_LONG)-1); /* * If there are no waiters then the next thread to block will * sleep, wake up immediately and then go back to sleep. * See pthread_mutex_lock.c. */ SetEvent(mx->event); } if (sp->detachState == PTHREAD_CREATE_DETACHED) { ptw32_threadDestroy (sp->ptHandle); if (ptw32_selfThreadKey) { TlsSetValue (ptw32_selfThreadKey->key, NULL); } } } } return TRUE; }
int pthread_mutex_unlock (pthread_mutex_t * mutex) { int result = 0; int kind; pthread_mutex_t mx; /* * Let the system deal with invalid pointers. */ mx = *mutex; /* * If the thread calling us holds the mutex then there is no * race condition. If another thread holds the * lock then we shouldn't be in here. */ if (mx < PTHREAD_ERRORCHECK_MUTEX_INITIALIZER) { kind = mx->kind; if (kind >= 0) { if (kind == PTHREAD_MUTEX_NORMAL) { LONG idx; idx = (LONG) PTW32_INTERLOCKED_EXCHANGE_LONG ((PTW32_INTERLOCKED_LONGPTR)&mx->lock_idx, (PTW32_INTERLOCKED_LONG)0); if (idx != 0) { if (idx < 0) { /* * Someone may be waiting on that mutex. */ if (SetEvent (mx->event) == 0) { result = EINVAL; } } } } else { if (pthread_equal (to_pthread(mx->ownerThread), pthread_self())) { if (kind != PTHREAD_MUTEX_RECURSIVE || 0 == --mx->recursive_count) { mx->ownerThread.p = NULL; if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG ((PTW32_INTERLOCKED_LONGPTR)&mx->lock_idx, (PTW32_INTERLOCKED_LONG)0) < 0L) { /* Someone may be waiting on that mutex */ if (SetEvent (mx->event) == 0) { result = EINVAL; } } } } else { result = EPERM; } } } else { /* Robust types */ pthread_t self = pthread_self(); kind = -kind - 1; /* Convert to non-robust range */ /* * The thread must own the lock regardless of type if the mutex * is robust. */ if (pthread_equal (to_pthread(mx->ownerThread), self)) { PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->robustNode->stateInconsistent, (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_NOTRECOVERABLE, (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_INCONSISTENT); if (PTHREAD_MUTEX_NORMAL == kind) { ptw32_robust_mutex_remove(mutex, NULL); if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx, (PTW32_INTERLOCKED_LONG) 0) < 0) { /* * Someone may be waiting on that mutex. */ if (SetEvent (mx->event) == 0) { result = EINVAL; } } } else { if (kind != PTHREAD_MUTEX_RECURSIVE || 0 == --mx->recursive_count) { ptw32_robust_mutex_remove(mutex, NULL); if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx, (PTW32_INTERLOCKED_LONG) 0) < 0) { /* * Someone may be waiting on that mutex. */ if (SetEvent (mx->event) == 0) { result = EINVAL; } } } } } else { result = EPERM; } } } else if (mx != PTHREAD_MUTEX_INITIALIZER) { result = EINVAL; } return (result); }
int pthread_mutex_unlock (pthread_mutex_t * mutex) { int result = 0; int kind; pthread_mutex_t mx; mx = *mutex; if (mx < PTHREAD_ERRORCHECK_MUTEX_INITIALIZER) { kind = mx->kind; if (kind >= 0) { if (kind == PTHREAD_MUTEX_NORMAL) { LONG idx; idx = (LONG) PTW32_INTERLOCKED_EXCHANGE_LONG ((PTW32_INTERLOCKED_LONGPTR)&mx->lock_idx, (PTW32_INTERLOCKED_LONG)0); if (idx != 0) { if (idx < 0) { if (SetEvent (mx->event) == 0) { result = EINVAL; } } } } else { if (pthread_equal (mx->ownerThread, pthread_self())) { if (kind != PTHREAD_MUTEX_RECURSIVE || 0 == --mx->recursive_count) { mx->ownerThread.p = NULL; if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG ((PTW32_INTERLOCKED_LONGPTR)&mx->lock_idx, (PTW32_INTERLOCKED_LONG)0) < 0L) { if (SetEvent (mx->event) == 0) { result = EINVAL; } } } } else { result = EPERM; } } } else { pthread_t self = pthread_self(); kind = -kind - 1; if (pthread_equal (mx->ownerThread, self)) { PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->robustNode->stateInconsistent, (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_NOTRECOVERABLE, (PTW32_INTERLOCKED_LONG)PTW32_ROBUST_INCONSISTENT); if (PTHREAD_MUTEX_NORMAL == kind) { ptw32_robust_mutex_remove(mutex, NULL); if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx, (PTW32_INTERLOCKED_LONG) 0) < 0) { if (SetEvent (mx->event) == 0) { result = EINVAL; } } } else { if (kind != PTHREAD_MUTEX_RECURSIVE || 0 == --mx->recursive_count) { ptw32_robust_mutex_remove(mutex, NULL); if ((LONG) PTW32_INTERLOCKED_EXCHANGE_LONG((PTW32_INTERLOCKED_LONGPTR) &mx->lock_idx, (PTW32_INTERLOCKED_LONG) 0) < 0) { if (SetEvent (mx->event) == 0) { result = EINVAL; } } } } } else { result = EPERM; } } } else if (mx != PTHREAD_MUTEX_INITIALIZER) { result = EINVAL; } return (result); }