windows-server-2003/sdktools/pdh/pdhdll/qutils.c

/*++
Copyright (C) 1995-1999 Microsoft Corporation

Module Name:
    qutils.c

Abstract:
    Query management utility functions
--*/

#include <windows.h>
#include "strsafe.h"
#include <pdh.h>
#include "pdhitype.h"
#include "pdhidef.h"
#include "pdhmsg.h"
#include "strings.h"
#include "log_bin.h"
#include "log_wmi.h"
#include "perfdata.h"

BOOL
IsValidQuery(
    PDH_HQUERY hQuery
)
{
    BOOL        bReturn = FALSE;    // assume it's not a valid query
    PPDHI_QUERY pQuery;

    __try {
        if (hQuery != NULL) {
            // see if a valid signature
            pQuery = (PPDHI_QUERY) hQuery;
            if ((* (DWORD *) & pQuery->signature[0] == SigQuery) && (pQuery->dwLength == sizeof(PDHI_QUERY))) {
                bReturn = TRUE;
            }
        }
    }
    __except (EXCEPTION_EXECUTE_HANDLER) {
        // something failed miserably so we can assume this is invalid
    }
    return bReturn;
}

BOOL
AddMachineToQueryLists(
    PPERF_MACHINE pMachine,
    PPDHI_COUNTER pNewCounter
)
{
    BOOL                bReturn = FALSE; // assume failure
    PPDHI_QUERY         pQuery;
    PPDHI_QUERY_MACHINE pQMachine;
    PPDHI_QUERY_MACHINE pLastQMachine;

    pQuery = pNewCounter->pOwner;

    if (IsValidQuery(pQuery)) {
        if (pQuery->pFirstQMachine != NULL) {
            // look for machine in list
            pLastQMachine = pQMachine = pQuery->pFirstQMachine;
            while (pQMachine != NULL) {
                if (pQMachine->pMachine == pMachine) {
                    // found the machine already in the list so continue
                    bReturn = TRUE;
                    break;
                }
                else {
                    pLastQMachine = pQMachine;
                    pQMachine     = pQMachine->pNext;
                }
            }
            if (pQMachine == NULL) {
                // add this machine to the end of the list
                pQMachine = G_ALLOC((sizeof(PDHI_QUERY_MACHINE) + (sizeof(WCHAR) * MAX_PATH)));
                if (pQMachine != NULL) {
                    pQMachine->pMachine     = pMachine;
                    pQMachine->szObjectList = (LPWSTR) ( & pQMachine[1]);
                    pQMachine->pNext        = NULL;
                    pQMachine->lQueryStatus = pMachine->dwStatus;
                    pQMachine->llQueryTime  = 0;
                    bReturn                 = TRUE;

                    // the pPerfData pointer will be tested prior to usage
                    pQMachine->pPerfData    = G_ALLOC(MEDIUM_BUFFER_SIZE);
                    if (pQMachine->pPerfData == NULL) {
                        G_FREE(pQMachine);
                        pQMachine = NULL;
                        bReturn   = FALSE;
                        SetLastError(PDH_MEMORY_ALLOCATION_FAILURE);
                    }
                    else {
                        pLastQMachine->pNext = pQMachine;
                    }
                }
                else {
                    // unable to alloc memory block so machine cannot
                    // be added
                    SetLastError(PDH_MEMORY_ALLOCATION_FAILURE);
                }
            }
        }
        else {
            // add this as the first machine
            pQMachine = G_ALLOC ((sizeof(PDHI_QUERY_MACHINE) + (sizeof(WCHAR) * PDH_MAX_COUNTER_PATH)));
            if (pQMachine != NULL) {
                pQMachine->pMachine     = pMachine;
                pQMachine->szObjectList = (LPWSTR) (& pQMachine[1]);
                pQMachine->pNext        = NULL;
                pQMachine->lQueryStatus = pMachine->dwStatus;
                pQMachine->llQueryTime  = 0;
                bReturn                 = TRUE;

                // the pPerfData pointer will be tested prior to usage
                pQMachine->pPerfData = G_ALLOC(MEDIUM_BUFFER_SIZE);
                if (pQMachine->pPerfData == NULL) {
                    G_FREE(pQMachine);
                    pQMachine = NULL;
                    bReturn   = FALSE;
                    SetLastError(PDH_MEMORY_ALLOCATION_FAILURE);
                }
                else {
                    pQuery->pFirstQMachine = pQMachine;
                }
            }
            else {
                // unable to alloc memory block so machine cannot
                // be added
               SetLastError(PDH_MEMORY_ALLOCATION_FAILURE);
            }
        }
        // here pQMachine should be the pointer to the correct machine
        // entry or NULL if unable to create
        if (pQMachine != NULL) {
            // save the new pointer
            pNewCounter->pQMachine = pQMachine;

            // increment reference count for this machine
            pMachine->dwRefCount ++;

            // update query perf. object list
            AppendObjectToValueList(
                    pNewCounter->plCounterInfo.dwObjectId, pQMachine->szObjectList, PDH_MAX_COUNTER_PATH);
        }
    }
    else {
        SetLastError(PDH_INVALID_HANDLE);
        bReturn = FALSE;
    }

    return bReturn;
}

extern PDH_FUNCTION
PdhiGetBinaryLogCounterInfo(
    PPDHI_LOG       pLog,
    PPDHI_COUNTER   pCounter
);

extern PPERF_DATA_BLOCK
PdhWmiMergeObjectBlock(
    PPDHI_LOG                       pLog,
    LPWSTR                          szMachine,
    PPDHI_BINARY_LOG_RECORD_HEADER  pThisMasterRecord,
    PPDHI_BINARY_LOG_RECORD_HEADER  pThisSubRecord
);

PDH_FUNCTION
PdhiGetCounterFromDataBlock(
    PPDHI_LOG          pLog,
    PVOID              pDataBuffer,
    PPDHI_COUNTER      pCounter
)
{
    PDH_STATUS        pdhStatus           = ERROR_SUCCESS;
    PERFLIB_COUNTER * pPerfCounter        = & pCounter->plCounterInfo;
    PPDH_RAW_COUNTER  pRawValue           = & pCounter->ThisValue;
    LPWSTR            szCompositeInstance = NULL;
    DWORD             dwDataItemIndex;
    LPWSTR            szThisInstanceName;

    PPDHI_BINARY_LOG_RECORD_HEADER  pThisMasterRecord;
    PPDHI_BINARY_LOG_RECORD_HEADER  pThisSubRecord;

    PPDHI_RAW_COUNTER_ITEM_BLOCK    pDataBlock;
    PPDHI_RAW_COUNTER_ITEM          pDataItem;
    PPDH_RAW_COUNTER                pRawItem;

    PPERF_DATA_BLOCK                pPerfData;
    PPERF_DATA_BLOCK                pTmpBlock;
    FILETIME                        ftDataBlock;
    FILETIME                        ftGmtDataBlock;
    LONGLONG                        TimeStamp;

    ZeroMemory(& ftDataBlock, sizeof(FILETIME));
    ZeroMemory(& ftGmtDataBlock, sizeof(FILETIME));
    ZeroMemory(pRawValue, sizeof(PDH_RAW_COUNTER));
    pThisMasterRecord = (PPDHI_BINARY_LOG_RECORD_HEADER) pDataBuffer;
    pThisSubRecord = PdhiGetSubRecord(pThisMasterRecord, pCounter->dwIndex);

    if (pThisSubRecord != NULL) {
        if (pThisSubRecord->dwType == BINLOG_TYPE_DATA_PSEUDO) {
            PDH_STATUS Status     = ERROR_SUCCESS;
            DWORD      dwOriginal = pCounter->dwIndex;
            DWORD      dwPrevious;

            while (Status == ERROR_SUCCESS && pThisSubRecord) {
                if (pThisSubRecord->dwType != BINLOG_TYPE_DATA_PSEUDO) {
                    break;
                }
                dwPrevious = pCounter->dwIndex;
                Status     = PdhiGetBinaryLogCounterInfo(pLog, pCounter);
                if (   Status == ERROR_SUCCESS
                    && dwPrevious != pCounter->dwIndex) {
                    pThisSubRecord = PdhiGetSubRecord(pThisMasterRecord, pCounter->dwIndex);
                }
            }
            if (pThisSubRecord == NULL || Status == PDH_ENTRY_NOT_IN_LOG_FILE) {
                pCounter->dwIndex = 0;
                do {
                    dwPrevious = pCounter->dwIndex;
                    Status     = PdhiGetBinaryLogCounterInfo(pLog, pCounter);
                    if (Status == ERROR_SUCCESS && dwPrevious != pCounter->dwIndex) {
                        pThisSubRecord = PdhiGetSubRecord(pThisMasterRecord, pCounter->dwIndex);
                    }
                    if (pThisSubRecord->dwType != BINLOG_TYPE_DATA_PSEUDO) {
                        break;
                    }
                }
                while (Status == ERROR_SUCCESS && pCounter->dwIndex < dwOriginal && pThisSubRecord);

                if (pThisSubRecord == NULL || pCounter->dwIndex >= dwOriginal) {
                    Status = PDH_ENTRY_NOT_IN_LOG_FILE;
                }
            }
            if (Status == PDH_ENTRY_NOT_IN_LOG_FILE) {
                    pCounter->dwIndex = dwOriginal;
                    pThisSubRecord = PdhiGetSubRecord(pThisMasterRecord, pCounter->dwIndex);
            }
        }
    }
    if (pLog->pLastRecordRead != pDataBuffer) {
        pLog->pLastRecordRead = pDataBuffer;
    }

    if (pThisSubRecord != NULL) {
        switch (pThisSubRecord->dwType) {
        case BINLOG_TYPE_DATA_LOC_OBJECT:
            pTmpBlock = (PPERF_DATA_BLOCK) ((LPBYTE)pThisSubRecord + sizeof(PDHI_BINARY_LOG_RECORD_HEADER));
            pPerfData = PdhWmiMergeObjectBlock(
                            pLog, pCounter->pCounterPath->szMachineName, pThisMasterRecord, pThisSubRecord);
            SystemTimeToFileTime(& pPerfData->SystemTime, & ftDataBlock);
            TimeStamp = MAKELONGLONG(ftDataBlock.dwLowDateTime, ftDataBlock.dwHighDateTime);
            if (pCounter->dwFlags & PDHIC_MULTI_INSTANCE) {
                UpdateMultiInstanceCounterValue(pCounter, pPerfData, TimeStamp);
            }
            else {
                UpdateCounterValue(pCounter, pPerfData);
                pCounter->ThisValue.TimeStamp = ftDataBlock;
            }
            break;

        case BINLOG_TYPE_DATA_PSEUDO:
        case BINLOG_TYPE_DATA_SINGLE:
            pRawItem = (PPDH_RAW_COUNTER) ((LPBYTE)pThisSubRecord + sizeof (PDHI_BINARY_LOG_RECORD_HEADER));
            RtlCopyMemory(pRawValue, pRawItem, sizeof (PDH_RAW_COUNTER));
            pdhStatus = ERROR_SUCCESS;
            break;

        case BINLOG_TYPE_DATA_MULTI:
            if (pCounter->dwFlags & PDHIC_MULTI_INSTANCE) {
                // this is a wild card query
                //
                ULONG i;
                ULONG CopySize = pThisSubRecord->dwLength - sizeof(PDHI_BINARY_LOG_RECORD_HEADER);
                PPDHI_RAW_COUNTER_ITEM_BLOCK pNewBlock = G_ALLOC(CopySize);

                if (pNewBlock == NULL) {
                    pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
                }
                else if (pCounter->pThisRawItemList != NULL) {
                    G_FREE(pCounter->pLastRawItemList);
                    pCounter->pLastRawItemList = pCounter->pThisRawItemList;
                }
                pCounter->pThisRawItemList = pNewBlock;
                RtlCopyMemory(pNewBlock,
                              (((LPBYTE) pThisSubRecord) + sizeof(PDHI_BINARY_LOG_RECORD_HEADER)),
                              CopySize);
            }
            else if (pPerfCounter->szInstanceName != NULL) {
                DWORD dwInstanceId   = pCounter->pCounterPath->dwIndex;
                DWORD dwInstanceSize = lstrlenW(pPerfCounter->szInstanceName) + 1;

                if (pPerfCounter->szParentInstanceName != NULL) {
                    dwInstanceSize += lstrlenW(pPerfCounter->szParentInstanceName) + 1;
                }
                szCompositeInstance = G_ALLOC(sizeof(WCHAR) * dwInstanceSize);
                if (szCompositeInstance != NULL) {
                    if (pPerfCounter->szParentInstanceName != NULL) {
                        StringCchPrintfW(szCompositeInstance, dwInstanceSize,
                                         L"%ws/%ws",
                                         pPerfCounter->szParentInstanceName,
                                         pPerfCounter->szInstanceName);
                    }
                    else {
                        StringCchCopyW(szCompositeInstance, dwInstanceSize, pPerfCounter->szInstanceName);
                    }
                }
                else {
                    pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE;
                    break;
                }

                pDataBlock = (PPDHI_RAW_COUNTER_ITEM_BLOCK)
                             ((LPBYTE) pThisSubRecord + sizeof (PDHI_BINARY_LOG_RECORD_HEADER));
                pdhStatus          = PDH_ENTRY_NOT_IN_LOG_FILE;
                pRawValue->CStatus = PDH_CSTATUS_NO_INSTANCE;

                for (dwDataItemIndex = 0; dwDataItemIndex < pDataBlock->dwItemCount; dwDataItemIndex++) {
                    pDataItem = &pDataBlock->pItemArray[dwDataItemIndex];
                    szThisInstanceName = (LPWSTR) ((LPBYTE) pDataBlock + (DWORD_PTR) pDataItem->szName);
                    if (lstrcmpiW(szThisInstanceName, szCompositeInstance) == 0) {
                        if (dwInstanceId == 0) {
                            pdhStatus              = ERROR_SUCCESS;
                            pRawValue->CStatus     = pDataBlock->CStatus;
                            pRawValue->TimeStamp   = pDataBlock->TimeStamp;
                            pRawValue->FirstValue  = pDataItem->FirstValue;
                            pRawValue->SecondValue = pDataItem->SecondValue;
                            pRawValue->MultiCount  = pDataItem->MultiCount;
                            break;
                        }
                        else {
                            dwInstanceId --;
                        }
                    }
                }
            }
            else {
                pdhStatus          = PDH_ENTRY_NOT_IN_LOG_FILE;
                pRawValue->CStatus = PDH_CSTATUS_INVALID_DATA;
            }
            break;

        default:
            pdhStatus          = PDH_LOG_TYPE_NOT_FOUND;
            pRawValue->CStatus = PDH_CSTATUS_INVALID_DATA;
            break;
        }
    }
    else {
        pdhStatus          = PDH_ENTRY_NOT_IN_LOG_FILE;
        pRawValue->CStatus = PDH_CSTATUS_INVALID_DATA;
    }

    G_FREE(szCompositeInstance);
    return pdhStatus;
}

LONG
GetQueryPerfData(
    PPDHI_QUERY   pQuery,
    LONGLONG    * pTimeStamp
)
{
    LONG                lStatus           = PDH_INVALID_DATA;
    PPDHI_COUNTER       pCounter;
    PPDHI_QUERY_MACHINE pQMachine;
    LONGLONG            llCurrentTime;
    LONGLONG            llTimeStamp       = 0;
    BOOLEAN             bCounterCollected = FALSE;
    BOOL                bLastLogEntry;

    if (pQuery->hLog == H_REALTIME_DATASOURCE) {
        FILETIME GmtFileTime;
        FILETIME LocFileTime;

        // this is a real-time query so
        // get the current data from each of the machines in the query
        //  (after this "sequential" approach is perfected, then the
        //  "parallel" approach of multiple threads can be developed
        //
        // get time stamp now so each machine will have the same time
        GetSystemTimeAsFileTime(& GmtFileTime);
        FileTimeToLocalFileTime(& GmtFileTime, & LocFileTime);
        llTimeStamp = MAKELONGLONG(LocFileTime.dwLowDateTime, LocFileTime.dwHighDateTime);

        pQMachine = pQuery->pFirstQMachine;
        while (pQMachine != NULL) {
            pQMachine->llQueryTime = llTimeStamp;
            lStatus = ValidateMachineConnection(pQMachine->pMachine);
            if (lStatus == ERROR_SUCCESS) {
                // machine is connected so get data
                lStatus = GetSystemPerfData(
                                pQMachine->pMachine->hKeyPerformanceData,
                                & pQMachine->pPerfData,
                                pQMachine->szObjectList,
                                FALSE); // never query the costly data objects as a group
                // save the machine's last status

                pQMachine->pMachine->dwStatus = lStatus;
                // if there was an error in the data collection,
                // set the retry counter and wait to try again.
                if (lStatus != ERROR_SUCCESS) {
                    GetSystemTimeAsFileTime(& LocFileTime);
                    llCurrentTime = MAKELONGLONG(LocFileTime.dwLowDateTime, LocFileTime.dwHighDateTime);
                    pQMachine->pMachine->llRetryTime = llCurrentTime + RETRY_TIME_INTERVAL;
                }

            }
            pQMachine->lQueryStatus = lStatus;
            // get next machine in query
            pQMachine = pQMachine->pNext;
        }
        // now update the counters using this new data
        if ((pCounter = pQuery->pCounterListHead) != NULL) {
            DWORD dwCollected = 0;
            do {
                if (pCounter->dwFlags & PDHIC_COUNTER_OBJECT) {
                    if (UpdateCounterObject(pCounter)) {
                        dwCollected ++;
                    }
                }
                else if (pCounter->dwFlags & PDHIC_MULTI_INSTANCE) {
                    if (UpdateRealTimeMultiInstanceCounterValue (pCounter)) {
                        dwCollected ++;
                    }
                }
                else {
                    // update single instance counter values
                    if (UpdateRealTimeCounterValue(pCounter)) {
                        dwCollected ++;
                    }
                }
                pCounter = pCounter->next.flink;
            }
            while (pCounter != NULL && pCounter != pQuery->pCounterListHead);
            lStatus = (dwCollected > 0) ? ERROR_SUCCESS : PDH_NO_DATA;
        }
        else {
            // no counters in the query  (?!)
            lStatus = PDH_NO_DATA;
        }
    }
    else {
        // read data from log file
        // get the next log record entry and update the
        // corresponding counter entries

        PPDHI_LOG pLog      = NULL;
        DWORD     dwLogType = 0;

        __try {
            pLog      = (PPDHI_LOG) (pQuery->hLog);
            dwLogType = LOWORD(pLog->dwLogFormat);
            lStatus   = ERROR_SUCCESS;
        }
        __except (EXCEPTION_EXECUTE_HANDLER) {
            pQuery->dwLastLogIndex = (ULONG) -1;
            lStatus                = PDH_INVALID_HANDLE;
        }

        if (lStatus == ERROR_SUCCESS) {
            if (dwLogType == PDH_LOG_TYPE_BINARY) {
                if (pQuery->dwLastLogIndex == 0) {
                    lStatus = PdhiReadTimeWmiRecord(
                                    pLog,
                                    * (ULONGLONG *) & pQuery->TimeRange.StartTime,
                                    NULL,
                                    0);
                    pQuery->dwLastLogIndex = BINLOG_FIRST_DATA_RECORD;
                }
                else {
                    lStatus = PdhiReadNextWmiRecord(pLog, NULL, 0, TRUE);
                }
                if (lStatus != ERROR_SUCCESS && lStatus != PDH_MORE_DATA) {
                    pQuery->dwLastLogIndex = (DWORD) -1;
                }
                else {
                    pQuery->dwLastLogIndex --;
                }
            }
            else if (pQuery->dwLastLogIndex == 0) {
                // then the first matching entry needs to be
                // located in the log file
                lStatus = PdhiGetMatchingLogRecord(
                                pQuery->hLog,
                                (LONGLONG *) & pQuery->TimeRange.StartTime,
                                & pQuery->dwLastLogIndex);
                if (lStatus != ERROR_SUCCESS) {
                    // the matching time entry wasn't found in the log
                    pQuery->dwLastLogIndex = (DWORD) -1;
                }
                else {
                    // decrement the index so it can be incremented
                    // below. 0 is not a valid entry so there's no
                    // worry about -1 being attempted accidently.
                    pQuery->dwLastLogIndex--;
                }
            }

            if (pQuery->dwLastLogIndex != (DWORD) -1) {
                bLastLogEntry = FALSE;
                pQuery->dwLastLogIndex ++;   // go to next entry
                if ((pCounter = pQuery->pCounterListHead) != NULL) {
                    DWORD dwCounter = 0;
                    do {
                        if (dwLogType == PDH_LOG_TYPE_BINARY) {
                            // save current value as last value since we are getting
                            // a new one, hopefully.
                            pCounter->LastValue = pCounter->ThisValue;
                            lStatus = PdhiGetCounterFromDataBlock(
                                            pLog,
                                            pLog->pLastRecordRead,
                                            pCounter);
                        }
                        else {
                            lStatus = PdhiGetCounterValueFromLogFile(
                                            pQuery->hLog,
                                            pQuery->dwLastLogIndex,
                                            pCounter);
                        }
                        if (lStatus != ERROR_SUCCESS) {
                            // see if this is because there's no more entries
                            if (lStatus == PDH_NO_MORE_DATA) {
                                bLastLogEntry = TRUE;
                                break;
                            }
                        }
                        else if (dwLogType == PDH_LOG_TYPE_BINARY) {
                            if (pCounter->ThisValue.CStatus == PDH_CSTATUS_VALID_DATA) {
                                llTimeStamp = pLog->llFileSize;
                                if (pLog->llFileSize > pQuery->TimeRange.EndTime) {
                                    lStatus = PDH_NO_MORE_DATA;
                                    bLastLogEntry = TRUE;
                                    break;
                                }
                                dwCounter ++;
                            }
                        }
                        else {
                            // single entry or multiple entries
                            //
                            if (pCounter->ThisValue.CStatus == PDH_CSTATUS_VALID_DATA) {
                                llTimeStamp = MAKELONGLONG(pCounter->ThisValue.TimeStamp.dwLowDateTime,
                                                           pCounter->ThisValue.TimeStamp.dwHighDateTime);
                                if (llTimeStamp > pQuery->TimeRange.EndTime) {
                                    lStatus = PDH_NO_MORE_DATA;
                                    bLastLogEntry = TRUE;
                                    break;
                                }
                                dwCounter ++;
                            }
                            bCounterCollected = TRUE;
                        }
                        // go to next counter in list
                        pCounter = pCounter->next.flink;
                    }
                    while (pCounter != NULL && pCounter != pQuery->pCounterListHead);

                    if (bLastLogEntry) {
                        lStatus = PDH_NO_MORE_DATA;
                    }
                    else if (dwCounter == 0) {
                        lStatus = PDH_NO_DATA;
                    }
                    else if (bCounterCollected) {
                        lStatus = ERROR_SUCCESS;
                    }
                }
                else {
                    // no counters in the query  (?!)
                    lStatus = PDH_NO_DATA;
                }
            }
            else {
                // all samples in the requested time frame have
                // been returned.
                lStatus = PDH_NO_MORE_DATA;
            }
        }
    }
    * pTimeStamp = llTimeStamp;
    return lStatus;
}

DWORD
WINAPI
PdhiAsyncTimerThreadProc(
    LPVOID  pArg
)
{
    PPDHI_QUERY pQuery;
    DWORD       dwMsWaitTime;
    PDH_STATUS  Status;
    FILETIME    ftStart;
    FILETIME    ftStop;
    LONGLONG    llAdjustment;
    DWORD       dwInterval;
    LONG        lStatus = ERROR_SUCCESS;
    LONGLONG    llTimeStamp;

    pQuery     = (PPDHI_QUERY) pArg;
    dwInterval = dwMsWaitTime = pQuery->dwInterval * 1000; // convert sec. to mS.

    // wait for timeout or exit event, then update the specified query
    while ((lStatus = WaitForSingleObject(pQuery->hExitEvent, dwMsWaitTime)) != WAIT_OBJECT_0) {
        // time out elapsed so get new sample.
        GetSystemTimeAsFileTime(& ftStart);
        lStatus = WAIT_FOR_AND_LOCK_MUTEX(pQuery->hMutex);
        if (lStatus == ERROR_SUCCESS) {
            if (pQuery->dwFlags & PDHIQ_WBEM_QUERY) {
                Status = GetQueryWbemData(pQuery, & llTimeStamp);
            } else {
                Status = GetQueryPerfData(pQuery, & llTimeStamp);
            }
            SetEvent (pQuery->hNewDataEvent);
            RELEASE_MUTEX(pQuery->hMutex);
            GetSystemTimeAsFileTime(& ftStop);
            llAdjustment  = * (LONGLONG *) & ftStop;
            llAdjustment -= * (LONGLONG *) & ftStart;
            llAdjustment += 5000;   // for rounding
            llAdjustment /= 10000;  // convert 100ns Units to ms

            if (dwInterval > llAdjustment) {
                dwMsWaitTime = dwInterval - (DWORD) (llAdjustment & 0x00000000FFFFFFFF);
            }
            else {
                dwMsWaitTime = 0; // overdue so do it now.
            }
        }
    }
    return lStatus;
}