//

// Copyright (c) Microsoft. All rights reserved.

// Licensed under the MIT license. See LICENSE file in the project root for full license information.

//

/*++

Module Name:

wait.cpp

Abstract:

Implementation of waiting functions as described in

the WIN32 API

Revision History:

--*/

#include "pal/thread.hpp"

#include "pal/synchobjects.hpp"

#include "pal/malloc.hpp"

#include "pal/dbgmsg.h"

SET_DEFAULT_DEBUG_CHANNEL(SYNC);

#define MAXIMUM_STACK_WAITOBJ_ARRAY_SIZE (MAXIMUM_WAIT_OBJECTS / 4)

using namespace CorUnix;

static PalObjectTypeId sg_rgWaitObjectsIds[] =

{

otiAutoResetEvent,

otiManualResetEvent,

otiMutex,

otiSemaphore,

otiProcess,

otiThread

};

static CAllowedObjectTypes sg_aotWaitObject(sg_rgWaitObjectsIds,

sizeof(sg_rgWaitObjectsIds)/sizeof(sg_rgWaitObjectsIds[0]));

/*++

Function:

WaitForSingleObject

See MSDN doc.

--*/

DWORD

PALAPI

WaitForSingleObject(IN HANDLE hHandle,

IN DWORD dwMilliseconds)

{

DWORD dwRet;

PERF_ENTRY(WaitForSingleObject);

ENTRY("WaitForSingleObject(hHandle=%p, dwMilliseconds=%u)\n",

hHandle, dwMilliseconds);

CPalThread * pThread = InternalGetCurrentThread();

dwRet = InternalWaitForMultipleObjectsEx(pThread, 1, &hHandle, FALSE,

dwMilliseconds, FALSE);

LOGEXIT("WaitForSingleObject returns DWORD %u\n", dwRet);

PERF_EXIT(WaitForSingleObject);

return dwRet;

}

/*++

Function:

WaitForSingleObjectEx

See MSDN doc.

--*/

DWORD

PALAPI

WaitForSingleObjectEx(IN HANDLE hHandle,

IN DWORD dwMilliseconds,

IN BOOL bAlertable)

{

DWORD dwRet;

PERF_ENTRY(WaitForSingleObjectEx);

ENTRY("WaitForSingleObjectEx(hHandle=%p, dwMilliseconds=%u, bAlertable=%s)\n",

hHandle, dwMilliseconds, bAlertable ? "TRUE" : "FALSE");

CPalThread * pThread = InternalGetCurrentThread();

dwRet = InternalWaitForMultipleObjectsEx(pThread, 1, &hHandle, FALSE,

dwMilliseconds, bAlertable);

LOGEXIT("WaitForSingleObjectEx returns DWORD %u\n", dwRet);

PERF_EXIT(WaitForSingleObjectEx);

return dwRet;

}

/*++

Function:

WaitForMultipleObjects

See MSDN doc.

--*/

DWORD

PALAPI

WaitForMultipleObjects(IN DWORD nCount,

IN CONST HANDLE *lpHandles,

IN BOOL bWaitAll,

IN DWORD dwMilliseconds)

{

DWORD dwRet;

PERF_ENTRY(WaitForMultipleObjects);

ENTRY("WaitForMultipleObjects(nCount=%d, lpHandles=%p,"

" bWaitAll=%d, dwMilliseconds=%u)\n",

nCount, lpHandles, bWaitAll, dwMilliseconds);

CPalThread * pThread = InternalGetCurrentThread();

dwRet = InternalWaitForMultipleObjectsEx(pThread, nCount, lpHandles,

bWaitAll, dwMilliseconds, FALSE);

LOGEXIT("WaitForMultipleObjects returns DWORD %u\n", dwRet);

PERF_EXIT(WaitForMultipleObjects);

return dwRet;

}

/*++

Function:

WaitForMultipleObjectsEx

See MSDN doc for info about this function.

--*/

DWORD

PALAPI

WaitForMultipleObjectsEx(IN DWORD nCount,

IN CONST HANDLE *lpHandles,

IN BOOL bWaitAll,

IN DWORD dwMilliseconds,

IN BOOL bAlertable)

{

DWORD dwRet;

PERF_ENTRY(WaitForMultipleObjectsEx);

ENTRY("WaitForMultipleObjectsEx(nCount=%d, lpHandles=%p,"

" bWaitAll=%d, dwMilliseconds=%u, bAlertable=d)\n",

nCount, lpHandles, bWaitAll, dwMilliseconds, bAlertable);

CPalThread * pThread = InternalGetCurrentThread();

dwRet = InternalWaitForMultipleObjectsEx(pThread, nCount, lpHandles, bWaitAll,

dwMilliseconds, bAlertable);

LOGEXIT("WaitForMultipleObjectsEx returns DWORD %u\n", dwRet);

PERF_EXIT(WaitForMultipleObjectsEx);

return dwRet;

}

/*++

Function:

Sleep

See MSDN doc.

--*/

VOID

PALAPI

Sleep(IN DWORD dwMilliseconds)

{

PERF_ENTRY(Sleep);

ENTRY("Sleep(dwMilliseconds=%u)\n", dwMilliseconds);

CPalThread * pThread = InternalGetCurrentThread();

PAL_ERROR palErr = InternalSleepEx(pThread, dwMilliseconds, FALSE);

if (NO_ERROR != palErr)

{

ERROR("Sleep(dwMilliseconds=%u) failed [error=%u]\n",

dwMilliseconds, palErr);

pThread->SetLastError(palErr);

}

LOGEXIT("Sleep returns VOID\n");

PERF_EXIT(Sleep);

}

/*++

Function:

SleepEx

See MSDN doc.

--*/

DWORD

PALAPI

SleepEx(IN DWORD dwMilliseconds,

IN BOOL bAlertable)

{

DWORD dwRet;

PERF_ENTRY(SleepEx);

ENTRY("SleepEx(dwMilliseconds=%u, bAlertable=%d)\n", dwMilliseconds, bAlertable);

CPalThread * pThread = InternalGetCurrentThread();

dwRet = InternalSleepEx(pThread, dwMilliseconds, bAlertable);

LOGEXIT("SleepEx returns DWORD %u\n", dwRet);

PERF_EXIT(SleepEx);

return dwRet;

}

/*++

Function:

QueueUserAPC

See MSDN doc.

--*/

DWORD

PALAPI

QueueUserAPC(

PAPCFUNC pfnAPC,

HANDLE hThread,

ULONG_PTR dwData)

{

CPalThread * pCurrentThread = NULL;

CPalThread * pTargetThread = NULL;

IPalObject * pTargetThreadObject = NULL;

PAL_ERROR palErr;

DWORD dwRet;

PERF_ENTRY(QueueUserAPC);

ENTRY("QueueUserAPC(pfnAPC=%p, hThread=%p, dwData=%#x)\n",

pfnAPC, hThread, dwData);

/* NOTE: Windows does not check the validity of pfnAPC, even if it is

NULL. It just does an access violation later on when the APC call

is attempted */

pCurrentThread = InternalGetCurrentThread();

palErr = InternalGetThreadDataFromHandle(

pCurrentThread,

hThread,

0, // THREAD_SET_CONTEXT

&pTargetThread,

&pTargetThreadObject

);

if (NO_ERROR != palErr)

{

ERROR("Unable to obtain thread data for handle %p (error %x)!\n",

hThread, palErr);

goto QueueUserAPC_exit;

}

palErr = g_pSynchronizationManager->QueueUserAPC(pCurrentThread, pTargetThread,

pfnAPC, dwData);

QueueUserAPC_exit:

if (pTargetThreadObject)

{

pTargetThreadObject->ReleaseReference(pCurrentThread);

}

dwRet = (NO_ERROR == palErr) ? 1 : 0;

LOGEXIT("QueueUserAPC returns DWORD %d\n", dwRet);

PERF_EXIT(QueueUserAPC);

return dwRet;

}

DWORD CorUnix::InternalWaitForMultipleObjectsEx(

CPalThread * pThread,

DWORD nCount,

CONST HANDLE *lpHandles,

BOOL bWaitAll,

DWORD dwMilliseconds,

BOOL bAlertable)

{

DWORD dwRet = WAIT_FAILED;

PAL_ERROR palErr = NO_ERROR;

int i, iSignaledObjCount, iSignaledObjIndex = -1;

bool fWAll = (bool)bWaitAll, fNeedToBlock = false;

bool fAbandoned = false;

WaitType wtWaitType;

IPalObject * pIPalObjStackArray[MAXIMUM_STACK_WAITOBJ_ARRAY_SIZE] = { NULL };

ISynchWaitController * pISyncStackArray[MAXIMUM_STACK_WAITOBJ_ARRAY_SIZE] = { NULL };

IPalObject ** ppIPalObjs = pIPalObjStackArray;

ISynchWaitController ** ppISyncWaitCtrlrs = pISyncStackArray;

if ((nCount == 0) || (nCount > MAXIMUM_WAIT_OBJECTS))

{

ppIPalObjs = NULL; // make delete at the end safe

ppISyncWaitCtrlrs = NULL; // make delete at the end safe

ERROR("Invalid object count=%d [range: 1 to %d]\n",

nCount, MAXIMUM_WAIT_OBJECTS)

pThread->SetLastError(ERROR_INVALID_PARAMETER);

goto WFMOExIntExit;

}

else if (nCount == 1)

{

fWAll = false; // makes no difference when nCount is 1

wtWaitType = SingleObject;

}

else

{

wtWaitType = fWAll ? MultipleObjectsWaitAll : MultipleObjectsWaitOne;

if (nCount > MAXIMUM_STACK_WAITOBJ_ARRAY_SIZE)

{

ppIPalObjs = InternalNewArray<IPalObject*>(nCount);

ppISyncWaitCtrlrs = InternalNewArray<ISynchWaitController*>(nCount);

if ((NULL == ppIPalObjs) || (NULL == ppISyncWaitCtrlrs))

{

ERROR("Out of memory allocating internal structures\n");

pThread->SetLastError(ERROR_NOT_ENOUGH_MEMORY);

goto WFMOExIntExit;

}

}

}

palErr = g_pObjectManager->ReferenceMultipleObjectsByHandleArray(pThread,

(VOID **)lpHandles,

nCount,

&sg_aotWaitObject,

SYNCHRONIZE,

ppIPalObjs);

if (NO_ERROR != palErr)

{

ERROR("Unable to obtain object for some or all of the handles [error=%u]\n",

palErr);

if (palErr == ERROR_INVALID_HANDLE)

pThread->SetLastError(ERROR_INVALID_HANDLE);

else

pThread->SetLastError(ERROR_INTERNAL_ERROR);

goto WFMOExIntExit;

}

if (fWAll)

{

// For a wait-all operation, check for duplicate wait objects in the array. This just uses a brute-force O(n^2)

// algorithm, but since MAXIMUM_WAIT_OBJECTS is small, the worst case is not so bad, and the average case would involve

// significantly fewer items.

for (DWORD i = 0; i < nCount - 1; ++i)

{

IPalObject *const objectToCheck = ppIPalObjs[i];

for (DWORD j = i + 1; j < nCount; ++j)

{

if (ppIPalObjs[j] == objectToCheck)

{

ERROR("Duplicate handle provided for a wait-all operation [error=%u]\n", ERROR_INVALID_PARAMETER);

pThread->SetLastError(ERROR_INVALID_PARAMETER);

goto WFMOExIntCleanup;

}

}

}

}

palErr = g_pSynchronizationManager->GetSynchWaitControllersForObjects(

pThread, ppIPalObjs, nCount, ppISyncWaitCtrlrs);

if (NO_ERROR != palErr)

{

ERROR("Unable to obtain ISynchWaitController interface for some or all "

"of the objects [error=%u]\n", palErr);

pThread->SetLastError(ERROR_INTERNAL_ERROR);

goto WFMOExIntCleanup;

}

if (bAlertable)

{

// First check for pending APC. We need to do that while holding the global

// synch lock implicitely grabbed by GetSynchWaitControllersForObjects

if (g_pSynchronizationManager->AreAPCsPending(pThread))

{

// If there is any pending APC we need to release the

// implicit global synch lock before calling into it

for (i = 0; (i < (int)nCount) && (NULL != ppISyncWaitCtrlrs[i]); i++)

{

ppISyncWaitCtrlrs[i]->ReleaseController();

ppISyncWaitCtrlrs[i] = NULL;

}

palErr = g_pSynchronizationManager->DispatchPendingAPCs(pThread);

if (NO_ERROR == palErr)

{

dwRet = WAIT_IO_COMPLETION;

}

else

{

ASSERT("Awakened for APC, but no APC is pending\n");

pThread->SetLastError(ERROR_INTERNAL_ERROR);

dwRet = WAIT_FAILED;

}

goto WFMOExIntCleanup;

}

}

iSignaledObjCount = 0;

iSignaledObjIndex = -1;

for (i=0;i<(int)nCount;i++)

{

bool fValue;

palErr = ppISyncWaitCtrlrs[i]->CanThreadWaitWithoutBlocking(&fValue, &fAbandoned);

if (NO_ERROR != palErr)

{

ERROR("ISynchWaitController::CanThreadWaitWithoutBlocking() failed for "

"%d-th object [handle=%p error=%u]\n", i, lpHandles[i], palErr);

pThread->SetLastError(ERROR_INTERNAL_ERROR);

goto WFMOExIntReleaseControllers;

}

if (fValue)

{

iSignaledObjCount++;

iSignaledObjIndex = i;

if (!fWAll)

break;

}

}

fNeedToBlock = (iSignaledObjCount == 0) || (fWAll && (iSignaledObjCount < (int)nCount));

if (!fNeedToBlock)

{

// At least one object signaled, or bWaitAll==TRUE and all object signaled.

// No need to wait, let's unsignal the object(s) and return without blocking

int iStartIdx, iEndIdx;

if (fWAll)

{

iStartIdx = 0;

iEndIdx = nCount;

}

else

{

iStartIdx = iSignaledObjIndex;

iEndIdx = iStartIdx + 1;

}

// Unsignal objects

if( iStartIdx < 0 )

{

ERROR("Buffer underflow due to iStartIdx < 0");

pThread->SetLastError(ERROR_INTERNAL_ERROR);

dwRet = WAIT_FAILED;

goto WFMOExIntCleanup;

}

for (i = iStartIdx; i < iEndIdx; i++)

{

palErr = ppISyncWaitCtrlrs[i]->ReleaseWaitingThreadWithoutBlocking();

if (NO_ERROR != palErr)

{

ERROR("ReleaseWaitingThreadWithoutBlocking() failed for %d-th "

"object [handle=%p error=%u]\n",

i, lpHandles[i], palErr);

pThread->SetLastError(palErr);

goto WFMOExIntReleaseControllers;

}

}

dwRet = (fAbandoned ? WAIT_ABANDONED_0 : WAIT_OBJECT_0);

}

else if (0 == dwMilliseconds)

{

// Not enough objects signaled, but timeout is zero: no actual wait

dwRet = WAIT_TIMEOUT;

fNeedToBlock = false;

}

else

{

// Register the thread for waiting on all objects

for (i=0;i<(int)nCount;i++)

{

palErr = ppISyncWaitCtrlrs[i]->RegisterWaitingThread(

wtWaitType,

i,

(TRUE == bAlertable));

if (NO_ERROR != palErr)

{

ERROR("RegisterWaitingThread() failed for %d-th object "

"[handle=%p error=%u]\n", i, lpHandles[i], palErr);

pThread->SetLastError(palErr);

goto WFMOExIntReleaseControllers;

}

}

}

WFMOExIntReleaseControllers:

// Release all controllers before going to sleep

for (i = 0; i < (int)nCount; i++)

{

ppISyncWaitCtrlrs[i]->ReleaseController();

ppISyncWaitCtrlrs[i] = NULL;

}

if (NO_ERROR != palErr)

goto WFMOExIntCleanup;

if (fNeedToBlock)

{

ThreadWakeupReason twrWakeupReason;

//

// Going to sleep

//

palErr = g_pSynchronizationManager->BlockThread(pThread,

dwMilliseconds,

(TRUE == bAlertable),

false,

&twrWakeupReason,

(DWORD *)&iSignaledObjIndex);

//

// Awakened

//

if (NO_ERROR != palErr)

{

ERROR("IPalSynchronizationManager::BlockThread failed for thread "

"pThread=%p [error=%u]\n", pThread, palErr);

pThread->SetLastError(palErr);

goto WFMOExIntCleanup;

}

switch (twrWakeupReason)

{

case WaitSucceeded:

dwRet = WAIT_OBJECT_0; // offset added later

break;

case MutexAbondoned:

dwRet = WAIT_ABANDONED_0; // offset added later

break;

case WaitTimeout:

dwRet = WAIT_TIMEOUT;

break;

case Alerted:

_ASSERT_MSG(bAlertable,

"Awakened for APC from a non-alertable wait\n");

dwRet = WAIT_IO_COMPLETION;

palErr = g_pSynchronizationManager->DispatchPendingAPCs(pThread);

_ASSERT_MSG(NO_ERROR == palErr,

"Awakened for APC, but no APC is pending\n");

break;

case WaitFailed:

default:

ERROR("Thread %p awakened with some failure\n", pThread);

dwRet = WAIT_FAILED;

break;

}

}

if (!fWAll && ((WAIT_OBJECT_0 == dwRet) || (WAIT_ABANDONED_0 == dwRet)))

{

_ASSERT_MSG(0 <= iSignaledObjIndex,

"Failed to identify signaled/abandoned object\n");

_ASSERT_MSG(iSignaledObjIndex >= 0 && nCount > static_cast<DWORD>(iSignaledObjIndex),

"SignaledObjIndex object out of range "

"[index=%d obj_count=%u\n",

iSignaledObjCount, nCount);

if (iSignaledObjIndex < 0)

{

pThread->SetLastError(ERROR_INTERNAL_ERROR);

dwRet = WAIT_FAILED;

goto WFMOExIntCleanup;

}

dwRet += iSignaledObjIndex;

}

WFMOExIntCleanup:

for (i = 0; i < (int)nCount; i++)

{

ppIPalObjs[i]->ReleaseReference(pThread);

ppIPalObjs[i] = NULL;

}

WFMOExIntExit:

if (nCount > MAXIMUM_STACK_WAITOBJ_ARRAY_SIZE)

{

InternalDeleteArray(ppIPalObjs);

InternalDeleteArray(ppISyncWaitCtrlrs);

}

return dwRet;

}

PAL_ERROR CorUnix::InternalSleepEx (

CPalThread * pThread,

DWORD dwMilliseconds,

BOOL bAlertable)

{

PAL_ERROR palErr = NO_ERROR;

DWORD dwRet = WAIT_FAILED;

int iSignaledObjIndex;

TRACE("Sleeping %u ms [bAlertable=%d]", dwMilliseconds, (int)bAlertable);

if (bAlertable)

{

// In this case do not use AreAPCsPending. In fact, since we are

// not holding the synch lock(s) an APC posting may race with

// AreAPCsPending.

palErr = g_pSynchronizationManager->DispatchPendingAPCs(pThread);

if (NO_ERROR == palErr)

{

dwRet = WAIT_IO_COMPLETION;

goto InternalSleepExExit;

}

else if (ERROR_NOT_FOUND == palErr)

{

// No APC was pending, just continue

palErr = NO_ERROR;

}

}

if (dwMilliseconds > 0)

{

ThreadWakeupReason twrWakeupReason;

palErr = g_pSynchronizationManager->BlockThread(pThread,

dwMilliseconds,

(TRUE == bAlertable),

true,

&twrWakeupReason,

(DWORD *)&iSignaledObjIndex);

if (NO_ERROR != palErr)

{

ERROR("IPalSynchronizationManager::BlockThread failed for thread "

"pThread=%p [error=%u]\n", pThread, palErr);

goto InternalSleepExExit;

}

switch (twrWakeupReason)

{

case WaitSucceeded:

case WaitTimeout:

dwRet = 0;

break;

case Alerted:

_ASSERT_MSG(bAlertable,

"Awakened for APC from a non-alertable wait\n");

dwRet = WAIT_IO_COMPLETION;

palErr = g_pSynchronizationManager->DispatchPendingAPCs(pThread);

_ASSERT_MSG(NO_ERROR == palErr,

"Awakened for APC, but no APC is pending\n");

break;

case MutexAbondoned:

ASSERT("Thread %p awakened with reason=MutexAbondoned from a "

"SleepEx\n", pThread);

palErr = ERROR_INTERNAL_ERROR;

break;

case WaitFailed:

default:

ERROR("Thread %p awakened with some failure\n", pThread);

palErr = ERROR_INTERNAL_ERROR;

break;

}

}

else

{

dwRet = 0;

}

TRACE("Done sleeping %u ms [bAlertable=%d]", dwMilliseconds, (int)bAlertable);

InternalSleepExExit:

return dwRet;

}