/*++ 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 #include #include #include #include #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; }