windows-xp/Source/XPSP1/NT/sdktools/perflog/pdlsvc/logthred.c

/*++

Copyright (c) 1996  Microsoft Corporation

Module Name:

    LogThred.c

Abstract:

    module containing logging thread functions

Author:

    Bob Watson (a-robw) 10 Apr 96

Revision History:

--*/
#ifndef UNICODE
#define UNICODE     1
#endif
#ifndef _UNICODE
#define _UNICODE    1
#endif
//
//  Windows Include files
//
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
#include <pdh.h>
#include <pdhmsg.h>
#include "pdlsvc.h"
//#include "logutils.h"
#include "pdlmsg.h"

static
long
JulianDateFromSystemTime(
    SYSTEMTIME *pST
)
{
    static WORD wDaysInRegularMonth[] = {
    	31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365
    };

    static WORD wDaysInLeapYearMonth[] = {
    	31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366
    };

    long JDate = 0;

    // Check for leap year.
    if (pST->wMonth > 1) {
        if( pST->wYear % 100 != 0 && pST->wYear % 4 == 0 ) {
	    // this is a leap year
	    JDate += wDaysInLeapYearMonth[pST->wMonth - 1];
	} else {
	    // this is not a leap year
            JDate += wDaysInRegularMonth[pST->wMonth - 1];
        }
    }
    // Add in days for this month.
    JDate += pST->wDay;

    // Add in year.
    JDate += (pST->wYear % 100) * 10000;

    return JDate;
}

static
BOOL
GetLocalFileTime (
    SYSTEMTIME  *pST,
    LONGLONG    *pFileTime
)
{
    BOOL    bResult;
    GetLocalTime (pST);
    if (pFileTime != NULL) {
        bResult = SystemTimeToFileTime (pST, (LPFILETIME)pFileTime);
    } else {
        bResult = TRUE;
    }
    return bResult;
}

static
DWORD
GetSamplesInRenameInterval(
    IN DWORD    dwSampleInterval,           // in seconds
    IN DWORD    dwRenameIntervalCount,      // in units
    IN DWORD    dwRenameIntervalUnits)      // for "count" arg
{
    DWORD    dwRenameIntervalSeconds;
    // convert rename interval to seconds and account for the
    // first (or zero-th) sample in the log

    dwRenameIntervalSeconds = dwRenameIntervalCount;

    switch (dwRenameIntervalUnits) {
        case OPD_RENAME_HOURS:
            dwRenameIntervalSeconds *= SECONDS_IN_HOUR;
            break;

        case OPD_RENAME_DAYS:
        default:
            dwRenameIntervalSeconds *= SECONDS_IN_DAY;
            break;

        case OPD_RENAME_MONTHS:
            dwRenameIntervalSeconds *= SECONDS_IN_DAY * 30;
            break;

        case OPD_RENAME_KBYTES:
        case OPD_RENAME_MBYTES:
            // these don't use a rename counter
            return (DWORD)0;
            break;
    }

    dwRenameIntervalSeconds /= dwSampleInterval;

    dwRenameIntervalSeconds += 1;   // add in the "zero-th" sample

    return (dwRenameIntervalSeconds);
}

static
LONG
BuildCurrentLogFileName (
    IN  LPCTSTR     szBaseFileName,
    IN  LPCTSTR     szDefaultDir,
    IN  LPTSTR      szOutFileBuffer,
    IN  LPDWORD     lpdwSerialNumber,
    IN  DWORD       dwDateFormat,
    IN  DWORD       dwLogFormat
)
// presumes OutFileBuffer is large enough (i.e. >= MAX_PATH)
{
    SYSTEMTIME  st;
    BOOL        bUseCurrentDir = FALSE;
    TCHAR       szAuto[MAX_PATH];
    LPTSTR      szExt;

    if (szDefaultDir != NULL) {
        if (*szDefaultDir == 0) {
            bUseCurrentDir = TRUE;
        }
    } else {
        bUseCurrentDir = TRUE;
    }

    if (bUseCurrentDir) {
        GetCurrentDirectory (MAX_PATH, szOutFileBuffer);
    } else {
        lstrcpy (szOutFileBuffer, szDefaultDir);
    }

    // add a backslash to the path name if it doesn't have one already

    if (szOutFileBuffer[lstrlen(szOutFileBuffer)-1] != TEXT('\\')) {
        lstrcat (szOutFileBuffer, TEXT("\\"));
    }

    // add the base filename

    lstrcat (szOutFileBuffer, szBaseFileName);

    // add the auto name part

    // get date/time/serial integer format
    GetLocalTime(&st);

    switch (dwDateFormat) {
    case OPD_NAME_NNNNNN:
        _stprintf (szAuto, TEXT("_%6.6d"), *lpdwSerialNumber);
        (*lpdwSerialNumber)++; // increment
        if (*lpdwSerialNumber >= 1000000) {
            // roll over to 0
            *lpdwSerialNumber = 0;
        }
        break;

    case OPD_NAME_YYDDD:
        _stprintf (szAuto, TEXT("_%5.5d"),
            JulianDateFromSystemTime(&st));
        break;

    case OPD_NAME_YYMM:
        _stprintf (szAuto, TEXT("_%2.2d%2.2d"),
            st.wYear % 100, st.wMonth);
        break;

    case OPD_NAME_YYMMDDHH:
        _stprintf (szAuto, TEXT("_%2.2d%2.2d%2.2d%2.2d"),
            (st.wYear % 100), st.wMonth, st.wDay, st.wHour);
        break;

    case OPD_NAME_MMDDHH:
        _stprintf (szAuto, TEXT("_%2.2d%2.2d%2.2d"),
            st.wMonth, st.wDay, st.wHour);
        break;

    case OPD_NAME_YYMMDD:
    default:
        _stprintf (szAuto, TEXT("_%2.2d%2.2d%2.2d"),
            st.wYear % 100, st.wMonth, st.wDay);
        break;
    }

    lstrcat (szOutFileBuffer, szAuto);

    // get file type
    switch (dwLogFormat) {
    case PDH_LOG_TYPE_TSV:
        szExt = TEXT(".tsv");
        break;

    case PDH_LOG_TYPE_BINARY:
        szExt = TEXT(".blg");
        break;

    case PDH_LOG_TYPE_CSV:
    default:
        szExt = TEXT(".csv");
        break;
    }

    lstrcat (szOutFileBuffer, szExt);

    return ERROR_SUCCESS;
}

static
BOOL
LoadDataFromRegistry (
    IN  LPLOG_THREAD_DATA   pArg,
    IN  LPTSTR              szDefaultDir,
    IN  LPTSTR              szBaseName,
    IN  LPTSTR              szCurrentLogFile
)
{
    LONG            lStatus;
    DWORD           dwType;
    DWORD           dwSize;
    DWORD           dwData;
    LPTSTR          szStringArray[2];

    // get size of buffer required by counter list,
    // then allocate the buffer and retrieve the counter list

    dwType = 0;
    dwData = 0;
    dwSize = 0;
    lStatus = RegQueryValueEx (
        pArg->hKeyQuery,
        TEXT("Counter List"),
        NULL,
        &dwType,
        (LPBYTE)NULL,
        &dwSize);

    pArg->mszCounterList = (LPTSTR)G_ALLOC(dwSize);

    if (pArg->mszCounterList != NULL) {
        dwType = 0;
        lStatus = RegQueryValueEx (
            pArg->hKeyQuery,
            TEXT("Counter List"),
            NULL,
            &dwType,
            (LPBYTE)pArg->mszCounterList,
            &dwSize);

        if ((lStatus != ERROR_SUCCESS) || (dwSize == 0)) {
            // no counter list retrieved so there's not much
            // point in continuing
            szStringArray[0] = pArg->szQueryName;
            ReportEvent (hEventLog,
                EVENTLOG_ERROR_TYPE,
                0,
                PERFLOG_UNABLE_READ_COUNTER_LIST,
                NULL,
                1,
                sizeof(DWORD),
                szStringArray,
                (LPVOID)&lStatus);
            return FALSE;
        }
    } else {
        szStringArray[0] = pArg->szQueryName;
        ReportEvent (hEventLog,
            EVENTLOG_ERROR_TYPE,
            0,
            PERFLOG_UNABLE_ALLOC_COUNTER_LIST,
            NULL,
            1,
            sizeof(DWORD),
            szStringArray,
            (LPVOID)&lStatus);
        return FALSE;
    }

    dwType = 0;
    dwData = 0;
    dwSize = sizeof(DWORD);
    lStatus = RegQueryValueEx (
        pArg->hKeyQuery,
        TEXT("Auto Name Interval"),
        NULL,
        &dwType,
        (LPBYTE)&dwData,
        &dwSize);
    if (lStatus != ERROR_SUCCESS) {
        dwData = 0; // default is no autonaming
    } else if (dwType != REG_DWORD) {
        dwData = 0; // default is no autonaming
    } // else assume success

    pArg->dwRenameIntervalCount = dwData;

    dwType = 0;
    dwData = 0;
    dwSize = sizeof(DWORD);
    lStatus = RegQueryValueEx (
        pArg->hKeyQuery,
        TEXT("Auto Rename Units"),
        NULL,
        &dwType,
        (LPBYTE)&dwData,
        &dwSize);
    if (lStatus != ERROR_SUCCESS) {
        dwData = OPD_RENAME_DAYS; // default is days
    } else if (dwType != REG_DWORD) {
        dwData = OPD_RENAME_DAYS; // default is days
    } // else assume success

    pArg->dwRenameIntervalUnits = dwData;

    dwType = 0;
    dwData = 0;
    dwSize = sizeof(DWORD);
    lStatus = RegQueryValueEx (
        pArg->hKeyQuery,
        TEXT("Log File Auto Format"),
        NULL,
        &dwType,
        (LPBYTE)&dwData,
        &dwSize);
    if (lStatus != ERROR_SUCCESS) {
        dwData = OPD_NAME_NNNNNN; // default is a serial number
    } else if (dwType != REG_DWORD) {
        dwData = OPD_NAME_NNNNNN; // default is a serial number
    } // else assume success

    pArg->dwAutoNameFormat = dwData;

    dwType = 0;
    dwData = 0;
    dwSize = sizeof(DWORD);
    lStatus = RegQueryValueEx (
        pArg->hKeyQuery,
        TEXT("Log File Type"),
        NULL,
        &dwType,
        (LPBYTE)&dwData,
        &dwSize);
    if (lStatus != ERROR_SUCCESS) {
        dwData = OPD_CSV_FILE; // default is a CSV file
    } else if (dwType != REG_DWORD) {
        dwData = OPD_CSV_FILE; // default is a CSV file
    } // else assume success

    // convert from OPD to PDH constant
    switch (dwData) {
        case OPD_TSV_FILE:
            pArg->dwLogType = PDH_LOG_TYPE_TSV;
            break;

        case OPD_BIN_FILE:
            pArg->dwLogType = PDH_LOG_TYPE_BINARY;
            break;

        case OPD_CSV_FILE:
        default:
            pArg->dwLogType = PDH_LOG_TYPE_CSV;
            break;
    }

    dwType = 0;
    dwData = 0;
    dwSize = sizeof(DWORD);
    lStatus = RegQueryValueEx (
        pArg->hKeyQuery,
        TEXT("Sample Interval"),
        NULL,
        &dwType,
        (LPBYTE)&dwData,
        &dwSize);
    if (lStatus != ERROR_SUCCESS) {
        dwData = SECONDS_IN_MINUTE; // default is 1 Minute samples
    } else if (dwType != REG_DWORD) {
        dwData = SECONDS_IN_MINUTE; // default is 1 Minute samples
    } // else assume success

    pArg->dwTimeInterval = dwData;

    // get filename or components if auto name

    if (pArg->dwRenameIntervalCount > 0) {
        // this is an autoname file so get components
        dwType = 0;
        *szDefaultDir = 0;
        dwSize = MAX_PATH * sizeof(TCHAR);
        lStatus = RegQueryValueEx (
            pArg->hKeyQuery,
            TEXT("Log Default Directory"),
            NULL,
            &dwType,
            (LPBYTE)&szDefaultDir[0],
            &dwSize);
        if (lStatus != ERROR_SUCCESS) {
            *szDefaultDir = 0;
        } // else assume success

        dwType = 0;
        *szBaseName = 0;
        dwSize = MAX_PATH * sizeof(TCHAR);
        lStatus = RegQueryValueEx (
            pArg->hKeyQuery,
            TEXT("Base Filename"),
            NULL,
            &dwType,
            (LPBYTE)&szBaseName[0],
            &dwSize);
        if (lStatus != ERROR_SUCCESS) {
            // apply default
            lstrcpy (szBaseName, TEXT("perfdata"));
        } // else assume success

        dwType = 0;
        dwSize = 0;
        lStatus = RegQueryValueEx (
            pArg->hKeyQuery,
            TEXT("Command File"),
            NULL,
            &dwType,
            NULL,
            &dwSize);
        if (lStatus != ERROR_SUCCESS) {
            // assume no command filname
            pArg->szCmdFileName = NULL;
        } else {
            // allocate a buffer for this field and collect data
            pArg->szCmdFileName = (LPTSTR)G_ALLOC(dwSize);
            if (pArg->szCmdFileName != NULL) {
                // get command filename
                dwType = 0;
                lStatus = RegQueryValueEx (
                    pArg->hKeyQuery,
                    TEXT("Command File"),
                    NULL,
                    &dwType,
                    (LPBYTE)pArg->szCmdFileName,
                    &dwSize);
                if (lStatus != ERROR_SUCCESS) {
                    // apply default
                    pArg->szCmdFileName = NULL;
                } // else assume success
            }
            if (pArg->szCmdFileName == NULL) {
                // log error message
                // no command file could be read so issue
                // warning and continue
                szStringArray[0] = pArg->szQueryName;
                ReportEvent (hEventLog,
                    EVENTLOG_WARNING_TYPE,
                    0,
                    PERFLOG_ALLOC_CMDFILE_BUFFER,
                    NULL,
                    1,
                    sizeof(DWORD),
                    szStringArray,
                    (LPVOID)&lStatus);
            }
        }

    } else {
        // this is a manual name file so read name
        dwType = 0;
        *szCurrentLogFile = 0;
        dwSize = MAX_PATH * sizeof(TCHAR);
        lStatus = RegQueryValueEx (
            pArg->hKeyQuery,
            TEXT("Log Filename"),
            NULL,
            &dwType,
            (LPBYTE)&szCurrentLogFile[0],
            &dwSize);
        if (lStatus != ERROR_SUCCESS) {
            // apply default
            lstrcpy (szCurrentLogFile, TEXT("c:\\perfdata.log"));
        } // else assume success
    }

    dwType = 0;
    dwData = 0;
    dwSize = sizeof(DWORD);
    lStatus = RegQueryValueEx (
        pArg->hKeyQuery,
        TEXT("Log File Serial Number"),
        NULL,
        &dwType,
        (LPBYTE)&dwData,
        &dwSize);
    if (lStatus != ERROR_SUCCESS) {
        dwData = 1; // default is to start at 1
    } else if (dwType != REG_DWORD) {
        dwData = 1; // default is to start at 1
    } // else assume success

    pArg->dwCurrentSerialNumber = dwData;
    return TRUE;
}

static
LONG
DoCommandFile (
    IN  LPLOG_THREAD_DATA   pArg,
    IN  LPTSTR              szLogFileName,
    IN  BOOL                bStillRunning
)
{
    LONG    lStatus;
    BOOL    bStatus;
    LPTSTR  szCommandString;
    LONG    nErrorMode;
    TCHAR   TempBuffer [ 5 * MAX_PATH] ;
    DWORD   StringLen;
    STARTUPINFO si;
    PROCESS_INFORMATION pi;
    DWORD          dwCreationFlags = NORMAL_PRIORITY_CLASS;

    szCommandString = (LPTSTR)G_ALLOC(4096 * sizeof(TCHAR));

    if (szCommandString != NULL) {
        // build command line arguments
        szCommandString[0] = _T('\"');
        lstrcpy (&szCommandString[1], szLogFileName);
        lstrcat (szCommandString, TEXT("\" "));
        lstrcat (szCommandString,
            (bStillRunning ? TEXT("1") : TEXT("0")));

        // initialize Startup Info block
        memset (&si, 0, sizeof(si));
        si.cb = sizeof(si);
        si.dwFlags = STARTF_USESHOWWINDOW ;
        si.wShowWindow = SW_SHOWNOACTIVATE ;

        memset (&pi, 0, sizeof(pi));

        // supress pop-ups inf the detached process
        nErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);

        lstrcpy (TempBuffer, pArg->szCmdFileName) ;

        // see if this is a CMD or a BAT file
        // if it is then create a process with a console window, otherwise
        // assume it's an executable file that will create it's own window
        // or console if necessary
        //
        _tcslwr (TempBuffer);
        if ((_tcsstr(TempBuffer, TEXT(".bat")) != NULL) ||
            (_tcsstr(TempBuffer, TEXT(".cmd")) != NULL)){
                dwCreationFlags |= CREATE_NEW_CONSOLE;
        } else {
                dwCreationFlags |= DETACHED_PROCESS;
        }
        // recopy the image name to the temp buffer since it was modified
        // (i.e. lowercased) for the previous comparison.

        lstrcpy (TempBuffer, pArg->szCmdFileName) ;
        StringLen = lstrlen (TempBuffer) ;

        // now add on the alert text preceded with a space char
        TempBuffer [StringLen] = TEXT(' ') ;
        StringLen++ ;
        lstrcpy (&TempBuffer[StringLen], szCommandString) ;

        bStatus = CreateProcess (
            NULL,
            TempBuffer,
            NULL, NULL, FALSE,
            dwCreationFlags,
            NULL,
            NULL,
            &si,
            &pi);

        SetErrorMode(nErrorMode);

        if (bStatus) {
            lStatus = ERROR_SUCCESS;
        } else {
            lStatus = GetLastError();
        }

    } else {
        lStatus = ERROR_OUTOFMEMORY;
    }

    return lStatus;
}

BOOL
LoggingProc (
    IN    LPLOG_THREAD_DATA pArg
)
{
    HQUERY          hQuery;
    HCOUNTER        hThisCounter;
    HLOG            hLog;
    DWORD           dwDelay;
    DWORD           dwSampleInterval, dwSampleTime=-1;
    PDH_STATUS      pdhStatus;
    DWORD           dwNumCounters;
    LONG            lStatus;
    TCHAR           szDefaultDir[MAX_PATH];
    TCHAR           szBaseName[MAX_PATH];

    LPTSTR          szThisPath;
    DWORD           dwLogType = PDH_LOG_TYPE_CSV;
    BOOL            bRun = FALSE;
    DWORD           dwSamplesUntilNewFile;
    TCHAR           szCurrentLogFile[MAX_PATH];
    LONG            lWaitStatus;
    LPTSTR          szStringArray[4];
    DWORD           dwFileSizeLimit;
    LONGLONG        llFileSizeLimit;
    LONGLONG        llFileSize;
    PLOG_COUNTER_INFO   pCtrInfo;

	SYSTEMTIME	    st;
    LONGLONG        llStartTime = 0;
    LONGLONG        llFinishTime = 0;

    // read registry values

    if (!LoadDataFromRegistry (pArg, szDefaultDir, szBaseName, szCurrentLogFile)) {
        // unable to initialize the query from the registry
        return FALSE;
    }

    // convert to milliseconds for use in timeouts
    dwSampleInterval = pArg->dwTimeInterval * 1000L;

    // open query and add counters from info file

    pdhStatus = PdhOpenQuery (NULL, 0, &hQuery); // from current activity
    if (pdhStatus == ERROR_SUCCESS) {
        dwNumCounters = 0;
        for (szThisPath = pArg->mszCounterList;
            *szThisPath != 0;
            szThisPath += lstrlen(szThisPath) + 1) {
            pdhStatus = PdhAddCounter (hQuery,
                (LPTSTR)szThisPath, dwNumCounters++, &hThisCounter);

            if (pdhStatus == ERROR_SUCCESS) {
                // then add this handle to the list
                pCtrInfo = G_ALLOC (sizeof (LOG_COUNTER_INFO));
                if (pCtrInfo != NULL) {
                    // insert at front of list since the order isn't
                    // important and this is simpler than walking the
                    // list each time.
                    pCtrInfo->hCounter = hThisCounter;
                    pCtrInfo->next = pFirstCounter;
                    pFirstCounter = pCtrInfo;
                }
            }
        }

        // to make sure we get to log the data
        SetThreadPriority (GetCurrentThread(), THREAD_PRIORITY_HIGHEST);

        bRun = TRUE;
        while (bRun) {
            // Get the current Log filename
            if (pArg->dwRenameIntervalCount != 0) {
                // then this is an autonamed file
                // so make current name
                BuildCurrentLogFileName (
                    szBaseName,
                    szDefaultDir,
                    szCurrentLogFile,
                    &pArg->dwCurrentSerialNumber,
                    pArg->dwAutoNameFormat,
                    pArg->dwLogType);
                // reset loop counter
                switch (pArg->dwRenameIntervalUnits) {
                case OPD_RENAME_KBYTES:
                    dwFileSizeLimit = pArg->dwRenameIntervalCount * 1024;
                    dwSamplesUntilNewFile = 0;
                    break;

                case OPD_RENAME_MBYTES:
                    dwFileSizeLimit = pArg->dwRenameIntervalCount * 1024 * 1024;
                    dwSamplesUntilNewFile = 0;
                    break;

                case OPD_RENAME_HOURS:
                case OPD_RENAME_DAYS:
                case OPD_RENAME_MONTHS:
                default:
                    dwSamplesUntilNewFile = GetSamplesInRenameInterval(
                        pArg->dwTimeInterval,
                        pArg->dwRenameIntervalCount,
                        pArg->dwRenameIntervalUnits);
                    dwFileSizeLimit = 0;
                    break;
                }
            } else {
                // filename is left as read from the registry
                dwSamplesUntilNewFile = 0;
                dwFileSizeLimit = 0;
            }
            llFileSizeLimit = dwFileSizeLimit;
            // open log file using this query
            dwLogType = pArg->dwLogType;
            pdhStatus = PdhOpenLog (
                szCurrentLogFile,
                PDH_LOG_WRITE_ACCESS |
                    PDH_LOG_CREATE_ALWAYS,
                &dwLogType,
                hQuery,
                0,
                NULL,
                &hLog);

            if (pdhStatus == ERROR_SUCCESS) {
                szStringArray[0] = pArg->szQueryName;
                szStringArray[1] = szCurrentLogFile;
                ReportEvent (hEventLog,
                    EVENTLOG_INFORMATION_TYPE,
                    0,
                    PERFLOG_LOGGING_QUERY,
                    NULL,
                    2,
                    0,
                    szStringArray,
                    NULL);
                // start sampling immediately
                dwDelay = 0;
                while ((lWaitStatus = WaitForSingleObject (pArg->hExitEvent, dwDelay)) == WAIT_TIMEOUT) {
                    // the event flag will be set when the sampling should exit. if
                    // the wait times out, then that means it's time to collect and
                    // log another sample of data.
                    // time the call to adjust the wait time

                    GetLocalFileTime (&st, &llStartTime);

                    pdhStatus = PdhUpdateLog (hLog, NULL);

                    if (pdhStatus == ERROR_SUCCESS) {
                        // see if it's time to rename the file
                        if (dwSamplesUntilNewFile) {
                            if (!--dwSamplesUntilNewFile) break;
                        } else if (llFileSizeLimit) {
                            // see if the file is too big
                            pdhStatus = PdhGetLogFileSize (hLog, &llFileSize);
                            if (pdhStatus == ERROR_SUCCESS) {
                                if (llFileSizeLimit <= llFileSize) break;
                            }
                        }
                        // compute new timeout value
                        if (dwSampleTime < dwSampleInterval) {
                            dwDelay = dwSampleInterval - dwSampleTime;
                        } else {
                            dwDelay = 0;
                        }
                    } else {
                        // unable to update the log so log event and exit
                        ReportEvent (hEventLog,
                            EVENTLOG_ERROR_TYPE,
                            0,
                            PERFLOG_UNABLE_UPDATE_LOG,
                            NULL,
                            0,
                            sizeof(DWORD),
                            NULL,
                            (LPVOID)&pdhStatus);

                        bRun = FALSE;
                        break;
                    }
                    GetLocalFileTime (&st, &llFinishTime);
                    // compute difference and convert to milliseconds
                    dwSampleTime = (DWORD)((llFinishTime - llStartTime) / 10000L);
                } // end while wait keeps timing out
                if (lWaitStatus == WAIT_OBJECT_0) {
                    // then the loop was terminated by the Exit event
                    // so clear the "run" flag to exit the loop & thread
                    bRun = FALSE;
                }

                // close log file, but keep query open
                PdhCloseLog (hLog, 0);

                if (pArg->szCmdFileName != NULL) {
                    DoCommandFile (pArg, szCurrentLogFile, bRun);
                }
            } else {
                // unable to open log file so log event log message
                szStringArray[0] = szCurrentLogFile;
                ReportEvent (hEventLog,
                    EVENTLOG_ERROR_TYPE,
                    0,
                    PERFLOG_UNABLE_OPEN_LOG_FILE,
                    NULL,
                    1,
                    sizeof(DWORD),
                    szStringArray,
                    (LPVOID)&pdhStatus);

                bRun = FALSE; // exit now
            }
        } // end while (bRun)
        PdhCloseQuery (hQuery);

        // update log serial number if necssary
        if (pArg->dwAutoNameFormat == OPD_NAME_NNNNNN) {
            lStatus = RegSetValueEx (
                pArg->hKeyQuery,
                TEXT("Log File Serial Number"),
                0L,
                REG_DWORD,
                (LPBYTE)&pArg->dwCurrentSerialNumber,
                sizeof(DWORD));
        }
    } else {
        // unable to open query so write event log message
        ReportEvent (hEventLog,
            EVENTLOG_ERROR_TYPE,
            0,
            PERFLOG_UNABLE_OPEN_LOG_QUERY,
            NULL,
            0,
            sizeof(DWORD),
            NULL,
            (LPVOID)&pdhStatus);

    }

    // free allocated buffers
    if (pArg->mszCounterList != NULL) {
        G_FREE(pArg->mszCounterList);
        pArg->mszCounterList = NULL;
    }

    if (pArg->szCmdFileName != NULL) {
        G_FREE(pArg->szCmdFileName);
        pArg->szCmdFileName = NULL;
    }

    return bRun;
}

DWORD
LoggingThreadProc (
    IN    LPVOID    lpThreadArg
)
{
    LPLOG_THREAD_DATA   pThreadData = (LPLOG_THREAD_DATA)lpThreadArg;
    DWORD               dwStatus = ERROR_SUCCESS;
    BOOL                bContinue = TRUE;

    if (pThreadData != NULL) {
        // read config from registry

        do {
            // read config from registry
            // expand counter paths as necessary
            // call Logging function
            bContinue = LoggingProc (pThreadData);
            // see if this thread was paused for reloading
            // or stopped to terminate
            if (pThreadData->bReloadNewConfig) {
                bContinue = TRUE;
            } // else  bContinue is always returned as FALSE
            // so that will terminate this loop
        } while (bContinue);
        dwStatus = ERROR_SUCCESS;
    } else {
        // unable to find data block so return
        dwStatus = ERROR_INVALID_PARAMETER;
    }

    return dwStatus;
}