WindowsXP-SP1/shell/shlwapi/tpstimer.cpp

966 lines
23 KiB
C++
Raw Normal View History

2001-01-01 00:00:00 +01:00
/*++
Copyright (c) 1998 Microsoft Corporation
Module Name:
tpstimer.cpp
Abstract:
Contains Win32 thread pool services timer functions
Contents:
TerminateTimers
SHCreateTimerQueue
(IECreateTimerQueue)
SHDeleteTimerQueue
(IEDeleteTimerQueue)
SHSetTimerQueueTimer
(IESetTimerQueueTimer)
(NTSetTimerQueueTimer)
SHChangeTimerQueueTimer
(IEChangeTimerQueueTimer)
SHCancelTimerQueueTimer
(IECancelTimerQueueTimer)
(NTCancelTimerQueueTimer)
(InitializeTimerThread)
(TimerCleanup)
(CreateDefaultTimerQueue)
(DeleteDefaultTimerQueue)
(CleanupDefaultTimerQueue)
(TimerThread)
(DeleteTimerQueue)
(AddTimer)
(ChangeTimer)
(CancelTimer)
Author:
Richard L Firth (rfirth) 10-Feb-1998
Environment:
Win32 user-mode
Notes:
Code reworked in C++ from NT-specific C code written by Gurdeep Singh Pall
(gurdeep)
Revision History:
10-Feb-1998 rfirth
Created
--*/
#include "priv.h"
#include "threads.h"
#include "tpsclass.h"
#include "tpstimer.h"
//
// private prototypes
//
typedef HANDLE (WINAPI * t_CreateTimerQueue)(VOID);
typedef BOOL (WINAPI * t_DeleteTimerQueue)(HANDLE);
typedef HANDLE (WINAPI * t_SetTimerQueueTimer)(HANDLE,
WAITORTIMERCALLBACKFUNC,
LPVOID,
DWORD,
DWORD,
LPCSTR,
DWORD
);
typedef BOOL (WINAPI * t_ChangeTimerQueueTimer)(HANDLE, HANDLE, DWORD, DWORD);
typedef BOOL (WINAPI * t_CancelTimerQueueTimer)(HANDLE, HANDLE);
// These are KERNEL32 functions that do not match our SHLWAPI APIs
typedef BOOL (WINAPI * t_CreateTimerQueueTimer)(PHANDLE,
HANDLE,
WAITORTIMERCALLBACKFUNC,
LPVOID,
DWORD,
DWORD,
ULONG
);
typedef BOOL (WINAPI * t_DeleteTimerQueueTimer)(HANDLE, HANDLE, HANDLE);
PRIVATE
DWORD
InitializeTimerThread(
VOID
);
PRIVATE
VOID
TimerCleanup(
VOID
);
PRIVATE
HANDLE
CreateDefaultTimerQueue(
VOID
);
PRIVATE
VOID
DeleteDefaultTimerQueue(
VOID
);
PRIVATE
VOID
CleanupDefaultTimerQueue(
VOID
);
PRIVATE
VOID
TimerThread(
VOID
);
PRIVATE
VOID
DeleteTimerQueue(
IN CTimerQueueDeleteRequest * pRequest
);
PRIVATE
VOID
AddTimer(
IN CTimerAddRequest * pRequest
);
PRIVATE
VOID
ChangeTimer(
IN CTimerChangeRequest * pRequest
);
PRIVATE
VOID
CancelTimer(
IN CTimerCancelRequest * pRequest
);
//
// global data
//
CTimerQueueList g_TimerQueueList;
HANDLE g_hDefaultTimerQueue = NULL;
HANDLE g_hTimerThread = NULL;
DWORD g_dwTimerId = 0;
LONG g_UID = 0;
BOOL g_bTimerInit = FALSE;
BOOL g_bTimerInitDone = FALSE;
BOOL g_bDeferredTimerTermination = FALSE;
//
// Forward-declared data.
//
extern t_CreateTimerQueue _I_CreateTimerQueue;
extern t_DeleteTimerQueue _I_DeleteTimerQueue;
extern t_SetTimerQueueTimer _I_SetTimerQueueTimer;
extern t_ChangeTimerQueueTimer _I_ChangeTimerQueueTimer;
extern t_CancelTimerQueueTimer _I_CancelTimerQueueTimer;
extern t_CreateTimerQueueTimer _I_CreateTimerQueueTimer;
extern t_DeleteTimerQueueTimer _I_DeleteTimerQueueTimer;
//
// Wrappers for NT5 because the Shlwapi version differs slightly from the
// NT version.
//
LWSTDAPI_(HANDLE)
NTSetTimerQueueTimer(
IN HANDLE hQueue,
IN WAITORTIMERCALLBACKFUNC pfnCallback,
IN LPVOID pContext,
IN DWORD dwDueTime,
IN DWORD dwPeriod,
IN LPCSTR lpszLibrary OPTIONAL,
IN DWORD dwFlags
)
{
//
// Translate the flags from TPS flags to WT flags.
//
DWORD dwWTFlags = 0;
if (dwFlags & TPS_EXECUTEIO) dwWTFlags |= WT_EXECUTEINIOTHREAD;
if (dwFlags & TPS_LONGEXECTIME) dwWTFlags |= WT_EXECUTELONGFUNCTION;
HANDLE hTimer;
if (_I_CreateTimerQueueTimer(&hTimer, hQueue, pfnCallback, pContext, dwDueTime, dwPeriod, dwWTFlags))
{
return hTimer;
}
return NULL;
}
LWSTDAPI_(BOOL)
NTCancelTimerQueueTimer(
IN HANDLE hQueue,
IN HANDLE hTimer
)
{
return _I_DeleteTimerQueueTimer(hQueue, hTimer, INVALID_HANDLE_VALUE);
}
STDAPI_(void) InitTimerQueue()
{
if (IsOS(OS_WHISTLERORGREATER))
{
HMODULE hKernel32 = GetModuleHandle("KERNEL32.DLL");
if (hKernel32)
{
t_CreateTimerQueue NTCreateTimerQueue;
t_DeleteTimerQueue NTDeleteTimerQueue;
t_CreateTimerQueueTimer NTCreateTimerQueueTimer;
t_ChangeTimerQueueTimer NTChangeTimerQueueTimer;
t_DeleteTimerQueueTimer NTDeleteTimerQueueTimer;
#define GetKernelProc(fn) \
((NT##fn = (t_##fn)GetProcAddress(hKernel32, #fn)) != NULL)
if (GetKernelProc(CreateTimerQueue) &&
GetKernelProc(DeleteTimerQueue) &&
GetKernelProc(CreateTimerQueueTimer) &&
GetKernelProc(ChangeTimerQueueTimer) &&
GetKernelProc(DeleteTimerQueueTimer))
{
#define SwitchToNTVersion(fn) (_I_##fn = NT##fn)
// Redirect the SHLWAPI APIs to the NT versions
// (They either point directly to the KERNEL API
// or to our stub functions.)
SwitchToNTVersion(CreateTimerQueue);
SwitchToNTVersion(DeleteTimerQueue);
SwitchToNTVersion(ChangeTimerQueueTimer);
SwitchToNTVersion(SetTimerQueueTimer);
SwitchToNTVersion(CancelTimerQueueTimer);
// Save these values so our stub functions can
// call the KERNEL API after they do their translation.
SwitchToNTVersion(CreateTimerQueueTimer);
SwitchToNTVersion(DeleteTimerQueueTimer);
}
#undef GetKernelProc
#undef SwitchToNTVersion
}
}
}
//
// functions
//
VOID
TerminateTimers(
VOID
)
/*++
Routine Description:
Terminate timer thread and global variables
Arguments:
None.
Return Value:
None.
--*/
{
if (g_bTimerInitDone) {
DWORD threadId = GetCurrentThreadId();
if ((g_hTimerThread != NULL) && (threadId != g_dwTimerId)) {
QueueNullFunc(g_hTimerThread);
DWORD ticks = GetTickCount();
while (g_hTimerThread != NULL) {
SleepEx(0, TRUE);
if (GetTickCount() - ticks > 10000) {
CloseHandle(g_hTimerThread);
g_hTimerThread = NULL;
break;
}
}
}
if (g_dwTimerId == threadId) {
g_bDeferredTimerTermination = TRUE;
} else {
TimerCleanup();
}
}
}
LWSTDAPI_(HANDLE)
SHCreateTimerQueue(
VOID
)
{
return _I_CreateTimerQueue();
}
LWSTDAPI_(HANDLE)
IECreateTimerQueue(
VOID
)
/*++
Routine Description:
Creates a timer queue
Arguments:
None.
Return Value:
HANDLE
Success - non-NULL pointer to CTimerQueue object
Failure - NULL. GetLastError() for more info
--*/
{
InterlockedIncrement((LPLONG)&g_ActiveRequests);
HANDLE hResult = NULL;
DWORD error = ERROR_SUCCESS;
if (!g_bTpsTerminating) {
if (g_hTimerThread == NULL) {
error = InitializeTimerThread();
}
if (error == ERROR_SUCCESS) {
//
// timer queue handle is just pointer to timer queue object
//
hResult = (HANDLE) new CTimerQueue(&g_TimerQueueList);
} else {
SetLastError(error);
}
} else {
SetLastError(ERROR_SHUTDOWN_IN_PROGRESS); // error code? looks valid -justmann
}
InterlockedDecrement((LPLONG)&g_ActiveRequests);
return hResult;
}
LWSTDAPI_(BOOL)
SHDeleteTimerQueue(
IN HANDLE hQueue
)
{
return _I_DeleteTimerQueue(hQueue);
}
LWSTDAPI_(BOOL)
IEDeleteTimerQueue(
IN HANDLE hQueue
)
/*++
Routine Description:
Deletes the specified timer queue
Arguments:
hQueue - handle of queue to delete; NULL for default timer queue
Return Value:
BOOL
Success - TRUE
Failure - FALSE. Call GetLastError() for more info
--*/
{
InterlockedIncrement((LPLONG)&g_ActiveRequests);
BOOL bSuccess = FALSE;
if (!g_bTpsTerminating) {
if (hQueue == NULL) {
hQueue = g_hDefaultTimerQueue;
}
if ((hQueue != NULL) && (g_hTimerThread != NULL)) {
CTimerQueueDeleteRequest request(hQueue);
if (QueueUserAPC((PAPCFUNC)DeleteTimerQueue,
g_hTimerThread,
(ULONG_PTR)&request)) {
request.WaitForCompletion();
bSuccess = request.SetThreadStatus();
} else {
#if DBG
DWORD error = GetLastError();
ASSERT(error == ERROR_SUCCESS);
#endif
}
} else {
SetLastError(ERROR_INVALID_PARAMETER); // correct error code? looks valid -justmann
}
} else {
SetLastError(ERROR_SHUTDOWN_IN_PROGRESS); // error code? looks valid -justmann
}
InterlockedDecrement((LPLONG)&g_ActiveRequests);
return bSuccess;
}
LWSTDAPI_(HANDLE)
SHSetTimerQueueTimer(
IN HANDLE hQueue,
IN WAITORTIMERCALLBACKFUNC pfnCallback,
IN LPVOID pContext,
IN DWORD dwDueTime,
IN DWORD dwPeriod,
IN LPCSTR lpszLibrary OPTIONAL,
IN DWORD dwFlags
)
{
return _I_SetTimerQueueTimer(hQueue, pfnCallback, pContext, dwDueTime, dwPeriod, lpszLibrary, dwFlags);
}
LWSTDAPI_(HANDLE)
IESetTimerQueueTimer(
IN HANDLE hQueue,
IN WAITORTIMERCALLBACKFUNC pfnCallback,
IN LPVOID pContext,
IN DWORD dwDueTime,
IN DWORD dwPeriod,
IN LPCSTR lpszLibrary OPTIONAL,
IN DWORD dwFlags
)
/*++
Routine Description:
Add a timer to a queue
Arguments:
hQueue - handle of timer queue; NULL for default queue
pfnCallback - function to call when timer triggers
pContext - parameter to pfnCallback
dwDueTime - initial firing time in milliseconds from now
dwPeriod - repeating period. 0 for one-shot
lpszLibrary - if specified, name of library (DLL) to reference
dwFlags - flags controlling function:
TPS_EXECUTEIO - Execute callback in I/O thread
Return Value:
HANDLE
Success - non-NULL handle
Failure - NULL. Call GetLastError() for more info
--*/
{
InterlockedIncrement((LPLONG)&g_ActiveRequests);
HANDLE hTimer = NULL;
if (!g_bTpsTerminating) {
DWORD error = ERROR_SUCCESS;
if (g_hTimerThread == NULL) {
error = InitializeTimerThread();
}
ASSERT(g_hTimerThread != NULL);
if (error == ERROR_SUCCESS) {
if (hQueue == NULL) {
hQueue = CreateDefaultTimerQueue();
}
if (hQueue != NULL) {
CTimerAddRequest * pRequest = new CTimerAddRequest(hQueue,
pfnCallback,
pContext,
dwDueTime,
dwPeriod,
dwFlags
);
if (pRequest != NULL) {
hTimer = pRequest->GetHandle();
if (QueueUserAPC((PAPCFUNC)AddTimer,
g_hTimerThread,
(ULONG_PTR)pRequest
)) {
} else {
#if DBG
error = GetLastError();
ASSERT(GetLastError() != ERROR_SUCCESS);
#endif
delete pRequest;
hTimer = NULL;
#if DBG
SetLastError(error);
#endif
}
}
}
} else {
SetLastError(error);
}
} else {
SetLastError(ERROR_SHUTDOWN_IN_PROGRESS); // error code? looks valid -justmann
}
InterlockedDecrement((LPLONG)&g_ActiveRequests);
return hTimer;
}
LWSTDAPI_(BOOL)
SHChangeTimerQueueTimer(
IN HANDLE hQueue,
IN HANDLE hTimer,
IN DWORD dwDueTime,
IN DWORD dwPeriod
)
{
return _I_ChangeTimerQueueTimer(hQueue, hTimer, dwDueTime, dwPeriod);
}
LWSTDAPI_(BOOL)
IEChangeTimerQueueTimer(
IN HANDLE hQueue,
IN HANDLE hTimer,
IN DWORD dwDueTime,
IN DWORD dwPeriod
)
/*++
Routine Description:
Change the due time or periodicity of a timer
Arguments:
hQueue - handle of queue on which timer resides. NULL for default queue
hTimer - handle of timer to change
dwDueTime - new due time
dwPeriod - new period
Return Value:
BOOL
Success - TRUE
Failure - FALSE. Call GetLastError() for more info
--*/
{
InterlockedIncrement((LPLONG)&g_ActiveRequests);
BOOL bSuccess = FALSE;
DWORD error = ERROR_SHUTDOWN_IN_PROGRESS; // error code? looks valid -justmann
if (!g_bTpsTerminating) {
error = ERROR_OBJECT_NOT_FOUND;
if (g_hTimerThread != NULL) {
if (hQueue == NULL) {
hQueue = g_hDefaultTimerQueue;
}
if (hQueue != NULL) {
CTimerChangeRequest request(hQueue, hTimer, dwDueTime, dwPeriod);
error = ERROR_SUCCESS; // both paths call SetLastError() if reqd
if (QueueUserAPC((PAPCFUNC)ChangeTimer,
g_hTimerThread,
(ULONG_PTR)&request
)) {
request.WaitForCompletion();
bSuccess = request.SetThreadStatus();
} else {
#if DBG
ASSERT(GetLastError() == ERROR_SUCCESS);
#endif
}
}
}
}
InterlockedDecrement((LPLONG)&g_ActiveRequests);
if (error != ERROR_SUCCESS) {
SetLastError(error);
}
return bSuccess;
}
LWSTDAPI_(BOOL)
SHCancelTimerQueueTimer(
IN HANDLE hQueue,
IN HANDLE hTimer
)
{
return _I_CancelTimerQueueTimer(hQueue, hTimer);
}
LWSTDAPI_(BOOL)
IECancelTimerQueueTimer(
IN HANDLE hQueue,
IN HANDLE hTimer
)
/*++
Routine Description:
Cancels a timer
Arguments:
hQueue - handle to queue on which timer resides
hTimer - handle of timer to cancel
Return Value:
BOOL
Success - TRUE
Failure - FALSE. Call GetLastError() for more info
--*/
{
InterlockedIncrement((LPLONG)&g_ActiveRequests);
BOOL bSuccess = FALSE;
if (!g_bTpsTerminating) {
if (hQueue == NULL) {
hQueue = g_hDefaultTimerQueue;
}
if ((hQueue != NULL) && (g_hTimerThread != NULL)) {
CTimerCancelRequest request(hQueue, hTimer);
if (QueueUserAPC((PAPCFUNC)CancelTimer,
g_hTimerThread,
(ULONG_PTR)&request
)) {
request.WaitForCompletion();
bSuccess = request.SetThreadStatus();
} else {
#if DBG
DWORD error = GetLastError();
ASSERT(error == ERROR_SUCCESS);
#endif
}
} else {
SetLastError(ERROR_INVALID_HANDLE);
}
} else {
SetLastError(ERROR_SHUTDOWN_IN_PROGRESS); // error code? looks valid -justmann
}
InterlockedDecrement((LPLONG)&g_ActiveRequests);
return bSuccess;
}
//
// private functions
//
PRIVATE
DWORD
InitializeTimerThread(
VOID
)
{
DWORD error = ERROR_SUCCESS;
while (!g_bTimerInitDone) {
if (!InterlockedExchange((LPLONG)&g_bTimerInit, TRUE)) {
//
// N.B. if CTimerQueueList::Init() does anything more than just
// initialize lists then add a Deinit()
//
g_TimerQueueList.Init();
ASSERT(g_hTimerThread == NULL);
error = StartThread((LPTHREAD_START_ROUTINE)TimerThread,
&g_hTimerThread,
FALSE
);
if (error == ERROR_SUCCESS) {
g_bTimerInitDone = TRUE;
} else {
InterlockedExchange((LPLONG)&g_bTimerInit, FALSE);
}
break;
} else {
SleepEx(0, FALSE);
}
}
return error;
}
PRIVATE
VOID
TimerCleanup(
VOID
)
{
while (!g_TimerQueueList.QueueListHead()->IsEmpty()) {
CTimerQueueDeleteRequest request((CTimerQueue *)
g_TimerQueueList.QueueListHead()->Next());
DeleteTimerQueue(&request);
}
DeleteDefaultTimerQueue();
g_UID = 0;
g_bTimerInit = FALSE;
g_bTimerInitDone = FALSE;
}
BOOL bDefaultQueueInit = FALSE;
BOOL bDefaultQueueInitDone = FALSE;
BOOL bDefaultQueueInitFailed = FALSE;
PRIVATE
HANDLE
CreateDefaultTimerQueue(
VOID
)
{
do {
if ((g_hDefaultTimerQueue != NULL) || bDefaultQueueInitFailed) {
return g_hDefaultTimerQueue;
}
if (!InterlockedExchange((LPLONG)&bDefaultQueueInit, TRUE)) {
InterlockedExchange((LPLONG)&bDefaultQueueInitDone, FALSE);
g_hDefaultTimerQueue = SHCreateTimerQueue();
if (g_hDefaultTimerQueue == NULL) {
bDefaultQueueInitFailed = TRUE;
InterlockedExchange((LPLONG)&bDefaultQueueInit, FALSE);
}
InterlockedExchange((LPLONG)&bDefaultQueueInitDone, TRUE);
} else {
do {
SleepEx(0, FALSE);
} while (!bDefaultQueueInitDone);
}
} while (TRUE);
}
PRIVATE
VOID
DeleteDefaultTimerQueue(
VOID
)
{
if (g_hDefaultTimerQueue != NULL) {
CTimerQueueDeleteRequest request((CTimerQueue *)g_hDefaultTimerQueue);
DeleteTimerQueue(&request);
g_hDefaultTimerQueue = NULL;
}
CleanupDefaultTimerQueue();
}
PRIVATE
VOID
CleanupDefaultTimerQueue(
VOID
)
{
g_hDefaultTimerQueue = NULL;
bDefaultQueueInit = FALSE;
bDefaultQueueInitDone = FALSE;
bDefaultQueueInitFailed = FALSE;
}
PRIVATE
VOID
TimerThread(
VOID
)
{
g_dwTimerId = GetCurrentThreadId();
HMODULE hDll = LoadLibrary(g_cszShlwapi);
ASSERT(hDll != NULL);
ASSERT(g_TpsTls != 0xFFFFFFFF);
TlsSetValue(g_TpsTls, (LPVOID)TPS_TIMER_SIGNATURE);
while (!g_bTpsTerminating || (g_ActiveRequests != 0)) {
if (g_TimerQueueList.Wait()) {
if (g_bTpsTerminating && (g_ActiveRequests == 0)) {
break;
}
g_TimerQueueList.ProcessCompletions();
}
}
ASSERT(g_hTimerThread != NULL);
CloseHandle(g_hTimerThread);
g_hTimerThread = NULL;
if (g_dwTimerId == g_dwTerminationThreadId) {
TimerCleanup();
g_bTpsTerminating = FALSE;
g_dwTerminationThreadId = 0;
g_bDeferredTimerTermination = FALSE;
}
g_dwTimerId = 0;
FreeLibraryAndExitThread(hDll, ERROR_SUCCESS);
}
PRIVATE
VOID
DeleteTimerQueue(
IN CTimerQueueDeleteRequest * pRequest
)
{
CTimerQueue * pQueue = (CTimerQueue *)pRequest->GetQueue();
DWORD dwStatus = ERROR_INVALID_PARAMETER;
if (g_TimerQueueList.FindQueue((CDoubleLinkedListEntry *)pQueue) != NULL) {
pQueue->DeleteTimers();
if (pQueue == g_hDefaultTimerQueue) {
CleanupDefaultTimerQueue();
}
delete pQueue;
dwStatus = ERROR_SUCCESS;
}
pRequest->SetCompletionStatus(dwStatus);
}
PRIVATE
VOID
AddTimer(
IN CTimerAddRequest * pRequest
)
{
CTimerQueue * pQueue = pRequest->GetQueue();
//
// add timer object to global list of timer objects, in expiration time
// order
//
pRequest->InsertBack(g_TimerQueueList.TimerListHead());
//
// add timer object to end of timer queue list in no particular order. Only
// used to delete all objects belonging to queue when queue is deleted
//
pRequest->TimerListHead()->InsertTail(pQueue->TimerListHead());
pRequest->SetComplete();
}
PRIVATE
VOID
ChangeTimer(
IN CTimerChangeRequest * pRequest
)
{
CTimerQueue * pQueue = (CTimerQueue *)pRequest->GetQueue();
CTimerQueueEntry * pTimer = pQueue->FindTimer(pRequest->GetTimer());
DWORD dwStatus = ERROR_INVALID_PARAMETER;
if (pTimer != NULL) {
pTimer->SetPeriod(pRequest->GetPeriod());
pTimer->SetExpirationTime(pRequest->GetDueTime());
dwStatus = ERROR_SUCCESS;
}
pRequest->SetCompletionStatus(dwStatus);
}
PRIVATE
VOID
CancelTimer(
IN CTimerCancelRequest * pRequest
)
{
CTimerQueue * pQueue = (CTimerQueue *)pRequest->GetQueue();
CTimerQueueEntry * pTimer = pQueue->FindTimer(pRequest->GetTimer());
DWORD dwStatus = ERROR_INVALID_PARAMETER;
if (pTimer != NULL) {
if (pTimer->IsInUse()) {
pTimer->SetCancelled();
} else {
pTimer->Remove();
delete pTimer;
}
dwStatus = ERROR_SUCCESS;
}
pRequest->SetCompletionStatus(dwStatus);
}
//
// Definitions of forward-declared data.
//
t_CreateTimerQueue _I_CreateTimerQueue = IECreateTimerQueue;
t_DeleteTimerQueue _I_DeleteTimerQueue = IEDeleteTimerQueue;
t_SetTimerQueueTimer _I_SetTimerQueueTimer = IESetTimerQueueTimer;
t_ChangeTimerQueueTimer _I_ChangeTimerQueueTimer = IEChangeTimerQueueTimer;
t_CancelTimerQueueTimer _I_CancelTimerQueueTimer = IECancelTimerQueueTimer;
//
// KERNEL functions that our NT stubs use. Not used if in IE mode.
//
t_CreateTimerQueueTimer _I_CreateTimerQueueTimer = NULL;
t_DeleteTimerQueueTimer _I_DeleteTimerQueueTimer = NULL;