static void loadUdpData(void) { PPERF_COUNTER_DEFINITION PerfCntr; DWORD c; if (UdpObj == NULL) return; PerfCntr = FirstCounter(UdpObj); for (c=0; c < UdpObj->NumCounters; c++) { switch (PerfCntr->CounterNameTitleIndex) { case DATAGRAMS_RECEIVED_PER_SEC_ID: udpCtrCache[DATAGRAMS_RECEIVED_PER_SEC_IDX] = *PerfCntr; break; case DATAGRAMS_NO_PORT_PER_SEC_ID: udpCtrCache[DATAGRAMS_NO_PORT_PER_SEC_IDX] = *PerfCntr; break; case DATAGRAMS_RECEIVED_ERRORS_ID: udpCtrCache[DATAGRAMS_RECEIVED_ERRORS_IDX] = *PerfCntr; break; case DATAGRAMS_SENT_PER_SEC_ID: udpCtrCache[DATAGRAMS_SENT_PER_SEC_IDX] = *PerfCntr; break; default: /* unknown counter. just skip it. */ break; } PerfCntr = NextCounter(PerfCntr); } #ifdef FLG_DEBUG for (c=0; c < MAX_UDP_CTRS_COLLECTED; c++) { if (udpCtrCache[c].CounterNameTitleIndex == 0) { fprintf(stderr, "DEBUG: bad udpCtr at idx=%d\n", c); fflush(stderr); } } #endif }
BOOL KProcessPerfMgr::_UpdateCounterInfo(PPERF_OBJECT_TYPE PerfObj) { PPERF_COUNTER_DEFINITION PerfCntr = NULL, CurCntr = NULL; PPERF_COUNTER_BLOCK PtrToCntr = NULL; BOOL bShouldBuildMap = FALSE; if (m_mapProcessData2CounterID.empty()) bShouldBuildMap = TRUE; memset(&m_ProcessCounters, 0, sizeof(m_ProcessCounters)); PerfCntr = FirstCounter( PerfObj ); for (DWORD i = 0; i < PerfObj->NumCounters; i++) { if (m_mapProcessData2CounterID.find(PerfCntr->CounterNameTitleIndex) != m_mapProcessData2CounterID.end()) { m_ProcessCounters[m_mapProcessData2CounterID[PerfCntr->CounterNameTitleIndex]] = PerfCntr; } else { if (bShouldBuildMap) { int nDataID = m_pNameMgr->GetDataIDByCounterID(PerfCntr->CounterNameTitleIndex); m_mapProcessData2CounterID[PerfCntr->CounterNameTitleIndex] = nDataID; m_ProcessCounters[nDataID] = PerfCntr; } } PerfCntr = NextCounter(PerfCntr); } return TRUE; }
LONGLONG CCpuUsage::CPerfCounters::GetCounterValue(PPERF_OBJECT_TYPE pPerfObj, DWORD dwCounterIndex, LPCTSTR pInstanceName) { PPERF_COUNTER_DEFINITION pPerfCntr = NULL; PPERF_INSTANCE_DEFINITION pPerfInst = NULL; PPERF_COUNTER_BLOCK pCounterBlock = NULL; // Get the first counter. pPerfCntr = FirstCounter( pPerfObj ); // Look for the index of '% Total processor time' for( DWORD j=0; j < pPerfObj->NumCounters; j++ ) { if (pPerfCntr->CounterNameTitleIndex == dwCounterIndex) break; // Get the next counter. pPerfCntr = NextCounter( pPerfCntr ); } if( pPerfObj->NumInstances == PERF_NO_INSTANCES ) { pCounterBlock = (PPERF_COUNTER_BLOCK) ((LPBYTE) pPerfObj + pPerfObj->DefinitionLength); } else { pPerfInst = FirstInstance( pPerfObj ); // Look for instance pInstanceName _bstr_t bstrInstance; _bstr_t bstrInputInstance = pInstanceName; for( int k=0; k < pPerfObj->NumInstances; k++ ) { bstrInstance = (wchar_t *)((PBYTE)pPerfInst + pPerfInst->NameOffset); if (!_stricmp((LPCTSTR)bstrInstance, (LPCTSTR)bstrInputInstance)) { pCounterBlock = (PPERF_COUNTER_BLOCK) ((LPBYTE) pPerfInst + pPerfInst->ByteLength); break; } // Get the next instance. pPerfInst = NextInstance( pPerfInst ); } } if (pCounterBlock) { LONGLONG *lnValue = NULL; lnValue = (LONGLONG*)((LPBYTE) pCounterBlock + pPerfCntr->CounterOffset); return *lnValue; } return -1; }
static void loadProcessorData(void) { DWORD c; PPERF_COUNTER_DEFINITION PerfCntr; if (ProcessorObj == NULL) return; #if 0 if (pidCtrOffset != -1) return; /* hunh? */ #endif PerfCntr = FirstCounter(ProcessorObj); #if 0 fprintf(stderr, "ProcessorObj->NumCounters=%d\n", ProcessorObj->NumCounters); fflush(stderr); #endif for (c=0; c < ProcessorObj->NumCounters; c++) { #if 0 fprintf(stderr, "PerfCntr->CounterNameTitleIndex=%d\n", PerfCntr->CounterNameTitleIndex); fflush(stderr); #endif switch (PerfCntr->CounterNameTitleIndex) { case TOTAL_PROCESSORTIME_ID: processorCtrCache[TOTAL_PROCESSORTIME_IDX] = *PerfCntr; break; case TOTAL_USERTIME_ID: processorCtrCache[TOTAL_USERTIME_IDX] = *PerfCntr; break; case TOTAL_PRIVILEGEDTIME_ID: processorCtrCache[TOTAL_PRIVILEGEDTIME_IDX] = *PerfCntr; break; case INTERRUPTTIME_ID: processorCtrCache[INTERRUPTTIME_IDX] = *PerfCntr; break; case INTERRUPTS_ID: processorCtrCache[INTERRUPTS_IDX] = *PerfCntr; break; default: /* unknown counter. just skip it. */ break; } PerfCntr = NextCounter(PerfCntr); } #ifdef FLG_DEBUG for (c=0; c < MAX_PROCESSOR_CTRS_COLLECTED; c++) { if (processorCtrCache[c].CounterNameTitleIndex == 0) { fprintf(stderr, "DEBUG: bad processorCtr at idx=%d\n", c); fflush(stderr); } } #endif }
static void loadObjectData(void) { PPERF_COUNTER_DEFINITION PerfCntr; DWORD c; if ( ObjectsObj == NULL ) { return; } PerfCntr = FirstCounter(ObjectsObj); for (c=0; c < ObjectsObj->NumCounters; c++) { switch (PerfCntr->CounterNameTitleIndex) { case PROCESSES_ID: objectsCtrCache[PROCESSES_IDX] = *PerfCntr; break; case THREADS_ID: objectsCtrCache[THREADS_IDX] = *PerfCntr; break; case EVENTS_ID: objectsCtrCache[EVENTS_IDX] = *PerfCntr; break; case SEMAPHORES_ID: objectsCtrCache[SEMAPHORES_IDX] = *PerfCntr; break; case MUTEXES_ID: objectsCtrCache[MUTEXES_IDX] = *PerfCntr; break; case SECTIONS_ID: objectsCtrCache[SECTIONS_IDX] = *PerfCntr; break; default: /* unknown counter. just skip it. */ break; } PerfCntr = NextCounter(PerfCntr); } #ifdef FLG_DEBUG for (c=0; c < MAX_OBJECTS_CTRS_COLLECTED; c++) { if (objectsCtrCache[c].CounterNameTitleIndex == 0) { fprintf(stderr, "DEBUG: bad objectsCtr at idx=%d\n", c); fflush(stderr); } } #endif }
static void loadNetworkData(void) { int32 i; unsigned int c; int32 val; char nausea[512]; PPERF_COUNTER_DEFINITION PerfCntr; PPERF_COUNTER_DEFINITION CurCntr; PPERF_INSTANCE_DEFINITION PerfInst; PPERF_COUNTER_BLOCK PerfCntrBlk; if (NetworkObj == NULL) { #ifdef FLG_DEBUG fprintf(stderr, "DEBUG: loadNetworkData, no NetworkObj!\n"); #endif return; } if (NetworkObj->NumInstances <= 0) { #ifdef FLG_DEBUG fprintf(stderr, "DEBUG: loadNetworkData, NetworkObj->NumInstances <= 0!\n"); #endif return; } /* We're collecting sums, so start by zeroing out */ netStats.loopbackPackets = 0; netStats.loopbackBytes = 0; netStats.packetsReceived = 0; netStats.bytesReceived = 0; netStats.packetsSent = 0; netStats.bytesSent = 0; PerfCntr = FirstCounter(NetworkObj); // retrieve all instances PerfInst = FirstInstance(NetworkObj); for (i = 0; i < NetworkObj->NumInstances; i ++) { boolean loopBack; wchar_t* unicodePtr = (wchar_t*)((PBYTE)PerfInst + PerfInst->NameOffset); #if 0 printf( "\n\tInstance %S: \n", unicodePtr); #endif sprintf(nausea, "%S", unicodePtr); loopBack = strcmp(nausea, "MS TCP Loopback interface") == 0; PerfCntrBlk = (PPERF_COUNTER_BLOCK)((PBYTE)PerfInst + PerfInst->ByteLength); CurCntr = PerfCntr; // retrieve all counters for (c = 0; c < NetworkObj->NumCounters; c ++) { #if 0 printf("\t\tCounter %ld: %s\n", CurCntr->CounterNameTitleIndex, lpNamesArray[CurCntr->CounterNameTitleIndex]); #endif switch (CurCntr->CounterNameTitleIndex) { case PACKETS_RECEIVED_ID: val = (int32)getLongValue(CurCntr, PerfCntrBlk); if (loopBack) netStats.loopbackPackets = val; else netStats.packetsReceived += val; break; case BYTES_RECEIVED_ID: val = (int32)getLongValue(CurCntr, PerfCntrBlk); if (loopBack) netStats.loopbackBytes = val; else netStats.bytesReceived += val; break; case PACKETS_SENT_ID: if (!loopBack) { val = (int32)getLongValue(CurCntr, PerfCntrBlk); netStats.packetsSent += val; } break; case BYTES_SENT_ID: if (!loopBack) { val = (int32)getLongValue(CurCntr, PerfCntrBlk); netStats.bytesSent += val; } break; default: /* unknown counter. just skip it. */ break; } CurCntr = NextCounter(CurCntr); } PerfInst = NextInstance(PerfCntrBlk); } }
static void loadMemoryData(void) { PPERF_COUNTER_DEFINITION PerfCntr; DWORD c; if (MemoryObj == NULL) return; PerfCntr = FirstCounter(MemoryObj); for (c=0; c < MemoryObj->NumCounters; c++) { switch (PerfCntr->CounterNameTitleIndex) { case AVAILABLEBYTES_ID: memoryCtrCache[AVAILABLEBYTES_IDX] = *PerfCntr; break; case COMMITTEDBYTES_ID: memoryCtrCache[COMMITTEDBYTES_IDX] = *PerfCntr; break; case COMMITLIMIT_ID: memoryCtrCache[COMMITLIMIT_IDX] = *PerfCntr; break; case TOTALPAGEFAULTS_ID: memoryCtrCache[TOTALPAGEFAULTS_IDX] = *PerfCntr; break; case WRITECOPIES_ID: memoryCtrCache[WRITECOPIES_IDX] = *PerfCntr; break; case TRANSITIONFAULTS_ID: memoryCtrCache[TRANSITIONFAULTS_IDX] = *PerfCntr; break; case CACHEFAULTS_ID: memoryCtrCache[CACHEFAULTS_IDX] = *PerfCntr; break; case DEMANDZEROFAULTS_ID: memoryCtrCache[DEMANDZEROFAULTS_IDX] = *PerfCntr; break; case PAGES_ID: memoryCtrCache[PAGES_IDX] = *PerfCntr; break; case PAGESINPUT_ID: memoryCtrCache[PAGESINPUT_IDX] = *PerfCntr; break; case PAGEREADS_ID: memoryCtrCache[PAGEREADS_IDX] = *PerfCntr; break; case PAGESOUTPUT_ID: memoryCtrCache[PAGESOUTPUT_IDX] = *PerfCntr; break; case PAGEWRITES_ID: memoryCtrCache[PAGEWRITES_IDX] = *PerfCntr; break; case TOTALPOOLPAGEDBYTES_ID: memoryCtrCache[TOTALPOOLPAGEDBYTES_IDX] = *PerfCntr; break; case TOTALPOOLNONPAGEDBYTES_ID: memoryCtrCache[TOTALPOOLNONPAGEDBYTES_IDX] = *PerfCntr; break; case POOLPAGEDALLOCS_ID: memoryCtrCache[POOLPAGEDALLOCS_IDX] = *PerfCntr; break; case POOLNONPAGEDALLOCS_ID: memoryCtrCache[POOLNONPAGEDALLOCS_IDX] = *PerfCntr; break; case FREESYSTEMPAGETABLEENTRIES_ID: memoryCtrCache[FREESYSTEMPAGETABLEENTRIES_IDX] = *PerfCntr; break; case CACHEBYTES_ID: memoryCtrCache[CACHEBYTES_IDX] = *PerfCntr; break; case CACHEBYTESPEAK_ID: memoryCtrCache[CACHEBYTESPEAK_IDX] = *PerfCntr; break; case POOLPAGEDRESIDENTBYTES_ID: memoryCtrCache[POOLPAGEDRESIDENTBYTES_IDX] = *PerfCntr; break; case SYSTEMCODETOTALBYTES_ID: memoryCtrCache[SYSTEMCODETOTALBYTES_IDX] = *PerfCntr; break; case SYSTEMCODERESIDENTBYTES_ID: memoryCtrCache[SYSTEMCODERESIDENTBYTES_IDX] = *PerfCntr; break; case SYSTEMDRIVERTOTALBYTES_ID: memoryCtrCache[SYSTEMDRIVERTOTALBYTES_IDX] = *PerfCntr; break; case SYSTEMDRIVERRESIDENTBYTES_ID: memoryCtrCache[SYSTEMDRIVERRESIDENTBYTES_IDX] = *PerfCntr; break; case SYSTEMCACHERESIDENTBYTES_ID: memoryCtrCache[SYSTEMCACHERESIDENTBYTES_IDX] = *PerfCntr; break; case COMMITTEDBYTESINUSE_ID: memoryCtrCache[COMMITTEDBYTESINUSE_IDX] = *PerfCntr; break; default: /* unknown counter. just skip it. */ break; } PerfCntr = NextCounter(PerfCntr); } #ifdef FLG_DEBUG for (c=0; c < MAX_MEMORY_CTRS_COLLECTED; c++) { if (memoryCtrCache[c].CounterNameTitleIndex == 0) { fprintf(stderr, "DEBUG: bad memoryCtr at idx=%d\n", c); fflush(stderr); } } #endif }
static void loadSystemData(void) { PPERF_COUNTER_DEFINITION PerfCntr; DWORD c; if (SystemObj == NULL) return; PerfCntr = FirstCounter(SystemObj); for (c=0; c < SystemObj->NumCounters; c++) { switch (PerfCntr->CounterNameTitleIndex) { case TOTALFILEREADOPS_ID: systemCtrCache[TOTALFILEREADOPS_IDX] = *PerfCntr; break; case TOTALFILEWRITEOPS_ID: systemCtrCache[TOTALFILEWRITEOPS_IDX] = *PerfCntr; break; case TOTALFILECONTROLOPS_ID: systemCtrCache[TOTALFILECONTROLOPS_IDX] = *PerfCntr; break; case TOTALFILEREADKBYTES_ID: systemCtrCache[TOTALFILEREADKBYTES_IDX] = *PerfCntr; break; case TOTALFILEWRITEKBYTES_ID: systemCtrCache[TOTALFILEWRITEKBYTES_IDX] = *PerfCntr; break; case TOTALFILECONTROLKBYTES_ID: systemCtrCache[TOTALFILECONTROLKBYTES_IDX] = *PerfCntr; break; case TOTALCONTEXTSWITCHES_ID: systemCtrCache[TOTALCONTEXTSWITCHES_IDX] = *PerfCntr; break; case TOTALSYSTEMCALLS_ID: systemCtrCache[TOTALSYSTEMCALLS_IDX] = *PerfCntr; break; case TOTALFILEDATAOPS_ID: systemCtrCache[TOTALFILEDATAOPS_IDX] = *PerfCntr; break; case PROCESSORQUEUELENGTH_ID: systemCtrCache[PROCESSORQUEUELENGTH_IDX] = *PerfCntr; break; case ALIGNMENTFIXUPS_ID: systemCtrCache[ALIGNMENTFIXUPS_IDX] = *PerfCntr; break; case EXCEPTIONDISPATCHES_ID: systemCtrCache[EXCEPTIONDISPATCHES_IDX] = *PerfCntr; break; case FLOATINGEMULATIONS_ID: systemCtrCache[FLOATINGEMULATIONS_IDX] = *PerfCntr; break; case REGISTRYQUOTAINUSE_ID: systemCtrCache[REGISTRYQUOTAINUSE_IDX] = *PerfCntr; break; default: /* unknown counter. just skip it. */ break; } PerfCntr = NextCounter(PerfCntr); } #ifdef FLG_DEBUG for (c=0; c < MAX_SYSTEM_CTRS_COLLECTED; c++) { if (systemCtrCache[c].CounterNameTitleIndex == 0) { fprintf(stderr, "DEBUG: bad systemCtr at idx=%d\n", c); fflush(stderr); } } #endif }
static void loadProcessData(void) { DWORD c; PPERF_COUNTER_DEFINITION PerfCntr; if (pidCtrOffset != -1) return; /* hunh? */ if (ProcessObj == NULL) return; PerfCntr = FirstCounter(ProcessObj); for (c=0; c < ProcessObj->NumCounters; c++) { switch (PerfCntr->CounterNameTitleIndex) { case PID_ID: pidCtrOffset = PerfCntr->CounterOffset; break; case PROCESS_PROCESSORTIME_ID: processCtrCache[PROCESS_PROCESSORTIME_IDX] = *PerfCntr; break; case PROCESS_USERTIME_ID: processCtrCache[PROCESS_USERTIME_IDX] = *PerfCntr; break; case PROCESS_PRIVILEGEDTIME_ID: processCtrCache[PROCESS_PRIVILEGEDTIME_IDX] = *PerfCntr; break; case VIRTUALBYTESPEAK_ID: processCtrCache[VIRTUALBYTESPEAK_IDX] = *PerfCntr; break; case VIRTUALBYTES_ID: processCtrCache[VIRTUALBYTES_IDX] = *PerfCntr; break; case PAGEFAULTS_ID: processCtrCache[PAGEFAULTS_IDX] = *PerfCntr; break; case WORKINGSETPEAK_ID: processCtrCache[WORKINGSETPEAK_IDX] = *PerfCntr; break; case WORKINGSET_ID: processCtrCache[WORKINGSET_IDX] = *PerfCntr; break; case PAGEFILEBYTESPEAK_ID: processCtrCache[PAGEFILEBYTESPEAK_IDX] = *PerfCntr; break; case PAGEFILEBYTES_ID: processCtrCache[PAGEFILEBYTES_IDX] = *PerfCntr; break; case PRIVATEBYTES_ID: processCtrCache[PRIVATEBYTES_IDX] = *PerfCntr; break; case THREADCOUNT_ID: processCtrCache[THREADCOUNT_IDX] = *PerfCntr; break; case PRIORITYBASE_ID: processCtrCache[PRIORITYBASE_IDX] = *PerfCntr; break; case POOLPAGEDBYTES_ID: processCtrCache[POOLPAGEDBYTES_IDX] = *PerfCntr; break; case POOLNONPAGEDBYTES_ID: processCtrCache[POOLNONPAGEDBYTES_IDX] = *PerfCntr; break; case HANDLECOUNT_ID: processCtrCache[HANDLECOUNT_IDX] = *PerfCntr; break; default: /* unknown counter. just skip it. */ break; } PerfCntr = NextCounter(PerfCntr); } /* for */ #ifdef FLG_DEBUG for (c=0; c < MAX_PROCESS_CTRS_COLLECTED; c++) { if (processCtrCache[c].CounterNameTitleIndex == 0) { fprintf(stderr, "DEBUG: bad processCtr at idx=%d\n", c); fflush(stderr); } } #endif }
void GetProcessID(LPCTSTR pProcessName, std::vector<DWORD>& SetOfPID) { PPERF_DATA_BLOCK pPerfData = NULL; PPERF_OBJECT_TYPE pPerfObj; PPERF_INSTANCE_DEFINITION pPerfInst; PPERF_COUNTER_DEFINITION pPerfCntr, pCurCntr; PPERF_COUNTER_BLOCK PtrToCntr; DWORD BufferSize = TOTALBYTES; DWORD i, j; LONG k; // Allocate the buffer for the performance data. pPerfData = (PPERF_DATA_BLOCK)malloc(BufferSize); wchar_t szKey[32]; swprintf_s(szKey, L"%d %d", PROCESS_OBJECT_INDEX, PROC_ID_COUNTER); LONG lRes; while ((lRes = RegQueryValueEx(HKEY_PERFORMANCE_DATA, szKey, NULL, NULL, (LPBYTE)pPerfData, &BufferSize)) == ERROR_MORE_DATA) { // Get a buffer that is big enough. BufferSize += BYTEINCREMENT; pPerfData = (PPERF_DATA_BLOCK)realloc(pPerfData, BufferSize); } // Get the first object type. pPerfObj = FirstObject(pPerfData); // Process all objects. for (i = 0; i < pPerfData->NumObjectTypes; i++) { if (pPerfObj->ObjectNameTitleIndex != PROCESS_OBJECT_INDEX) { pPerfObj = NextObject(pPerfObj); continue; } SetOfPID.clear(); // Get the first counter. pPerfCntr = FirstCounter(pPerfObj); // Get the first instance. pPerfInst = FirstInstance(pPerfObj); _bstr_t bstrProcessName, bstrInput; // Retrieve all instances. for (k = 0; k < pPerfObj->NumInstances; k++) { pCurCntr = pPerfCntr; bstrInput = pProcessName; bstrProcessName = (wchar_t *)((PBYTE)pPerfInst + pPerfInst->NameOffset); if (!_wcsicmp((LPCTSTR)bstrProcessName, (LPCTSTR)bstrInput)) { // Retrieve all counters. for (j = 0; j < pPerfObj->NumCounters; j++) { if (pCurCntr->CounterNameTitleIndex == PROC_ID_COUNTER) { PtrToCntr = CounterBlock(pPerfInst); DWORD *pdwValue = (DWORD*)((LPBYTE)PtrToCntr + pCurCntr->CounterOffset); SetOfPID.push_back(*pdwValue); break; } // Get the next counter. pCurCntr = NextCounter(pCurCntr); } } // Get the next instance. pPerfInst = NextInstance(pPerfInst); } } free(pPerfData); RegCloseKey(HKEY_PERFORMANCE_DATA); }
static PDH_STATUS PdhiExpandCounterPath ( IN LPCWSTR szWildCardPath, IN LPVOID pExpandedPathList, IN LPDWORD pcchPathListLength, IN BOOL bUnicode ) { PPERF_MACHINE pMachine; PPDHI_COUNTER_PATH pWildCounterPath = NULL; WCHAR szWorkBuffer[MAX_PATH]; WCHAR szCounterName[MAX_PATH]; WCHAR szInstanceName[MAX_PATH]; LPWSTR szEndOfObjectString; LPWSTR szInstanceString; LPWSTR szCounterString; LPVOID szNextUserString; PERF_OBJECT_TYPE *pObjectDef; PERF_OBJECT_TYPE *pParentObjectDef; PERF_COUNTER_DEFINITION *pCounterDef; PERF_INSTANCE_DEFINITION *pInstanceDef; PERF_INSTANCE_DEFINITION *pParentInstanceDef; DWORD dwBufferRemaining; DWORD dwSize; DWORD dwSizeReturned = 0; PDH_STATUS pdhStatus = ERROR_SUCCESS; DWORD dwCtrNdx, dwInstNdx; BOOL bMoreData = FALSE; // allocate buffers pWildCounterPath = G_ALLOC (GPTR, PDHI_COUNTER_PATH_BUFFER_SIZE); if (pWildCounterPath == NULL) { // unable to allocate memory so bail out pdhStatus = PDH_MEMORY_ALLOCATION_FAILURE; } else { __try { dwBufferRemaining = *pcchPathListLength; szNextUserString = pExpandedPathList; } __except (EXCEPTION_EXECUTE_HANDLER) { pdhStatus = PDH_INVALID_ARGUMENT; } } if (pdhStatus == ERROR_SUCCESS) { // Parse wild card Path dwSize = G_SIZE (pWildCounterPath); if (ParseFullPathNameW (szWildCardPath, &dwSize, pWildCounterPath)) { // get the machine referenced in the path pMachine = GetMachine (pWildCounterPath->szMachineName, 0); if (pMachine != NULL) { if (wcsncmp (cszDoubleBackSlash, szWildCardPath, 2) == 0) { // the caller wants the machine name in the path so // copy it to the work buffer lstrcpyW (szWorkBuffer, pWildCounterPath->szMachineName); } else { *szWorkBuffer = 0; } // append the object name (since wild card objects are not // currently supported. lstrcatW (szWorkBuffer, cszBackSlash); lstrcatW (szWorkBuffer, pWildCounterPath->szObjectName); szEndOfObjectString = &szWorkBuffer[lstrlenW(szWorkBuffer)]; // get object pointer (since objects are not wild) pObjectDef = GetObjectDefByName ( pMachine->pSystemPerfData, pMachine->dwLastPerfString, pMachine->szPerfStrings, pWildCounterPath->szObjectName); if (pObjectDef != NULL) { // for each counters and identify matches pCounterDef = FirstCounter (pObjectDef); for (dwCtrNdx = 0; dwCtrNdx < pObjectDef->NumCounters; dwCtrNdx++) { // for each counter check instances (if supported) // and keep matches if ((pCounterDef->CounterNameTitleIndex > 0) && (pCounterDef->CounterNameTitleIndex < pMachine->dwLastPerfString ) && (!((pCounterDef->CounterType & PERF_DISPLAY_NOSHOW) && // this is a hack because this type is not defined correctly (pCounterDef->CounterType != PERF_AVERAGE_BULK)))) { // look up name of each object & store size lstrcpyW (szCounterName, pMachine->szPerfStrings[pCounterDef->CounterNameTitleIndex]); if (WildStringMatchW(pWildCounterPath->szCounterName, szCounterName)) { // if this object has instances, then walk down // the instance list and save any matches if (pObjectDef->NumInstances != PERF_NO_INSTANCES) { // then walk instances to find matches pInstanceDef = FirstInstance (pObjectDef); if (pObjectDef->NumInstances > 0) { for (dwInstNdx = 0; dwInstNdx < (DWORD)pObjectDef->NumInstances; dwInstNdx++) { szInstanceString = szEndOfObjectString; if (pInstanceDef->ParentObjectTitleIndex > 0) { // then add in parent instance name pParentObjectDef = GetObjectDefByTitleIndex ( pMachine->pSystemPerfData, pInstanceDef->ParentObjectTitleIndex); if (pParentObjectDef != NULL) { pParentInstanceDef = GetInstance ( pParentObjectDef, pInstanceDef->ParentObjectInstance); if (pParentInstanceDef != NULL) { GetInstanceNameStr (pParentInstanceDef, szInstanceName, pObjectDef->CodePage); if (WildStringMatchW (pWildCounterPath->szParentName, szInstanceName)) { // add this string szInstanceString = szEndOfObjectString; lstrcpyW (szInstanceString, cszLeftParen); lstrcatW (szInstanceString, szInstanceName); lstrcatW (szInstanceString, cszSlash); } else { // get next instance and continue pInstanceDef = NextInstance(pInstanceDef); continue; } } else { // unable to locate parent instance // so cancel this one, then // get next instance and continue pInstanceDef = NextInstance(pInstanceDef); continue; } } else { // unable to locate parent object // so cancel this one, then // get next instance and continue pInstanceDef = NextInstance(pInstanceDef); continue; } } else { // no parent name so continue szInstanceString = szEndOfObjectString; lstrcpyW (szInstanceString, cszSlash); } GetInstanceNameStr (pInstanceDef, szInstanceName, pObjectDef->CodePage); // // BUGBUG: need to do something with indexes. // // if this instance name matches, then keep it if (WildStringMatchW (pWildCounterPath->szInstanceName, szInstanceName)) { lstrcatW (szInstanceString, szInstanceName); lstrcatW (szInstanceString, cszRightParenBackSlash); // now append this counter name lstrcatW (szInstanceString, szCounterName); // add it to the user's buffer if there's room dwSize = lstrlenW(szWorkBuffer) + 1; if (!bMoreData && (dwSize < dwBufferRemaining)) { if (bUnicode) { lstrcpyW ((LPWSTR)szNextUserString, szWorkBuffer); (LPBYTE)szNextUserString += dwSize * sizeof(WCHAR); } else { wcstombs ((LPSTR)szNextUserString, szWorkBuffer, dwSize); (LPBYTE)szNextUserString += dwSize * sizeof(CHAR); } dwSizeReturned += dwSize; dwBufferRemaining -= dwSize; } else { // they've run out of buffer so just update the size required bMoreData = TRUE; dwSizeReturned += dwSize; } } else { // they don't want this instance so skip it } pInstanceDef = NextInstance (pInstanceDef); } // end for each instance in object } else { // this object supports instances, // but doesn't currently have any // so do nothing. } } else { // this object does not use instances so copy this // counter to the caller's buffer. szCounterString = szEndOfObjectString; lstrcpyW (szCounterString, cszBackSlash); lstrcatW (szCounterString, szCounterName); dwSize = lstrlenW(szWorkBuffer) + 1; if (!bMoreData && (dwSize < dwBufferRemaining)) { if (bUnicode) { lstrcpyW ((LPWSTR)szNextUserString, szWorkBuffer); (LPBYTE)szNextUserString += dwSize * sizeof(WCHAR); } else { wcstombs ((LPSTR)szNextUserString, szWorkBuffer, dwSize); (LPBYTE)szNextUserString += dwSize * sizeof(CHAR); } dwSizeReturned += dwSize; dwBufferRemaining -= dwSize; } else { // they've run out of buffer so bail out of this loop bMoreData = TRUE; dwSizeReturned += dwSize; } } } else { // this counter doesn't match so skip it } } else { // this counter string is not available } pCounterDef = NextCounter(pCounterDef); } // end for each counter in this object if (bUnicode) { *(LPWSTR)szNextUserString = 0; // MSZ terminator } else { *(LPSTR)szNextUserString = 0; // MSZ terminator } *pcchPathListLength = dwSizeReturned; if (bMoreData) { pdhStatus = PDH_MORE_DATA; } else { pdhStatus = ERROR_SUCCESS; } } else { // unable to find object pdhStatus = PDH_INVALID_PATH; } } else { // unable to connect to machine. pdhStatus = PDH_CANNOT_CONNECT_MACHINE; } } else { // unable to read input path string pdhStatus = PDH_INVALID_PATH; } } if (pWildCounterPath != NULL) G_FREE (pWildCounterPath); return pdhStatus; }