| // |
| // Copyright (c) Microsoft. All rights reserved. |
| // Licensed under the MIT license. See LICENSE file in the project root for full license information. |
| // |
| |
| /*++ |
| |
| |
| |
| Module Name: |
| |
| synchcontrollers.cpp |
| |
| Abstract: |
| Implementation of Synchronization Controllers and related objects |
| |
| |
| |
| --*/ |
| |
| #include "synchmanager.hpp" |
| |
| #include <sys/types.h> |
| #include <sys/time.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| #include <sched.h> |
| #include <errno.h> |
| #include <limits.h> |
| |
| namespace CorUnix |
| { |
| #ifdef SYNCH_STATISTICS |
| LONG g_rglStatWaitCount[ObjectTypeIdCount] = { 0 }; |
| LONG g_rglStatContentionCount[ObjectTypeIdCount] = { 0 }; |
| #endif // SYNCH_STATISTICS |
| //////////////////////////// |
| // // |
| // CSynchControllerBase // |
| // // |
| //////////////////////////// |
| |
| /*++ |
| Method: |
| CSynchControllerBase::Init |
| |
| Initializes a generic controller |
| --*/ |
| PAL_ERROR CSynchControllerBase::Init( |
| CPalThread * pthrCurrent, |
| ControllerType ctCtrlrType, |
| ObjectDomain odObjectDomain, |
| CObjectType *potObjectType, |
| CSynchData * psdSynchData, |
| WaitDomain wdWaitDomain) |
| { |
| VALIDATEOBJECT(psdSynchData); |
| |
| _ASSERTE(InternalGetCurrentThread() == pthrCurrent); |
| |
| // Initialize internal controller data |
| m_pthrOwner = pthrCurrent; |
| m_ctCtrlrType = ctCtrlrType; |
| m_odObjectDomain = odObjectDomain; |
| m_potObjectType = potObjectType; |
| m_psdSynchData = psdSynchData; |
| m_wdWaitDomain = wdWaitDomain; |
| |
| // Add reference to target synch data |
| m_psdSynchData->AddRef(); |
| |
| // Acquire lock implied by the controller |
| CPalSynchronizationManager::AcquireLocalSynchLock(m_pthrOwner); |
| if (LocalWait != m_wdWaitDomain) |
| { |
| CPalSynchronizationManager::AcquireSharedSynchLock(m_pthrOwner); |
| } |
| |
| return NO_ERROR; |
| } |
| |
| /*++ |
| Method: |
| CSynchControllerBase::Release |
| |
| Releases a generic controller a return it to the appropriate cache |
| --*/ |
| void CSynchControllerBase::Release() |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| #ifdef _DEBUG |
| ThreadWaitInfo * ptwiWaitInfo = |
| CPalSynchronizationManager::GetThreadWaitInfo(m_pthrOwner); |
| #endif // _DEBUG |
| |
| CPalSynchronizationManager * pSynchManager = |
| CPalSynchronizationManager::GetInstance(); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERTE(ptwiWaitInfo->pthrOwner == m_pthrOwner); |
| |
| // Release reference to target synch data |
| m_psdSynchData->Release(m_pthrOwner); |
| |
| // Release lock implied by the controller |
| if (LocalWait != m_wdWaitDomain) |
| { |
| CPalSynchronizationManager::ReleaseSharedSynchLock(m_pthrOwner); |
| } |
| CPalSynchronizationManager::ReleaseLocalSynchLock(m_pthrOwner); |
| |
| // Return controller to the appropriate cache |
| if (WaitController == m_ctCtrlrType) |
| { |
| // The cast here must be static_cast and not reinterpet_cast. |
| // In fact in general static_cast<CSynchWaitController*>(this) is |
| // equal to this-sizeof(void*), given that CSynchWaitController |
| // has a virtual table, while CSynchControllerBase doesn't. |
| pSynchManager->CacheAddWaitCtrlr(m_pthrOwner, |
| static_cast<CSynchWaitController*>(this)); |
| } |
| else |
| { |
| // The cast here must be static_cast and not reinterpet_cast |
| pSynchManager->CacheAddStateCtrlr(m_pthrOwner, |
| static_cast<CSynchStateController*>(this)); |
| } |
| } |
| |
| //////////////////////////// |
| // // |
| // CSynchWaitController // |
| // // |
| //////////////////////////// |
| |
| /*++ |
| Method: |
| CSynchWaitController::CanThreadWaitWithoutBlocking |
| |
| Returns whether or not the thread owning this controller can |
| wait on the target object without blocking (i.e. the objet is |
| signaled) |
| --*/ |
| PAL_ERROR CSynchWaitController::CanThreadWaitWithoutBlocking( |
| bool * pfCanWaitWithoutBlocking, |
| bool * pfAbandoned) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| bool fRetVal = false; |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERTE(NULL != pfCanWaitWithoutBlocking); |
| _ASSERTE(NULL != pfAbandoned); |
| |
| fRetVal = m_psdSynchData->CanWaiterWaitWithoutBlocking(m_pthrOwner, pfAbandoned); |
| |
| if(!fRetVal && otiProcess == m_psdSynchData->GetObjectTypeId()) |
| { |
| // Note: if the target object is a process, here we need to check |
| // whether or not it has already exited. In fact, since currently |
| // we do not monitor a process status as long as there is no |
| // thread waiting on it, in general if the process already exited |
| // the process object is likely not to be signaled yet, therefore |
| // the above CanWaiterWaitWithoutBlocking call probably returned |
| // false, and, without the check below, that would cause the |
| // current thread to eventually go to sleep for a short time |
| // (until the worker thread notifies that the waited process has |
| // indeed exited), while it would not be necessary. |
| // As side effect that would cause a WaitForSingleObject with zero |
| // timeout to always return WAIT_TIMEOUT, even though the target |
| // process already exited. WaitForSingleObject with zero timeout |
| // is a common way to probe whether or not a process has already |
| // exited, and it is supposed to return WAIT_OBJECT_0 if the |
| // process exited, and WAIT_TIMEOUT if it is still active. |
| // In order to support this feature we need to check at this time |
| // whether or not the process has already exited. |
| |
| CProcProcessLocalData * pProcLocalData = GetProcessLocalData(); |
| DWORD dwExitCode = 0; |
| bool fIsActualExitCode = false; |
| |
| _ASSERT_MSG(NULL != pProcLocalData, |
| "Process synch data pointer is missing\n"); |
| |
| if (NULL != pProcLocalData && |
| CPalSynchronizationManager::HasProcessExited(pProcLocalData->dwProcessId, |
| &dwExitCode, |
| &fIsActualExitCode)) |
| { |
| TRACE("Process pid=%u exited with %s exitcode=%u\n", |
| pProcLocalData->dwProcessId, |
| fIsActualExitCode ? "actual" : "guessed", |
| dwExitCode); |
| |
| // Store the exit code in the process local data |
| if (fIsActualExitCode) |
| { |
| pProcLocalData->dwExitCode = dwExitCode; |
| } |
| |
| // Set process status to PS_DONE |
| pProcLocalData->ps = PS_DONE; |
| |
| // Set signal count |
| m_psdSynchData->SetSignalCount(1); |
| |
| // Releasing all local waiters |
| // (see comments in DoMonitorProcesses) |
| m_psdSynchData->ReleaseAllLocalWaiters(m_pthrOwner); |
| |
| fRetVal = true; |
| } |
| } |
| |
| *pfCanWaitWithoutBlocking = fRetVal; |
| return NO_ERROR; |
| } |
| |
| /*++ |
| Method: |
| CSynchWaitController::ReleaseWaitingThreadWithoutBlocking |
| |
| Performs all the steps needed to be done by the controller's owner |
| thread in order to wait on the target object without blocking |
| (e.g. modifying the object signal count accordingly with its |
| thread release semantics) |
| This method should be called only after having received positive |
| response from CanThreadWaitWithoutBlocking called on the same |
| controller. |
| --*/ |
| PAL_ERROR CSynchWaitController::ReleaseWaitingThreadWithoutBlocking() |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| PAL_ERROR palErr = NO_ERROR; |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| |
| palErr = m_psdSynchData->ReleaseWaiterWithoutBlocking(m_pthrOwner, m_pthrOwner); |
| |
| #ifdef SYNCH_STATISTICS |
| if (NO_ERROR == palErr) |
| { |
| m_psdSynchData->IncrementStatWaitCount(); |
| } |
| #endif |
| return palErr; |
| } |
| |
| /*++ |
| Method: |
| CSynchWaitController::RegisterWaitingThread |
| |
| Registers the controller's owner thread for waiting on the target |
| object |
| --*/ |
| PAL_ERROR CSynchWaitController::RegisterWaitingThread( |
| WaitType wtWaitType, |
| DWORD dwIndex, |
| bool fAlertable) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| PAL_ERROR palErr = NO_ERROR; |
| WaitingThreadsListNode * pwtlnNewNode = NULL; |
| SharedID shridNewNode = NULLSharedID; |
| ThreadWaitInfo * ptwiWaitInfo; |
| DWORD * pdwWaitState; |
| bool fSharedObject = (SharedObject == m_odObjectDomain); |
| bool fEarlyDeath = false; |
| bool fSynchDataRefd = false; |
| CPalSynchronizationManager * pSynchManager = |
| CPalSynchronizationManager::GetInstance(); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| |
| ptwiWaitInfo = CPalSynchronizationManager::GetThreadWaitInfo( |
| m_pthrOwner); |
| |
| _ASSERTE(ptwiWaitInfo->pthrOwner == m_pthrOwner); |
| |
| pdwWaitState = SharedIDToTypePointer(DWORD, |
| m_pthrOwner->synchronizationInfo.m_shridWaitAwakened); |
| |
| if (fSharedObject) |
| { |
| shridNewNode = pSynchManager->CacheGetSharedWTListNode(m_pthrOwner); |
| pwtlnNewNode = SharedIDToTypePointer(WaitingThreadsListNode, shridNewNode); |
| } |
| else |
| { |
| pwtlnNewNode = pSynchManager->CacheGetLocalWTListNode(m_pthrOwner); |
| } |
| |
| if (!pwtlnNewNode) |
| { |
| if (fSharedObject && (NULLSharedID != shridNewNode)) |
| { |
| ASSERT("Bad Shared Memory ptr %p\n", shridNewNode); |
| palErr = ERROR_INTERNAL_ERROR; |
| } |
| else |
| { |
| ERROR("Out of memory\n"); |
| palErr = ERROR_NOT_ENOUGH_MEMORY; |
| } |
| goto RWT_exit; |
| } |
| |
| if (ptwiWaitInfo->lObjCount >= MAXIMUM_WAIT_OBJECTS) |
| { |
| ASSERT("Too many objects"); |
| palErr = ERROR_INTERNAL_ERROR; |
| goto RWT_exit; |
| } |
| |
| if (0 == ptwiWaitInfo->lObjCount) |
| { |
| ptwiWaitInfo->wtWaitType = wtWaitType; |
| ptwiWaitInfo->wdWaitDomain = m_wdWaitDomain; |
| } |
| else |
| { |
| _ASSERT_MSG(wtWaitType == ptwiWaitInfo->wtWaitType, |
| "Conflicting wait types in wait registration\n"); |
| |
| if (m_wdWaitDomain != ptwiWaitInfo->wdWaitDomain) |
| { |
| ptwiWaitInfo->wdWaitDomain = MixedWait; |
| } |
| } |
| |
| pwtlnNewNode->shridSHRThis = NULLSharedID; |
| pwtlnNewNode->ptwiWaitInfo = ptwiWaitInfo; |
| pwtlnNewNode->dwObjIndex = dwIndex; |
| pwtlnNewNode->dwProcessId = gPID; |
| pwtlnNewNode->dwThreadId = m_pthrOwner->GetThreadId(); |
| pwtlnNewNode->dwFlags = (MultipleObjectsWaitAll == wtWaitType) ? |
| WTLN_FLAG_WAIT_ALL : 0; |
| pwtlnNewNode->shridWaitingState = m_pthrOwner->synchronizationInfo.m_shridWaitAwakened; |
| if (fSharedObject) |
| { |
| pwtlnNewNode->dwFlags |= WTLN_FLAG_OWNER_OBJECT_IS_SHARED; |
| pwtlnNewNode->shridSHRThis = shridNewNode; |
| pwtlnNewNode->ptrOwnerObjSynchData.shrid = m_psdSynchData->GetSharedThis(); |
| } |
| else |
| { |
| pwtlnNewNode->ptrOwnerObjSynchData.ptr = m_psdSynchData; |
| } |
| |
| // AddRef the synch data (will be released in UnregisterWait) |
| m_psdSynchData->AddRef(); |
| fSynchDataRefd = true; |
| |
| ptwiWaitInfo->rgpWTLNodes[ptwiWaitInfo->lObjCount] = pwtlnNewNode; |
| |
| if(otiProcess == m_psdSynchData->GetObjectTypeId()) |
| { |
| CProcProcessLocalData * pProcLocalData = GetProcessLocalData(); |
| |
| if (NULL == pProcLocalData) |
| { |
| // Process local data pointer not set in the controller. |
| // This pointer is set in CSynchWaitController only when the |
| // wait controller for the object is created by calling |
| // GetSynchWaitControllersForObjects |
| ASSERT("Process synch data pointer is missing\n"); |
| palErr = ERROR_INTERNAL_ERROR; |
| goto RWT_exit; |
| } |
| |
| palErr = pSynchManager->RegisterProcessForMonitoring(m_pthrOwner, |
| m_psdSynchData, |
| pProcLocalData); |
| if (NO_ERROR != palErr) |
| { |
| goto RWT_exit; |
| } |
| } |
| |
| if (0 == ptwiWaitInfo->lObjCount) |
| { |
| DWORD dwWaitState; |
| |
| // Setting the thread in wait state |
| dwWaitState = (DWORD)(fAlertable ? TWS_ALERTABLE: TWS_WAITING); |
| |
| TRACE("Switching my wait state [%p] from TWS_ACTIVE to %u \n", |
| pdwWaitState, dwWaitState); |
| |
| dwWaitState = InterlockedCompareExchange( |
| (LONG *)pdwWaitState, (LONG)dwWaitState, TWS_ACTIVE); |
| if ((DWORD)TWS_ACTIVE != dwWaitState) |
| { |
| if ((DWORD)TWS_EARLYDEATH == dwWaitState) |
| { |
| // Process is terminating, this thread will soon be |
| // suspended (by SuspendOtherThreads). |
| WARN("Thread is about to get suspended by " |
| "TerminateProcess\n"); |
| |
| fEarlyDeath = true; |
| palErr = WAIT_FAILED; |
| } |
| else |
| { |
| ASSERT("Unexpected thread wait state %d\n", dwWaitState); |
| palErr = ERROR_INTERNAL_ERROR; |
| } |
| goto RWT_exit; |
| } |
| } |
| |
| // Add new node to queue |
| if (fSharedObject) |
| { |
| m_psdSynchData->SharedWaiterEnqueue(shridNewNode); |
| ptwiWaitInfo->lSharedObjCount += 1; |
| } |
| else |
| { |
| m_psdSynchData->WaiterEnqueue(pwtlnNewNode); |
| } |
| |
| // Succeeded: update object count |
| ptwiWaitInfo->lObjCount++; |
| |
| RWT_exit: |
| if (palErr != NO_ERROR) |
| { |
| // Unregister any partial wait registration |
| pSynchManager->UnRegisterWait(m_pthrOwner, ptwiWaitInfo, fSharedObject); |
| |
| if (fSynchDataRefd) |
| { |
| m_psdSynchData->Release(m_pthrOwner); |
| } |
| if ((fSharedObject) && (NULLSharedID != shridNewNode)) |
| { |
| pSynchManager->CacheAddSharedWTListNode(m_pthrOwner, shridNewNode); |
| } |
| else if (NULL != pwtlnNewNode) |
| { |
| pSynchManager->CacheAddLocalWTListNode(m_pthrOwner, pwtlnNewNode); |
| } |
| |
| if (fEarlyDeath) |
| { |
| // Early death detected, i.e. the process is about to exit. |
| // We need to completely release the synch lock(s) before |
| // going to sleep |
| LONG lLocalSynchLockCount; |
| LONG lSharedSynchLockCount; |
| |
| lSharedSynchLockCount = CPalSynchronizationManager::ResetSharedSynchLock(m_pthrOwner); |
| lLocalSynchLockCount = CPalSynchronizationManager::ResetLocalSynchLock(m_pthrOwner); |
| |
| _ASSERTE(0 < lLocalSynchLockCount); |
| |
| // Sleep for ever |
| CPalSynchronizationManager::ThreadPrepareForShutdown(); |
| } |
| } |
| #ifdef SYNCH_STATISTICS |
| else |
| { |
| m_psdSynchData->IncrementStatWaitCount(); |
| m_psdSynchData->IncrementStatContentionCount(); |
| } |
| #endif |
| return palErr; |
| } |
| |
| /*++ |
| Method: |
| CSynchWaitController::ReleaseController |
| |
| Releases the current controller |
| --*/ |
| void CSynchWaitController::ReleaseController() |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| |
| Release(); |
| } |
| |
| /*++ |
| Method: |
| CSynchWaitController::GetProcessLocalData |
| |
| Accessor Get method for process local data of the target object |
| --*/ |
| CProcProcessLocalData * CSynchWaitController::GetProcessLocalData() |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERT_MSG(NULL != m_pProcLocalData, |
| "Pointer to process local data not yet initialized\n"); |
| |
| return m_pProcLocalData; |
| } |
| |
| /*++ |
| Method: |
| CSynchWaitController::SetProcessLocalData |
| |
| Accessor Set method for process local data of the target object |
| --*/ |
| void CSynchWaitController::SetProcessLocalData(CProcProcessLocalData * pProcLocalData) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| m_pProcLocalData = pProcLocalData; |
| } |
| |
| ///////////////////////////// |
| // // |
| // CSynchStateController // |
| // // |
| ///////////////////////////// |
| |
| /*++ |
| Method: |
| CSynchStateController::GetSignalCount |
| |
| Returns the current signal count of the target object |
| --*/ |
| PAL_ERROR CSynchStateController::GetSignalCount(LONG *plSignalCount) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| PAL_ERROR palErr = NO_ERROR; |
| LONG lCount = m_psdSynchData->GetSignalCount(); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERTE(NULL != plSignalCount); |
| _ASSERT_MSG(0 <= lCount, |
| "Internal error: negative signal count [signal count=%d]", |
| lCount); |
| |
| *plSignalCount = lCount; |
| return palErr; |
| } |
| |
| /*++ |
| Method: |
| CSynchStateController::SetSignalCount |
| |
| Sets the signal count of the target object, possibly triggering |
| waiting threads awakening. |
| --*/ |
| PAL_ERROR CSynchStateController::SetSignalCount(LONG lNewCount) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERTE(lNewCount >= 0); |
| |
| m_psdSynchData->Signal(m_pthrOwner, lNewCount, false); |
| |
| return NO_ERROR; |
| } |
| |
| /*++ |
| Method: |
| CSynchStateController::IncrementSignalCount |
| |
| Increments the signal count of the target object, possibly triggering |
| waiting threads awakening. |
| --*/ |
| PAL_ERROR CSynchStateController::IncrementSignalCount( |
| LONG lAmountToIncrement) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERTE(lAmountToIncrement > 0); |
| |
| LONG lOldCount = m_psdSynchData->GetSignalCount(); |
| LONG lNewCount = lOldCount + lAmountToIncrement; |
| |
| _ASSERT_MSG(lNewCount > lOldCount, |
| "Signal count increment %d would make current signal count %d to " |
| "wrap around\n", lAmountToIncrement, lOldCount); |
| |
| m_psdSynchData->Signal(m_pthrOwner, lNewCount, false); |
| |
| return NO_ERROR; |
| } |
| |
| /*++ |
| Method: |
| CSynchStateController::DecrementSignalCount |
| |
| Decrements the signal count of the target object. |
| --*/ |
| PAL_ERROR CSynchStateController::DecrementSignalCount( |
| LONG lAmountToDecrement) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERTE(lAmountToDecrement > 0); |
| |
| PAL_ERROR palErr = NO_ERROR; |
| LONG lCount = m_psdSynchData->GetSignalCount(); |
| _ASSERTE(lAmountToDecrement <= lCount); |
| |
| m_psdSynchData->SetSignalCount(lCount - lAmountToDecrement); |
| |
| return palErr; |
| } |
| |
| /*++ |
| Method: |
| CSynchStateController::SetOwner |
| |
| Sets the owner of the target object and initializes the ownership |
| count to 1 (for objects with tracked ownership). |
| --*/ |
| PAL_ERROR CSynchStateController::SetOwner(CPalThread * pNewOwningThread) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| PAL_ERROR palErr = NO_ERROR; |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERTE(NULL != pNewOwningThread); |
| _ASSERT_MSG(CObjectType::OwnershipTracked == |
| m_potObjectType->GetOwnershipSemantics(), |
| "SetOwner called on an object without OwnershipTracked " |
| "semantics\n"); |
| |
| if (0 != m_psdSynchData->GetOwnershipCount()) |
| { |
| ASSERT("Ownership count should be zero at this time\n"); |
| palErr = ERROR_INTERNAL_ERROR; |
| goto SO_exit; |
| } |
| |
| palErr = m_psdSynchData->AssignOwnershipToThread(m_pthrOwner, |
| pNewOwningThread); |
| |
| _ASSERT_MSG(0 == m_psdSynchData->GetOwnershipCount() || |
| 0 == m_psdSynchData->GetSignalCount(), |
| "Conflicting values for SignalCount [%d] and " |
| "OwnershipCount [%d]\n", |
| m_psdSynchData->GetOwnershipCount(), |
| m_psdSynchData->GetSignalCount()); |
| |
| SO_exit: |
| return palErr; |
| } |
| |
| /*++ |
| Method: |
| CSynchStateController::DecrementOwnershipCount |
| |
| Decrements the ownership count of the target object possibly triggering |
| waiting threads awakening (for objects with tracked ownership). |
| --*/ |
| PAL_ERROR CSynchStateController::DecrementOwnershipCount() |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| PAL_ERROR palErr = NO_ERROR; |
| LONG lOwnershipCount = m_psdSynchData->GetOwnershipCount(); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| _ASSERT_MSG(CObjectType::OwnershipTracked == |
| m_potObjectType->GetOwnershipSemantics(), |
| "Trying to decrement ownership count on an object with " |
| "ownership semantics other than OwnershipTracked\n"); |
| _ASSERT_MSG(0 <= lOwnershipCount, |
| "Operation would make ownership count negative - object " |
| "should be owned at this time [ownership count=%d]\n", |
| lOwnershipCount); |
| |
| if ( (1 > lOwnershipCount) || |
| (m_psdSynchData->GetOwnerProcessID() != gPID) || |
| (m_psdSynchData->GetOwnerThread() != m_pthrOwner) ) |
| { |
| palErr = ERROR_NOT_OWNER; |
| goto DOC_exit; |
| } |
| |
| lOwnershipCount--; |
| m_psdSynchData->SetOwnershipCount(lOwnershipCount); |
| |
| if (0 == lOwnershipCount) |
| { |
| CPalSynchronizationManager * pSynchManager = |
| CPalSynchronizationManager::GetInstance(); |
| OwnedObjectsListNode * pooln = |
| m_psdSynchData->GetOwnershipListNode(); |
| |
| _ASSERT_MSG(NULL != pooln, |
| "Null ownership node pointer in SynchData with ownership " |
| "semantics\n"); |
| _ASSERT_MSG(m_psdSynchData == pooln->pPalObjSynchData, |
| "Corrupted ownership node\n"); |
| |
| // Object has been released |
| // Remove it from list of owned objs for current thread |
| m_pthrOwner->synchronizationInfo.RemoveObjectFromOwnedList(pooln); |
| |
| // Release SynchData reference count implied by the ownership |
| // list node |
| m_psdSynchData->Release(m_pthrOwner); |
| |
| // Return node to the cache |
| pSynchManager->CacheAddOwnedObjsListNode(m_pthrOwner, pooln); |
| |
| // Reset ownership |
| m_psdSynchData->ResetOwnership(); |
| |
| // Signal it and trigger waiter thread awakening |
| m_psdSynchData->Signal(m_pthrOwner, 1, false); |
| } |
| |
| DOC_exit: |
| return palErr; |
| } |
| |
| /*++ |
| Method: |
| CSynchStateController::ReleaseController |
| |
| Releases the controller. |
| --*/ |
| void CSynchStateController::ReleaseController(void) |
| { |
| VALIDATEOBJECT(m_psdSynchData); |
| |
| _ASSERTE(InternalGetCurrentThread() == m_pthrOwner); |
| |
| Release(); |
| } |
| |
| ////////////////// |
| // // |
| // CSynchData // |
| // // |
| ////////////////// |
| |
| /*++ |
| Method: |
| CSynchData::Release |
| |
| Decremnt the reference count of the target synchdata and retrurns |
| it to the appropriate cache if the reference count reaches zero. |
| --*/ |
| LONG CSynchData::Release(CPalThread * pthrCurrent) |
| { |
| VALIDATEOBJECT(this); |
| |
| LONG lCount = InterlockedDecrement(&m_lRefCount); |
| |
| _ASSERT_MSG(0 <= lCount, |
| "CSynchData %p with negative reference count [%d]\n", |
| this, lCount); |
| |
| if (0 == lCount) |
| { |
| CPalSynchronizationManager * pSynchManager = |
| CPalSynchronizationManager::GetInstance(); |
| bool fSharedObject = (SharedObject == m_odObjectDomain); |
| |
| _ASSERT_MSG((fSharedObject && (NULLSharedID == m_ptrWTLHead.shrid)) || |
| (!fSharedObject && (NULL == m_ptrWTLHead.ptr)), |
| "Final Release on CSynchData with threads still in " |
| "the waiting list\n"); |
| |
| TRACE("Disposing %s waitable object with SynchData @ " |
| "{shrid=%p, p=%p}\n", |
| (SharedObject == m_odObjectDomain) ? "shared" : "local", |
| (PVOID)m_shridThis, this); |
| |
| |
| #ifdef SYNCH_STATISTICS |
| LONG lStatWaitCount = GetStatWaitCount(); |
| LONG lStatContentionCount = GetStatContentionCount(); |
| LONG lCount, lNewCount; |
| |
| TRACE("Statistical data for SynchData of otiType=%u @ %p: WaitCount=%d " |
| "ContentionCount=%d\n", m_otiObjectTypeId, this, lStatWaitCount, |
| lStatContentionCount); |
| |
| do { |
| lCount = g_rglStatWaitCount[m_otiObjectTypeId]; |
| lNewCount = lCount + lStatWaitCount; |
| lNewCount = InterlockedCompareExchange(&(g_rglStatWaitCount[m_otiObjectTypeId]), |
| lNewCount, lCount); |
| } while (lCount != lNewCount); |
| |
| lStatWaitCount = lNewCount; |
| |
| do { |
| lCount = g_rglStatContentionCount[m_otiObjectTypeId]; |
| lNewCount = lCount + lStatContentionCount; |
| lNewCount = InterlockedCompareExchange(&(g_rglStatContentionCount[m_otiObjectTypeId]), |
| lNewCount, lCount); |
| } while (lCount != lNewCount); |
| |
| lStatContentionCount = lNewCount; |
| |
| TRACE("Total current statistical data for otiType=%u objects: WaitCount=%d " |
| "ContentionCount=%d\n", m_otiObjectTypeId, lStatWaitCount, |
| lStatContentionCount); |
| #endif // SYNCH_STATISTICS |
| |
| if (fSharedObject) |
| { |
| pSynchManager->CacheAddSharedSynchData(pthrCurrent, m_shridThis); |
| } |
| else |
| { |
| pSynchManager->CacheAddLocalSynchData(pthrCurrent, this); |
| } |
| } |
| |
| return lCount; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::ReleaseWaiterWithoutBlocking |
| |
| Performs all the steps needed to be done by the target thread in order |
| to wait without blocking on the object associated with the current |
| SynchData (e.g. modifying the object signal count accordingly with its |
| thread release semantics) |
| |
| Note: this method must be called while holding the appropriate |
| synchronization locks (the local process synch lock if the target |
| object is local, both local and shared one if the object is shared). |
| --*/ |
| PAL_ERROR CSynchData::ReleaseWaiterWithoutBlocking( |
| CPalThread * pthrCurrent, |
| CPalThread * pthrTarget) |
| { |
| VALIDATEOBJECT(this); |
| |
| PAL_ERROR palErr = NO_ERROR; |
| CObjectType * potObjectType = GetObjectType(); |
| #ifdef _DEBUG |
| CObjectType::SignalingSemantics ssSignalingSemantics = |
| potObjectType->GetSignalingSemantics(); |
| #endif // _DEBUG |
| CObjectType::OwnershipSemantics osOwnershipSemantics = |
| potObjectType->GetOwnershipSemantics(); |
| CObjectType::ThreadReleaseSemantics trsThreadReleaseSemantics = |
| potObjectType->GetThreadReleaseSemantics(); |
| bool fReenteringObjWithOwnership = false; |
| |
| _ASSERT_MSG(CObjectType::SignalingNotApplicable != ssSignalingSemantics, |
| "Signaling not applicable"); |
| _ASSERT_MSG(CObjectType::ThreadReleaseNotApplicable != |
| trsThreadReleaseSemantics, |
| "Thread releasing not applicable"); |
| _ASSERT_MSG(CObjectType::SingleTransitionObject != ssSignalingSemantics || |
| (CObjectType::ThreadReleaseHasNoSideEffects == |
| trsThreadReleaseSemantics && |
| CObjectType::NoOwner == osOwnershipSemantics), |
| "Conflicting object synchronization attributes " |
| "[SignalingSemantics=%u OwnershipSemantics=%u " |
| "ThreadReleaseSemantics=%u]\n", ssSignalingSemantics, |
| osOwnershipSemantics, trsThreadReleaseSemantics); |
| |
| if (CObjectType::OwnershipTracked == osOwnershipSemantics && |
| 0 < GetOwnershipCount()) |
| { |
| // We are rentering an object with ownership: we need to skip |
| // the object unsignaling |
| fReenteringObjWithOwnership = true; |
| } |
| |
| if (!fReenteringObjWithOwnership && |
| CObjectType::ThreadReleaseAltersSignalCount == trsThreadReleaseSemantics) |
| { |
| _ASSERT_MSG(0 < GetSignalCount(), |
| "Internal error: operation would make signal count " |
| "negative - object should be signaled at this time " |
| "[signal count=%d]", GetSignalCount()); |
| _ASSERT_MSG(CObjectType::OwnershipTracked != osOwnershipSemantics || |
| 1 == GetSignalCount(), |
| "Ownable objects cannot have signal count greater " |
| "than zero [current SignalCount=%d]\n", |
| GetSignalCount()); |
| |
| // Unsignal the object |
| DecrementSignalCount(); |
| } |
| |
| if (CObjectType::OwnershipTracked == osOwnershipSemantics) |
| { |
| _ASSERT_MSG(0 == GetOwnershipCount() || 0 == GetSignalCount(), |
| "OwnershipCount and SignalCount with conflicting " |
| "values\n"); |
| |
| // Take ownership or increment ownership count. |
| // We do this after the object unsignaling to minimize possibilities |
| // of having both SignalCount and OwnershipCount greater than zero |
| // (see comment in AssignOwnershipToThread) |
| palErr = AssignOwnershipToThread(pthrCurrent, pthrTarget); |
| |
| if (NO_ERROR != palErr) |
| { |
| ERROR("AssignOwnershipToThread failed with error %u; " |
| "ownership data on object with SynchData {shrid=%p p=%p} " |
| "may be corrupted\n", palErr, (void *)m_shridThis, this); |
| } |
| } |
| |
| #ifdef SYNCH_STATISTICS |
| if (NO_ERROR == palErr) |
| { |
| IncrementStatWaitCount(); |
| } |
| #endif |
| return palErr; |
| |
| } |
| |
| /*++ |
| Method: |
| CSynchData::CanWaiterWaitWithoutBlocking |
| |
| Returns whether or not the waiter thread can wait on the target object |
| without blocking (i.e. the objet is signaled) |
| |
| Note: this method must be called while holding the appropriate |
| synchronization locks (the local process synch lock if the target |
| object is local, both local and shared one if the object is shared). |
| --*/ |
| bool CSynchData::CanWaiterWaitWithoutBlocking( |
| CPalThread * pWaiterThread, |
| bool * pfAbandoned) |
| { |
| VALIDATEOBJECT(this); |
| |
| bool fRetVal = (0 < GetSignalCount()); |
| bool fAbandoned = false; |
| bool fOwnershipTracked = (CObjectType::OwnershipTracked == |
| GetObjectType()->GetOwnershipSemantics()); |
| if (fRetVal) |
| { |
| // Object signaled: thread can wait without blocking |
| if (fOwnershipTracked) |
| { |
| fAbandoned = IsAbandoned(); |
| } |
| |
| goto CWWWB_exit; |
| } |
| |
| // Object not signaled: thread can wait without blocking only if the |
| // object is an ownable one, and it is owned by the current thread |
| if (fOwnershipTracked) |
| { |
| _ASSERT_MSG(0 < GetSignalCount() || 0 < GetOwnershipCount(), |
| "Objects with ownership must be either signaled or " |
| "owned by a thread\n"); |
| |
| if ((GetOwnerProcessID() == gPID) && |
| (GetOwnerThread() == pWaiterThread) ) |
| { |
| fRetVal = true; |
| goto CWWWB_exit; |
| } |
| } |
| |
| CWWWB_exit: |
| *pfAbandoned = fAbandoned; |
| return fRetVal; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::Signal |
| |
| Sets the signal count of the object owning the target SynchData, |
| possibly triggering awakening of waiting threads. |
| |
| Note: this method must be called while holding the appropriate |
| synchronization locks (the local process synch lock if the target |
| object is local, both local and shared one if the object is shared). |
| --*/ |
| void CSynchData::Signal( |
| CPalThread * pthrCurrent, |
| LONG lSignalCount, |
| bool fWorkerThread) |
| { |
| VALIDATEOBJECT(this); |
| |
| bool fThreadReleased = false; |
| bool fDelegatedSignaling = false; |
| bool fReleaseAltersSignalCount = |
| (CObjectType::ThreadReleaseAltersSignalCount == |
| GetObjectType()->GetThreadReleaseSemantics()); |
| |
| _ASSERTE(0 <= lSignalCount); |
| |
| // Preset the signal count to the new value, so that it can be used |
| // by ReleaseFirstWaiter when delegating signaling to another process |
| m_lSignalCount = lSignalCount; |
| |
| while (m_lSignalCount > 0) |
| { |
| fThreadReleased = ReleaseFirstWaiter(pthrCurrent, |
| &fDelegatedSignaling, |
| fWorkerThread); |
| if (!fThreadReleased) |
| { |
| // No more threads to release: break out of the loop |
| // keeping the current signal count |
| break; |
| } |
| if (fReleaseAltersSignalCount) |
| { |
| // Adjust signal count |
| m_lSignalCount--; |
| } |
| if (fDelegatedSignaling) |
| { |
| // Object signaling has been delegated |
| m_lSignalCount = 0; |
| } |
| } |
| |
| _ASSERT_MSG(CObjectType::OwnershipTracked != |
| GetObjectType()->GetOwnershipSemantics() || |
| 0 == GetOwnershipCount() || 0 == GetSignalCount(), |
| "Conflicting values for SignalCount [%d] and " |
| "OwnershipCount [%d]\n", |
| GetOwnershipCount(), GetSignalCount()); |
| |
| _ASSERT_MSG(otiMutex != m_otiObjectTypeId || m_lSignalCount <= 1, |
| "Mutex with invalid singal count\n"); |
| |
| return; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::ReleaseFirstWaiter |
| |
| Releases the first thread from the front of the list of waiting threads |
| whose wait is fully satisfied, possibly triggering remote awakening (if |
| the target thread lives in a different process) or object signaling |
| delegation (if the target thread lives in a different processing and it |
| is blocked on a wait-all). |
| |
| Note: this method must be called while holding the appropriate |
| synchronization locks (the local process synch lock if the target |
| object is local, both local and shared one if the object is shared). |
| --*/ |
| bool CSynchData::ReleaseFirstWaiter( |
| CPalThread * pthrCurrent, |
| bool * pfDelegated, |
| bool fWorkerThread) |
| { |
| PAL_ERROR palErr = NO_ERROR; |
| bool fSharedSynchLock = false; |
| bool fSharedObject = (SharedObject == GetObjectDomain()); |
| bool fThreadAwakened = false; |
| bool fDelegatedSignaling = false; |
| DWORD * pdwWaitState; |
| DWORD dwObjIdx; |
| SharedID shridItem = NULLSharedID, shridNextItem = NULLSharedID; |
| WaitingThreadsListNode * pwtlnItem, * pwtlnNextItem; |
| DWORD dwPid = gPID; |
| CPalSynchronizationManager * pSynchManager = |
| CPalSynchronizationManager::GetInstance(); |
| |
| VALIDATEOBJECT(this); |
| |
| *pfDelegated = false; |
| |
| if (fSharedObject) |
| { |
| shridItem = GetWTLHeadShmPtr(); |
| pwtlnItem = SharedIDToTypePointer(WaitingThreadsListNode, shridItem); |
| } |
| else |
| { |
| pwtlnItem = GetWTLHeadPtr(); |
| } |
| |
| while (pwtlnItem) |
| { |
| VALIDATEOBJECT(pwtlnItem); |
| |
| WaitCompletionState wcsWaitCompletionState; |
| bool fWaitAll = (0 != (WTLN_FLAG_WAIT_ALL & pwtlnItem->dwFlags)); |
| pdwWaitState = SharedIDToTypePointer(DWORD, |
| pwtlnItem->shridWaitingState); |
| |
| if (fSharedObject) |
| { |
| shridNextItem = pwtlnItem->ptrNext.shrid; |
| pwtlnNextItem = SharedIDToTypePointer(WaitingThreadsListNode, |
| shridNextItem); |
| } |
| else |
| { |
| pwtlnNextItem = pwtlnItem->ptrNext.ptr; |
| } |
| |
| if (fWaitAll) |
| { |
| // Wait All: we need to find out whether the wait is satisfied, |
| // or it is not, or if that cannot be determined from within |
| // this process (WaitMayBeSatisfied); in this case we need to |
| // delegate the object signaling to the process hosting the |
| // thread that owns the current target WaitingThreadsListNode |
| |
| // If the target object is local (fSharedObject == false) |
| // we're probably not holding the shared lock. |
| // If the wait is not a LocalWait, it involves at least one |
| // shared object. If that is the case, at this time we need |
| // to grab the shared lock. In fact IsRestOfWaitAllSatisfied |
| // and UnsignalRestOfLocalAwakeningWaitAll must be called |
| // atomically to prevent that another thread living |
| // in a different process could race with us stealing the |
| // signaling from one of the objects involved in the wait-all. |
| // |
| // Note: pwtlnItem->ptwiWaitInfo is valid only if the target |
| // wait originates in the current process. Anyway in the |
| // following 'if' we don't need to check that since we are |
| // already making sure that the object is local (!fSharedObject). |
| // If a wait involves at least one object local to this process, |
| // it can only be a wait performed by a thread in the current |
| // process, therefore pwtlnItem->ptwiWaitInfo is valid. |
| |
| _ASSERTE(fSharedObject || pwtlnItem->dwProcessId == gPID); |
| |
| if (!fSharedSynchLock && !fSharedObject && |
| LocalWait != pwtlnItem->ptwiWaitInfo->wdWaitDomain) |
| { |
| CPalSynchronizationManager::AcquireSharedSynchLock(pthrCurrent); |
| fSharedSynchLock = true; |
| } |
| |
| // First check if the current target node is already marked for |
| // wait all check in progress, and in case skip it by setting |
| // wcsWaitCompletionState to WaitIsNotSatisfied |
| bool fMarkedForDelegatedObjectSingalingInProgress = |
| (0 != (WTLN_FLAG_DELEGATED_OBJECT_SIGNALING_IN_PROGRESS & pwtlnItem->dwFlags)); |
| |
| wcsWaitCompletionState = |
| fMarkedForDelegatedObjectSingalingInProgress ? WaitIsNotSatisfied : |
| IsRestOfWaitAllSatisfied(pwtlnItem); |
| } |
| else |
| { |
| // Normal Wait: the wait is satisfied by definition |
| wcsWaitCompletionState = WaitIsSatisfied; |
| } |
| |
| if (WaitIsSatisfied == wcsWaitCompletionState) |
| { |
| // |
| // Target wait is satisfied |
| // |
| TRACE("Trying to switch wait state [%p] from WAIT/ALERTABLE " |
| "to ACTIVE for thread=%u\n", |
| pdwWaitState, pwtlnItem->dwThreadId); |
| |
| if (CPalSynchronizationManager::InterlockedAwaken(pdwWaitState, FALSE)) |
| { |
| TRACE("Succeeded switching wait state [%p] from WAIT/ALERTABLE " |
| "to TWS_ACTIVE for trhead=%u\n", |
| pdwWaitState, pwtlnItem->dwThreadId); |
| |
| dwObjIdx = pwtlnItem->dwObjIndex; |
| |
| if (dwPid == pwtlnItem->dwProcessId) |
| { |
| /////////////////////////// |
| // |
| // Local Thread Awakening |
| // |
| /////////////////////////// |
| ThreadWaitInfo * ptwiWaitInfo = pwtlnItem->ptwiWaitInfo; |
| bool fAbandoned = false; |
| |
| if (CObjectType::OwnershipTracked == |
| GetObjectType()->GetOwnershipSemantics()) |
| { |
| // Get the abandoned status before resetting it by |
| // assigning ownership to target thread |
| fAbandoned = IsAbandoned(); |
| |
| // Assign ownership to target thread |
| // Note: This will cause both ownership count and |
| // signal count to be greater than zero at the |
| // same time; the signal count will be anyway |
| // decremented immediately by the caller |
| // CsynchData::Signal |
| palErr = AssignOwnershipToThread(pthrCurrent, |
| ptwiWaitInfo->pthrOwner); |
| if (NO_ERROR != palErr) |
| { |
| ERROR("Synch Worker: AssignOwnershipToThread " |
| "failed with error %u; ownership data on " |
| "object with SynchData %p may be " |
| "corrupted\n", palErr, this); |
| } |
| } |
| |
| if (fWaitAll) |
| { |
| // Wait all satisfied: unsignal other objects |
| // involved in the wait |
| CPalSynchronizationManager::UnsignalRestOfLocalAwakeningWaitAll( |
| pthrCurrent, |
| ptwiWaitInfo->pthrOwner, |
| pwtlnItem, |
| this); |
| } |
| |
| TRACE("Unregistering wait for thread %u and waking it up " |
| "[pdwWaitState=%p]\n", pwtlnItem->dwThreadId, |
| pdwWaitState); |
| |
| // Unregister the wait |
| pSynchManager->UnRegisterWait(pthrCurrent, |
| ptwiWaitInfo, |
| fSharedObject || fSharedSynchLock); |
| |
| // After UnRegisterWait pwtlnItem is invalid |
| pwtlnItem = NULL; |
| |
| palErr = CPalSynchronizationManager::WakeUpLocalThread( |
| pthrCurrent, |
| ptwiWaitInfo->pthrOwner, |
| fAbandoned ? MutexAbondoned : WaitSucceeded, |
| dwObjIdx); |
| |
| if (NO_ERROR != palErr) |
| { |
| ERROR("Failed to wakeup local thread %#x: " |
| "object signaling may be " |
| "lost\n", ptwiWaitInfo->pthrOwner->GetThreadId()); |
| } |
| } |
| else |
| { |
| /////////////////////////// |
| // |
| // Remote Thread Awakening |
| // |
| /////////////////////////// |
| |
| // Note: if we are here, this cannot be a wait-all |
| _ASSERT_MSG(!fWaitAll, |
| "Control should never reach this point if " |
| "target wait is a wait-all\n"); |
| |
| // Wake up remote thread |
| palErr = CPalSynchronizationManager::WakeUpRemoteThread(shridItem); |
| |
| if (NO_ERROR != palErr) |
| { |
| ERROR("Failed to dispatch remote awakening cmd to " |
| "worker thread in process pid=%d to wake up" |
| "thread tid=%#x; object signaling may be " |
| "lost\n", pwtlnItem->dwProcessId, |
| pwtlnItem->dwThreadId); |
| } |
| } |
| |
| // A thread has been awakened |
| fThreadAwakened = true; |
| |
| // break out of the while loop |
| break; |
| } |
| } |
| else if (WaitMayBeSatisfied == wcsWaitCompletionState) |
| { |
| ////////////////////////////////////////// |
| // |
| // Wait All with remote thread awakening |
| // |
| ////////////////////////////////////////// |
| |
| // |
| // We need to transfer the object signaling to the process |
| // hosting the target waiter thread |
| // |
| |
| _ASSERT_MSG(fWaitAll, |
| "IsRestOfWaitAllSatisfied() apparently " |
| "returned -1 on a normal (non wait all) " |
| "wait\n"); |
| _ASSERT_MSG(fSharedObject, |
| "About to delegate object signaling to a remote " |
| "process, but the signaled object is actually " |
| "local\n"); |
| |
| // Delegate object signaling to target process |
| palErr = CPalSynchronizationManager::DelegateSignalingToRemoteProcess( |
| pthrCurrent, |
| pwtlnItem->dwProcessId, |
| pwtlnItem->ptrOwnerObjSynchData.shrid); |
| |
| TRACE("Delegating object signaling for SynchData shrid=%p\n", |
| (VOID *)pwtlnItem->ptrOwnerObjSynchData.shrid); |
| |
| if (NO_ERROR == palErr) |
| { |
| // A remote thread will be awakened |
| // This will also cause the object to be unsignaled by the |
| // code calling ReleaseFirstWaiter before releasing the |
| // synch locks, so no other WaitForMultipleObjects |
| // involving the target object may race stealing this |
| // particuklar object signaling |
| fThreadAwakened = true; |
| |
| fDelegatedSignaling = true; |
| |
| // break out of the while loop |
| break; |
| } |
| else |
| { |
| ERROR("Failed to delegate object signaling to remote " |
| "process %d. Looking for another waiter.\n", |
| pwtlnItem->dwProcessId); |
| |
| // Go on: a different target waiter will be selected |
| } |
| } |
| |
| if (fWorkerThread && fWaitAll && (dwPid == pwtlnItem->dwProcessId)) |
| { |
| // Mark the target wait for object signaling |
| CPalSynchronizationManager::MarkWaitForDelegatedObjectSignalingInProgress( |
| pthrCurrent, |
| pwtlnItem); |
| } |
| |
| // Go to the next item |
| shridItem = shridNextItem; |
| pwtlnItem = pwtlnNextItem; |
| } |
| |
| if (fDelegatedSignaling) |
| { |
| *pfDelegated = true; |
| } |
| else if (fWorkerThread) |
| { |
| // Reset 'delegated object signaling in progress' flags |
| CPalSynchronizationManager::UnmarkTWListForDelegatedObjectSignalingInProgress( |
| this); |
| } |
| |
| if (fSharedSynchLock) |
| { |
| CPalSynchronizationManager::ReleaseSharedSynchLock(pthrCurrent); |
| } |
| return fThreadAwakened; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::Signal |
| |
| Releases all the threads waiting on this object and living in the current |
| process. |
| |
| Note: this method must be called while holding the appropriate |
| synchronization locks (the local process synch lock if the target |
| object is local, both local and shared one if the object is shared). |
| --*/ |
| LONG CSynchData::ReleaseAllLocalWaiters( |
| CPalThread * pthrCurrent) |
| { |
| PAL_ERROR palErr = NO_ERROR; |
| LONG lAwakenedCount = 0; |
| bool fSharedSynchLock = false; |
| bool fSharedObject = (SharedObject == GetObjectDomain()); |
| DWORD * pdwWaitState; |
| DWORD dwObjIdx; |
| SharedID shridItem = NULLSharedID, shridNextItem = NULLSharedID; |
| WaitingThreadsListNode * pwtlnItem, * pwtlnNextItem; |
| DWORD dwPid = gPID; |
| CPalSynchronizationManager * pSynchManager = |
| CPalSynchronizationManager::GetInstance(); |
| |
| VALIDATEOBJECT(this); |
| |
| if (fSharedObject) |
| { |
| shridItem = GetWTLHeadShmPtr(); |
| pwtlnItem = SharedIDToTypePointer(WaitingThreadsListNode, shridItem); |
| } |
| else |
| { |
| pwtlnItem = GetWTLHeadPtr(); |
| } |
| |
| while (pwtlnItem) |
| { |
| VALIDATEOBJECT(pwtlnItem); |
| |
| bool fWaitAll = (0 != (WTLN_FLAG_WAIT_ALL & pwtlnItem->dwFlags)); |
| pdwWaitState = SharedIDToTypePointer(DWORD, |
| pwtlnItem->shridWaitingState); |
| |
| if (fSharedObject) |
| { |
| shridNextItem = pwtlnItem->ptrNext.shrid; |
| pwtlnNextItem = SharedIDToTypePointer(WaitingThreadsListNode, |
| shridNextItem); |
| } |
| else |
| { |
| pwtlnNextItem = pwtlnItem->ptrNext.ptr; |
| } |
| |
| // See note in similar spot in ReleaseFirstWaiter |
| |
| _ASSERTE(fSharedObject || pwtlnItem->dwProcessId == gPID); |
| |
| if (!fSharedSynchLock && !fSharedObject && |
| LocalWait != pwtlnItem->ptwiWaitInfo->wdWaitDomain) |
| { |
| CPalSynchronizationManager::AcquireSharedSynchLock(pthrCurrent); |
| fSharedSynchLock = true; |
| } |
| |
| if( dwPid == pwtlnItem->dwProcessId && |
| (!fWaitAll || WaitIsSatisfied == IsRestOfWaitAllSatisfied(pwtlnItem)) ) |
| { |
| // |
| // Target wait is satisfied |
| // |
| TRACE("Trying to switch wait state [%p] from WAIT/ALERTABLE " |
| "to ACTIVE for thread=%u\n", |
| pdwWaitState, pwtlnItem->dwThreadId); |
| |
| if (CPalSynchronizationManager::InterlockedAwaken(pdwWaitState, FALSE)) |
| { |
| TRACE("Succeeded switching wait state [%p] from WAIT/ALERTABLE " |
| "to TWS_ACTIVE for trhead=%u\n", |
| pdwWaitState, pwtlnItem->dwThreadId); |
| |
| dwObjIdx = pwtlnItem->dwObjIndex; |
| |
| ThreadWaitInfo * ptwiWaitInfo = pwtlnItem->ptwiWaitInfo; |
| bool fAbandoned = false; |
| |
| if (CObjectType::OwnershipTracked == |
| GetObjectType()->GetOwnershipSemantics()) |
| { |
| // Get the abandoned status before resetting it by |
| // assigning ownership to target thread |
| fAbandoned = IsAbandoned(); |
| |
| // Assign ownership to target thread |
| palErr = AssignOwnershipToThread(pthrCurrent, |
| ptwiWaitInfo->pthrOwner); |
| if (NO_ERROR != palErr) |
| { |
| ERROR("Synch Worker: AssignOwnershipToThread " |
| "failed with error %u; ownership data on " |
| "object with SynchData %p may be " |
| "corrupted\n", palErr, this); |
| } |
| } |
| |
| if (fWaitAll) |
| { |
| // Wait all satisfied: unsignal other objects |
| // involved in the wait |
| CPalSynchronizationManager::UnsignalRestOfLocalAwakeningWaitAll( |
| pthrCurrent, |
| ptwiWaitInfo->pthrOwner, |
| pwtlnItem, |
| this); |
| } |
| |
| TRACE("Unregistering wait for thread %u and waking it up " |
| "[pdwWaitState=%p]\n", pwtlnItem->dwThreadId, |
| pdwWaitState); |
| |
| // Unregister the wait |
| pSynchManager->UnRegisterWait(pthrCurrent, |
| ptwiWaitInfo, |
| fSharedObject || fSharedSynchLock); |
| |
| // After UnRegisterWait pwtlnItem is invalid |
| pwtlnItem = NULL; |
| |
| palErr = CPalSynchronizationManager::WakeUpLocalThread( |
| pthrCurrent, |
| ptwiWaitInfo->pthrOwner, |
| fAbandoned ? MutexAbondoned : WaitSucceeded, |
| dwObjIdx); |
| |
| if (NO_ERROR != palErr) |
| { |
| ERROR("Failed to wakeup local thread %#x: " |
| "object signaling may be " |
| "lost\n", ptwiWaitInfo->pthrOwner->GetThreadId()); |
| } |
| else |
| { |
| // A thread has been awakened |
| lAwakenedCount++; |
| } |
| } |
| } |
| |
| // Go to the next item |
| shridItem = shridNextItem; |
| pwtlnItem = pwtlnNextItem; |
| } |
| |
| if (fSharedSynchLock) |
| { |
| CPalSynchronizationManager::ReleaseSharedSynchLock(pthrCurrent); |
| } |
| return lAwakenedCount; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::IsRestOfWaitAllSatisfied |
| |
| Returns whether or not the current wait-all operation is fully satisfied, |
| assuming the current target object as signaled (i.e. whether or not all the |
| involved object, except the current one, are signaled). |
| It returns: |
| - WaitIsNotSatisfied if the wait-all is not fully satisfied. |
| - WaitIsSatisfied if the wait-all is fully satisfied. |
| - WaitMayBeSatisfied if the target thread lives in a different process and |
| therefore the wait may involve objects local to the remote process, and |
| as result is generally not possible to say whther or not the wait-all is |
| fully satisfied from the current process. |
| |
| Note: this method must be called while holding the synchronization locks |
| appropriate to all the objects involved in the wait-all. If any |
| of the objects is shared, the caller must own both local and |
| shared synch locks; if no shared object is involved in the wait, |
| only the local synch lock is needed. |
| --*/ |
| WaitCompletionState CSynchData::IsRestOfWaitAllSatisfied( |
| WaitingThreadsListNode * pwtlnNode) |
| { |
| int iSignaledOrOwnedObjCount = 0; |
| int iTgtCount = 0; |
| int i; |
| WaitCompletionState wcsWaitCompletionState = WaitIsNotSatisfied; |
| CSynchData * psdSynchDataItem = NULL; |
| ThreadWaitInfo * ptwiWaitInfo = NULL; |
| |
| VALIDATEOBJECT(this); |
| VALIDATEOBJECT(pwtlnNode); |
| |
| _ASSERT_MSG(0 != (WTLN_FLAG_WAIT_ALL & pwtlnNode->dwFlags), |
| "IsRestOfWaitAllSatisfied() called on a normal " |
| "(non wait all) wait"); |
| _ASSERT_MSG((SharedObject == GetObjectDomain()) == |
| (0 != (WTLN_FLAG_OWNER_OBJECT_IS_SHARED & pwtlnNode->dwFlags)), |
| "WTLN_FLAG_OWNER_OBJECT_IS_SHARED in WaitingThreadsListNode " |
| "not consistent with target object's domain\n"); |
| |
| if(gPID != pwtlnNode->dwProcessId) |
| { |
| //////////////////////////// |
| // |
| // Remote Thread Awakening |
| // |
| //////////////////////////// |
| |
| // Cannot determine whether or not the wait all is satisfied from |
| // this process |
| wcsWaitCompletionState = WaitMayBeSatisfied; |
| goto IROWAS_exit; |
| } |
| |
| /////////////////////////// |
| // |
| // Local Thread Awakening |
| // |
| /////////////////////////// |
| |
| ptwiWaitInfo = pwtlnNode->ptwiWaitInfo; |
| |
| iTgtCount = ptwiWaitInfo->lObjCount; |
| for (i=0; i < iTgtCount; i++) |
| { |
| WaitingThreadsListNode * pwtlnItem = ptwiWaitInfo->rgpWTLNodes[i]; |
| bool fRetVal; |
| bool fIsAbandoned; |
| |
| VALIDATEOBJECT(pwtlnItem); |
| |
| if (0 != (WTLN_FLAG_OWNER_OBJECT_IS_SHARED & pwtlnItem->dwFlags)) |
| { |
| psdSynchDataItem = SharedIDToTypePointer(CSynchData, |
| pwtlnItem->ptrOwnerObjSynchData.shrid); |
| } |
| else |
| { |
| psdSynchDataItem = pwtlnItem->ptrOwnerObjSynchData.ptr; |
| } |
| |
| VALIDATEOBJECT(psdSynchDataItem); |
| |
| if (pwtlnItem == pwtlnNode) |
| { |
| _ASSERT_MSG (this == psdSynchDataItem, |
| "pwtlnNode and pwtlnItem match, but this " |
| "and psdSynchDataItem don't\n"); |
| |
| // The target object (the one related to pwtlnNode) is counted as |
| // signaled/owned without checking it (also if it is not, as |
| // it normally happens when this method is called) |
| iSignaledOrOwnedObjCount++; |
| continue; |
| } |
| |
| fRetVal = psdSynchDataItem->CanWaiterWaitWithoutBlocking( |
| ptwiWaitInfo->pthrOwner, |
| &fIsAbandoned); |
| |
| if (fRetVal) |
| { |
| iSignaledOrOwnedObjCount++; |
| } |
| else |
| { |
| break; |
| } |
| } |
| |
| if (iSignaledOrOwnedObjCount < iTgtCount) |
| { |
| wcsWaitCompletionState = WaitIsNotSatisfied; |
| } |
| else |
| { |
| wcsWaitCompletionState = WaitIsSatisfied; |
| } |
| |
| IROWAS_exit: |
| TRACE("IsRestOfWaitAllSatisfied() returning %u \n", wcsWaitCompletionState); |
| |
| return wcsWaitCompletionState; |
| } |
| |
| |
| /*++ |
| Method: |
| CSynchData::SetOwner |
| |
| Blindly sets the thread whose CPalThread is passed as argument, as the |
| owner of the current object. |
| WARNING: this method discards any previous ownership data and does not |
| update the list of the object owned by the owner thread. |
| |
| Note: this method must be called while holding the appropriate |
| synchronization locks (the local process synch lock if the target |
| object is local, both local and shared one if the object is shared). |
| --*/ |
| void CSynchData::SetOwner(CPalThread * pOwnerThread) |
| { |
| VALIDATEOBJECT(this); |
| |
| m_dwOwnerPid = gPID; |
| m_dwOwnerTid = pOwnerThread->GetThreadId(); |
| m_pOwnerThread = pOwnerThread; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::ResetOwnership |
| |
| Resets current object's ownership data |
| |
| Note: this method must be called while holding the appropriate |
| synchronization locks (the local process synch lock if the target |
| object is local, both local and shared one if the object is shared). |
| --*/ |
| void CSynchData::ResetOwnership() |
| { |
| VALIDATEOBJECT(this); |
| |
| m_lOwnershipCount = 0; |
| m_dwOwnerPid = 0; |
| m_dwOwnerTid = 0; |
| m_pOwnerThread = NULL; |
| m_poolnOwnedObjectListNode = NULL; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::AssignOwnershipToThread |
| |
| Assigns thw ownership of the current object to the target thread, performing |
| all the operations neede to mantain the correct status of ownership data, |
| also handling recursive object ownership acquisition |
| |
| Note: this method must be called while holding the appropriate |
| synchronization locks (the local process synch lock if the target |
| object is local, both local and shared one if the object is shared). |
| --*/ |
| PAL_ERROR CSynchData::AssignOwnershipToThread( |
| CPalThread * pthrCurrent, |
| CPalThread * pthrTarget) |
| { |
| // Note: when this method is called by ReleaseFirstWaiter there is |
| // a small time window in which both SignalCount and |
| // OwnershipCount can be greater than zero (which normally |
| // is illegal). Anyway that is fine since ReleaseFirstWaiter |
| // will restore the value right after, and such situation |
| // takes place while holding synchroniztion locks, so no |
| // other thread/process can access the object. |
| |
| PAL_ERROR palErr = NO_ERROR; |
| |
| _ASSERT_MSG(CObjectType::OwnershipTracked == |
| GetObjectType()->GetOwnershipSemantics(), |
| "AssignOwnershipToThread called on a non-ownable " |
| "CSynchData [this=%p OwnershipSemantics=%u]\n", this, |
| GetObjectType()->GetOwnershipSemantics()); |
| |
| |
| if (0 < m_lOwnershipCount) |
| { |
| // |
| // Object already owned, incrementing ownership count |
| // |
| _ASSERT_MSG(0 == GetSignalCount(), |
| "Conflicting OwnershipCount and SignalCount values\n"); |
| |
| _ASSERT_MSG(pthrTarget == m_pOwnerThread && gPID == m_dwOwnerPid, |
| "Attempting to assign ownership of CSynchData %p to " |
| "thread {pid=%#x tid=%#x} while it is currently owned " |
| "by thread {pid=%#x tid=%#x}\n", this, |
| gPID, pthrTarget->GetThreadId(), |
| m_dwOwnerPid, m_pOwnerThread->GetThreadId()); |
| |
| m_lOwnershipCount++; |
| |
| TRACE("Incrementing ownership count for object with " |
| "SynchData %p owned by thread %#x [new count=%d]\n", |
| this, pthrTarget->GetThreadId(), m_lOwnershipCount); |
| } |
| else |
| { |
| // |
| // Acquiring currently not owned object |
| // |
| CPalSynchronizationManager * pSynchManager = |
| CPalSynchronizationManager::GetInstance(); |
| OwnedObjectsListNode * pooln; |
| |
| pooln = pSynchManager->CacheGetOwnedObjsListNode(pthrCurrent); |
| if (NULL == pooln) |
| { |
| ERROR("Out of memory while acquiring mutex ownership"); |
| // In this case we bail out. It will result in no |
| // thread being awakend, which may cause deadlock, |
| // but it is anyway better than corrupting the |
| // ownership list |
| palErr = ERROR_NOT_ENOUGH_MEMORY; |
| goto AOTT_exit; |
| } |
| |
| TRACE("Assigning ownable object with SynchData %p to " |
| "thread %#x\n", |
| this, pthrTarget->GetThreadId()); |
| |
| // Set ownership data |
| SetOwner(pthrTarget); |
| SetOwnershipListNode(pooln); |
| SetOwnershipCount(1); |
| SetAbandoned(false); |
| |
| // Add object to list of owned objs for current thread |
| pooln->pPalObjSynchData = this; |
| AddRef(); |
| pthrTarget->synchronizationInfo.AddObjectToOwnedList(pooln); |
| } |
| |
| AOTT_exit: |
| return palErr; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::WaiterEnqueue |
| |
| Adds the WaitingThreadsListNode passed as argument at the end of the |
| list of WaitingThreadsListNode for the current object, representing |
| the threads waiting on the current object. The target SynchData is |
| assumed to be local to the current process |
| |
| Note: this method must be called while holding the local process |
| synchronization lock. |
| --*/ |
| void CSynchData::WaiterEnqueue(WaitingThreadsListNode * pwtlnNewNode) |
| { |
| VALIDATEOBJECT(this); |
| VALIDATEOBJECT(pwtlnNewNode); |
| |
| _ASSERT_MSG(ProcessLocalObject == GetObjectDomain(), |
| "Trying to enqueue a WaitingThreadsListNode as local " |
| "on a shared object\n"); |
| _ASSERT_MSG(0 == (WTLN_FLAG_OWNER_OBJECT_IS_SHARED & pwtlnNewNode->dwFlags), |
| "Trying to add a WaitingThreadsListNode marked as shared " |
| "as it was a local one\n"); |
| |
| WaitingThreadsListNode * pwtlnCurrLast = m_ptrWTLTail.ptr; |
| |
| pwtlnNewNode->ptrNext.ptr = NULL; |
| if (NULL == pwtlnCurrLast) |
| { |
| _ASSERT_MSG(NULL == m_ptrWTLHead.ptr, |
| "Corrupted waiting list on local CSynchData @ %p\n", |
| this); |
| |
| pwtlnNewNode->ptrPrev.ptr = NULL; |
| m_ptrWTLHead.ptr = pwtlnNewNode; |
| m_ptrWTLTail.ptr = pwtlnNewNode; |
| } |
| else |
| { |
| VALIDATEOBJECT(pwtlnCurrLast); |
| |
| pwtlnNewNode->ptrPrev.ptr = pwtlnCurrLast; |
| pwtlnCurrLast->ptrNext.ptr = pwtlnNewNode; |
| m_ptrWTLTail.ptr = pwtlnNewNode; |
| } |
| |
| m_ulcWaitingThreads += 1; |
| |
| return; |
| } |
| |
| /*++ |
| Method: |
| CSynchData::SharedWaiterEnqueue |
| |
| Adds the WaitingThreadsListNode passed as argument at the end of the |
| list of WaitingThreadsListNode for the current object, representing |
| the threads waiting on the current object. The target SynchData is |
| assumed to be shared among processes |
| |
| Note: this method must be called while holding both local and shared |
| synchronization locks. |
| --*/ |
| void CSynchData::SharedWaiterEnqueue(SharedID shridNewNode) |
| { |
| VALIDATEOBJECT(this); |
| |
| _ASSERT_MSG(SharedObject == GetObjectDomain(), |
| "Trying to enqueue a WaitingThreadsListNode as shared " |
| "on a local object\n"); |
| |
| SharedID shridCurrLast; |
| WaitingThreadsListNode * pwtlnCurrLast, * pwtlnNewNode; |
| |
| shridCurrLast = m_ptrWTLTail.shrid; |
| pwtlnCurrLast = SharedIDToTypePointer(WaitingThreadsListNode, shridCurrLast); |
| pwtlnNewNode = SharedIDToTypePointer(WaitingThreadsListNode, shridNewNode); |
| |
| _ASSERT_MSG(1 == (WTLN_FLAG_OWNER_OBJECT_IS_SHARED & pwtlnNewNode->dwFlags), |
| "Trying to add a WaitingThreadsListNode marked as local " |
| "as it was a shared one\n"); |
| |
| VALIDATEOBJECT(pwtlnNewNode); |
| |
| pwtlnNewNode->ptrNext.shrid = NULLSharedID; |
| if (NULL == pwtlnCurrLast) |
| { |
| _ASSERT_MSG(NULLSharedID == m_ptrWTLHead.shrid, |
| "Corrupted waiting list on shared CSynchData at " |
| "{shrid=%p, p=%p}\n", m_shridThis, this); |
| |
| pwtlnNewNode->ptrPrev.shrid = NULLSharedID; |
| m_ptrWTLHead.shrid = shridNewNode; |
| m_ptrWTLTail.shrid = shridNewNode; |
| } |
| else |
| { |
| VALIDATEOBJECT(pwtlnCurrLast); |
| |
| pwtlnNewNode->ptrPrev.shrid = shridCurrLast; |
| pwtlnCurrLast->ptrNext.shrid = shridNewNode; |
| m_ptrWTLTail.shrid = shridNewNode; |
| } |
| |
| m_ulcWaitingThreads += 1; |
| |
| return; |
| } |
| |
| #ifdef SYNCH_OBJECT_VALIDATION |
| CSynchData::~CSynchData() |
| { |
| ValidateObject(true); |
| InvalidateObject(); |
| } |
| /*++ |
| Method: |
| CSynchData::ValidateObject |
| |
| Makes sure that the signature at the beginning and at the end of the |
| current object are those of a currently alive object (i.e. the object |
| has been constructed and does not appear to have been overwritten) |
| --*/ |
| void CSynchData::ValidateObject(bool fDestructor) |
| { |
| TRACE("Verifying in-use CSynchData @ %p\n", this); |
| _ASSERT_MSG(HeadSignature == m_dwDebugHeadSignature, |
| "CSynchData header signature corruption [p=%p]", this); |
| _ASSERT_MSG(TailSignature == m_dwDebugTailSignature, |
| "CSynchData trailer signature corruption [p=%p]", this); |
| _ASSERT_MSG((fDestructor && 0 == m_lRefCount) || |
| (!fDestructor && 0 < m_lRefCount), |
| "CSynchData %p with NULL reference count\n", this); |
| } |
| /*++ |
| Method: |
| CSynchData::ValidateEmptyObject |
| |
| Makes sure that the signature at the beginning and at the end of the |
| current object are not those of a currently alive object (i.e. the |
| object has not yet been constructed or it has alread been destructed) |
| --*/ |
| void CSynchData::ValidateEmptyObject() |
| { |
| TRACE("Verifying empty CSynchData @ %p\n", this); |
| _ASSERT_MSG(HeadSignature != m_dwDebugHeadSignature, |
| "CSynchData header previously signed [p=%p]", this); |
| _ASSERT_MSG(TailSignature != m_dwDebugTailSignature, |
| "CSynchData trailer previously signed [p=%p]", this); |
| } |
| /*++ |
| Method: |
| CSynchData::InvalidateObject |
| |
| Turns signatures from alive object to destructed object |
| --*/ |
| void CSynchData::InvalidateObject() |
| { |
| TRACE("Invalidating CSynchData @ %p\n", this); |
| m_dwDebugHeadSignature = EmptySignature; |
| m_dwDebugTailSignature = EmptySignature; |
| } |
| #endif // SYNCH_OBJECT_VALIDATION |
| } |
| |
