![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to playback.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon|
Return to playback.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon |
1.1 root 1: //==========================================================================//
2: // Includes //
3: //==========================================================================//
4:
5:
6: #include "perfmon.h"
7: #include "playback.h" // external declarations for this module
8:
9: #include "bookmark.h" // for BookmarkAppend
10: #include "grafdata.h" // for ResetGraph
11: #include "perfdata.h" // for UpdateLinesForSystem
12: #include "perfmops.h" // for SystemTimeDateString
13: #include "log.h"
14: #include "pmemory.h" // for MemoryAllocate
15: #include "fileutil.h"
16: #include "utils.h"
17: #include "alert.h" // for ResetAlert
18: #include "report.h" // for ResetReport
19:
20: NTSTATUS AddNamesToArray (LPTSTR pNames,
21: DWORD dwLastID,
22: LPWSTR *lpCounterId) ;
23:
24:
25: void PlaybackAddCounterName (PLOGINDEX pIndex) ;
26:
27: //==========================================================================//
28: // Macros //
29: //==========================================================================//
30:
31:
32:
33: #define PointerSeek(pBase, lFileOffset) \
34: ((PVOID) ((PBYTE) pBase + lFileOffset))
35:
36:
37: //==========================================================================//
38: // Local Functions //
39: //==========================================================================//
40:
41:
42: PVOID PlaybackSeek (long lFileOffset)
43: { // PlaybackSeek
44: return (PointerSeek (PlaybackLog.pHeader, lFileOffset)) ;
45: } // PlaybackSeek
46:
47:
48: PLOGINDEXBLOCK FirstIndexBlock (PLOGHEADER pLogHeader)
49: {
50: return ((PLOGINDEXBLOCK) PointerSeek (pLogHeader, pLogHeader->iLength)) ;
51: }
52:
53:
54: PLOGINDEX IndexFromPosition (PLOGPOSITION pLogPosition)
55: {
56: return (&pLogPosition->pIndexBlock->aIndexes [pLogPosition->iIndex]) ;
57: }
58:
59:
60: PPERFDATA DataFromIndex (PLOGINDEX pLogIndex,
61: LPTSTR lpszSystemName)
62: {
63: PPERFDATA pPerfData;
64: TCHAR szLoggedComputerName[MAX_COMPUTERNAME_LENGTH + 3] ;
65: int iNumSystem ;
66:
67: // Note: NULL lpszSystemName means return first logged system name
68: // at the specified index.
69:
70: pPerfData = PlaybackSeek (pLogIndex->lDataOffset) ;
71:
72: for (iNumSystem = 0;
73: iNumSystem < pLogIndex->iSystemsLogged;
74: iNumSystem++)
75: {
76: if ( pPerfData &&
77: pPerfData->Signature[0] == (WCHAR)'P' &&
78: pPerfData->Signature[1] == (WCHAR)'E' &&
79: pPerfData->Signature[2] == (WCHAR)'R' &&
80: pPerfData->Signature[3] == (WCHAR)'F' )
81: {
82: GetPerfComputerName(pPerfData, szLoggedComputerName) ;
83: if (!lpszSystemName || strsamei(lpszSystemName, szLoggedComputerName))
84: {
85: return pPerfData ;
86: }
87: }
88: pPerfData = (PPERFDATA)((PBYTE) pPerfData +
89: pPerfData->TotalByteLength) ;
90: }
91: return NULL ;
92: }
93:
94:
95: PPERFDATA DataFromIndexPosition (PLOGPOSITION pLogPosition,
96: LPTSTR lpszSystemName)
97: {
98: PLOGINDEX pLogIndex ;
99: // long lDataFileOffset ;
100:
101: pLogIndex = IndexFromPosition (pLogPosition) ;
102: return (DataFromIndex (pLogIndex, lpszSystemName)) ;
103: }
104:
105:
106: BOOL NextLogPosition (IN OUT PLOGPOSITION pLogPosition)
107: {
108: PLOGINDEXBLOCK pIndexBlock ;
109:
110: if (pLogPosition->pIndexBlock->iNumIndexes == 0)
111: {
112: // no data in this index block. This is most likely
113: // a corrupted log file caused by system failure...
114: return (FALSE) ;
115: }
116:
117: if (pLogPosition->iIndex == pLogPosition->pIndexBlock->iNumIndexes - 1)
118: {
119: if (pLogPosition->pIndexBlock->lNextBlockOffset)
120: {
121: pIndexBlock =
122: PlaybackSeek (pLogPosition->pIndexBlock->lNextBlockOffset) ;
123:
124: if (pIndexBlock->iNumIndexes == 0)
125: {
126: // no data in the next index block. This is most likely
127: // a corrupted log file caused by system failure...
128: return (FALSE) ;
129: }
130: else
131: {
132: pLogPosition->pIndexBlock = pIndexBlock ;
133: pLogPosition->iIndex = 0 ;
134: return (TRUE) ;
135: }
136: }
137: else
138: return (FALSE) ;
139: }
140: else
141: {
142: pLogPosition->iIndex++ ;
143: return (TRUE) ;
144: }
145: }
146:
147:
148: BOOL NextIndexPosition (IN OUT PLOGPOSITION pLogPosition,
149: BOOL bCheckForNonDataIndexes)
150: /*
151: Effect: Set pLogPosition to the next log position from
152: the current position of pLogPosition if there is one.
153:
154: Returns: Whether there was a next log position.
155: */
156: { // NextIndexPosition
157: LOGPOSITION LP ;
158: PLOGINDEX pIndex ;
159: PBOOKMARK pBookmarkDisk, pBookmark ;
160: // LONG lFilePosition ;
161:
162: pIndex = IndexFromPosition (pLogPosition) ;
163:
164: LP = *pLogPosition ;
165: pBookmark = NULL ;
166:
167: while (TRUE)
168: { // while
169: if (!NextLogPosition (&LP))
170: return (FALSE) ;
171: pIndex = IndexFromPosition (&LP) ;
172:
173: if (pIndex && bCheckForNonDataIndexes && IsCounterNameIndex (pIndex))
174: {
175: PlaybackAddCounterName (pIndex) ;
176: }
177:
178: if (pIndex && bCheckForNonDataIndexes && IsBookmarkIndex (pIndex))
179: {
180: if (pBookmark)
181: {
182: // this is the case when several bookmarks are
183: // found before any data index...
184: pBookmark->iTic = PlaybackLog.iTotalTics ;
185: BookmarkAppend (&PlaybackLog.pBookmarkFirst, pBookmark) ;
186: }
187:
188: pBookmarkDisk = PlaybackSeek (pIndex->lDataOffset) ;
189: pBookmark = MemoryAllocate (sizeof (BOOKMARK)) ;
190: *pBookmark = *pBookmarkDisk;
191: pBookmark->pBookmarkNext = NULL ;
192: }
193:
194: if (pIndex && IsDataIndex (pIndex))
195: {
196: LP.iPosition++ ;
197: *pLogPosition = LP ;
198: if (pBookmark)
199: {
200: pBookmark->iTic = PlaybackLog.iTotalTics ;
201: BookmarkAppend (&PlaybackLog.pBookmarkFirst, pBookmark) ;
202: }
203: return (TRUE) ;
204: }
205: } // while
206: } // NextIndexPosition
207:
208:
209: BOOL NextReLogIndexPosition (IN OUT PLOGPOSITION pLogPosition)
210: /*
211: Effect: Set pLogPosition to the next log position from
212: the current position of pLogPosition if there is one.
213: Will return bookmarks, counternames, or data.
214:
215: Returns: Whether there was a next relog position.
216: */
217: { // NextReLogIndexPosition
218: LOGPOSITION LP ;
219: PLOGINDEX pIndex ;
220: // LONG lFilePosition ;
221:
222: pIndex = IndexFromPosition (pLogPosition) ;
223:
224: LP = *pLogPosition ;
225:
226: if (!NextLogPosition (&LP))
227: return (FALSE) ;
228: pIndex = IndexFromPosition (&LP) ;
229:
230: if (pIndex && IsDataIndex (pIndex))
231: {
232: LP.iPosition++ ;
233: }
234: *pLogPosition = LP ;
235: return (TRUE) ;
236: } // NextReLogIndexPosition
237:
238:
239:
240:
241:
242: //==========================================================================//
243: // Exported Functions //
244: //==========================================================================//
245:
246:
247: void PlaybackInitializeInstance (void)
248: { // PlaybackInitializeInstance
249: PlaybackLog.iStatus = iPMStatusClosed ;
250: PlaybackLog.hFile = NULL ;
251:
252: PlaybackLog.szFilePath = MemoryAllocate (FilePathLen * sizeof (TCHAR)) ;
253: PlaybackLog.szFileTitle = MemoryAllocate (FilePathLen * sizeof (TCHAR)) ;
254: lstrcpy (PlaybackLog.szFilePath, szDefaultLogFileName) ;
255: lstrcpy (PlaybackLog.szFileTitle, szDefaultLogFileName) ;
256: } // PlaybackInitializeInstance
257:
258:
259: INT OpenPlayback (LPTSTR lpszFilePath, LPTSTR lpszFileTitle)
260: { // OpenPlayback
261: BOOL bFirstTime = TRUE ;
262:
263: lstrcpy (PlaybackLog.szFilePath, lpszFilePath) ;
264: lstrcpy (PlaybackLog.szFileTitle, lpszFileTitle) ;
265: PlaybackLog.hFile = FileHandleOpen (lpszFilePath) ;
266: if (!PlaybackLog.hFile || PlaybackLog.hFile == INVALID_HANDLE_VALUE)
267: {
268: return (ERR_CANT_OPEN) ;
269: }
270:
271: PlaybackLog.pHeader = (PLOGHEADER) FileMap (PlaybackLog.hFile,
272: &PlaybackLog.hMapHandle) ;
273:
274: if (!PlaybackLog.pHeader)
275: {
276: if (PlaybackLog.hMapHandle)
277: {
278: CloseHandle (PlaybackLog.hMapHandle) ;
279: }
280:
281: CloseHandle (PlaybackLog.hFile) ;
282: return (ERR_CANT_OPEN) ;
283: }
284:
285: if (!strsame (PlaybackLog.pHeader->szSignature, LogFileSignature))
286: {
287: FileUnMap((LPVOID)PlaybackLog.pHeader, PlaybackLog.hMapHandle) ;
288: CloseHandle (PlaybackLog.hFile) ;
289: return (ERR_BAD_LOG_FILE) ;
290: }
291:
292: PlaybackLog.BeginIndexPos.pIndexBlock = FirstIndexBlock (PlaybackLog.pHeader) ;
293: PlaybackLog.BeginIndexPos.iIndex = 0 ;
294: PlaybackLog.BeginIndexPos.iPosition = 0 ;
295: PlaybackLog.pBookmarkFirst = NULL ;
296:
297: PlaybackLog.iTotalTics = 1 ;
298: PlaybackLog.EndIndexPos = PlaybackLog.BeginIndexPos ;
299: while (NextIndexPosition (&PlaybackLog.EndIndexPos, TRUE))
300: {
301: if (bFirstTime)
302: {
303: // set the begin index to the first data index
304: bFirstTime = FALSE ;
305: PlaybackLog.BeginIndexPos.iIndex =
306: PlaybackLog.EndIndexPos.iIndex ;
307: }
308: else
309: {
310: PlaybackLog.iTotalTics++ ;
311: }
312: }
313:
314: if (PlaybackLog.iTotalTics == 1 )
315: {
316: // no data inside the log file. It must be a corrupted
317: // log file
318: FileUnMap((LPVOID)PlaybackLog.pHeader, PlaybackLog.hMapHandle) ;
319: CloseHandle (PlaybackLog.hFile) ;
320: return (ERR_CORRUPT_LOG) ;
321: }
322:
323: // PlaybackLog.StartIndexPos = PlaybackLog.BeginIndexPos ;
324:
325: // getthe first data index
326: if (!LogPositionN (1, &(PlaybackLog.StartIndexPos)))
327: {
328: PlaybackLog.StartIndexPos = PlaybackLog.BeginIndexPos ;
329: }
330:
331: PlaybackLog.StopIndexPos = PlaybackLog.EndIndexPos ;
332: PlaybackLog.StopIndexPos.iPosition =
333: min (PlaybackLog.StopIndexPos.iPosition,
334: PlaybackLog.iTotalTics - 1 ) ;
335:
336:
337: PlaybackLog.iSelectedTics = PlaybackLog.iTotalTics ;
338:
339: PlaybackLog.iStatus = iPMStatusPlaying ;
340: return (0) ;
341: } // OpenPlayback
342:
343:
344: void CloseInputLog (HWND hWndParent)
345: { // CloseInputLog
346: PBOOKMARK pBookmark, pNextBookmark ;
347: BOOL retCode, retCode1 ;
348: PLOGCOUNTERNAME pLogCounterName, pNextCounterName ;
349:
350: UNREFERENCED_PARAMETER (hWndParent) ;
351:
352: // free the bookmark list
353: for (pBookmark = PlaybackLog.pBookmarkFirst ;
354: pBookmark ;
355: pBookmark = pNextBookmark )
356: {
357: // save next bookmark and free current bookmark
358: pNextBookmark = pBookmark->pBookmarkNext ;
359: MemoryFree (pBookmark) ;
360: }
361: PlaybackLog.pBookmarkFirst = NULL ;
362:
363: // free all counter names stuff
364: if (PlaybackLog.pBaseCounterNames)
365: {
366: MemoryFree (PlaybackLog.pBaseCounterNames) ;
367: }
368: PlaybackLog.pBaseCounterNames = NULL ;
369: PlaybackLog.lBaseCounterNameSize = 0 ;
370: PlaybackLog.lBaseCounterNameOffset = 0 ;
371:
372: for (pLogCounterName = PlaybackLog.pLogCounterNameFirst ;
373: pLogCounterName ;
374: pLogCounterName = pNextCounterName)
375: {
376: pNextCounterName = pLogCounterName->pCounterNameNext ;
377: MemoryFree (pLogCounterName->pRemainNames) ;
378: MemoryFree (pLogCounterName) ;
379: }
380:
381: PlaybackLog.pLogCounterNameFirst = NULL ;
382:
383: retCode1 = FileUnMap((LPVOID)PlaybackLog.pHeader, PlaybackLog.hMapHandle) ;
384: retCode = CloseHandle (PlaybackLog.hFile) ;
385: PlaybackLog.iStatus = iPMStatusClosed ;
386:
387: ResetGraphView (hWndGraph) ;
388: ResetAlertView (hWndAlert) ;
389: ResetLogView (hWndLog) ;
390: ResetReportView (hWndReport) ;
391: }
392:
393:
394:
395: BOOL LogPositionN (int iIndex, PLOGPOSITION pLP)
396: { // LogPositionN
397: LOGPOSITION LP ;
398: int i ;
399:
400: LP = PlaybackLog.BeginIndexPos ;
401: for (i = 0 ;
402: i < iIndex ;
403: i++)
404: {
405: if (!NextIndexPosition (&LP, FALSE))
406: return (FALSE) ;
407: }
408:
409: *pLP = LP ;
410: return (TRUE) ;
411: } // LogPositionN
412:
413:
414: PLOGINDEX PlaybackIndexN (int iIndex)
415: {
416: LOGPOSITION LP ;
417: int i ;
418:
419: LP = PlaybackLog.BeginIndexPos ;
420: for (i = 0 ;
421: i < iIndex ;
422: i++)
423: {
424: if (!NextIndexPosition (&LP, FALSE))
425: return (NULL) ;
426: }
427:
428: return (IndexFromPosition (&LP)) ;
429: }
430:
431:
432: BOOL PlaybackLines (PPERFSYSTEM pSystemFirst,
433: PLINE pLineFirst,
434: int iLogTic)
435: { // PlaybackLines
436:
437: PLOGINDEX pLogIndex ;
438: PPERFDATA pPerfData ;
439: PPERFSYSTEM pSystem ;
440: BOOL bAnyFound ;
441:
442: pLogIndex = PlaybackIndexN (iLogTic) ;
443: if (!pLogIndex)
444: return (FALSE) ;
445:
446: bAnyFound = FALSE ;
447: for (pSystem = pSystemFirst ;
448: pSystem ;
449: pSystem = pSystem->pSystemNext)
450: { // for
451: pPerfData = DataFromIndex (pLogIndex, pSystem->sysName) ;
452: if (pPerfData)
453: {
454: UpdateLinesForSystem (pSystem->sysName,
455: pPerfData,
456: pLineFirst) ;
457: bAnyFound = TRUE ;
458: }
459: else
460: {
461: FailedLinesForSystem (pSystem->sysName,
462: pPerfData,
463: pLineFirst) ;
464: }
465: }
466: return (bAnyFound) ;
467: } // PlaybackLines
468:
469:
470:
471:
472: PPERFDATA LogDataFromPosition (PPERFSYSTEM pSystem,
473: PLOGPOSITION pLogPosition)
474: { // LogDataFromPosition
475: PLOGINDEX pLogIndex ;
476:
477:
478: if (!pLogPosition)
479: return (NULL) ;
480:
481: pLogIndex = IndexFromPosition (pLogPosition) ;
482: if (!pLogIndex)
483: return (NULL) ;
484:
485: return (DataFromIndex (pLogIndex, pSystem->sysName)) ;
486: } // LogDataFromPosition
487:
488:
489:
490: BOOL LogPositionSystemTime (PLOGPOSITION pLP, SYSTEMTIME *pSystemTime)
491: /*
492: Effect: Given a logposition, get the index entry for that position
493: and return the system time stored therein.
494: */
495: { // LogPositionSystemTime
496: PLOGINDEX pLogIndex ;
497:
498: pLogIndex = IndexFromPosition (pLP) ;
499: if (!pLogIndex)
500: return (FALSE) ;
501:
502: *pSystemTime = pLogIndex->SystemTime ;
503: } // LogPositionSystemTime
504:
505:
506: int LogPositionIntervalSeconds (PLOGPOSITION pLPStart,
507: PLOGPOSITION pLPStop)
508: /*
509: Effect: Return the time difference (in seconds) between the
510: system times of the two specified log positions.
511: */
512: { // LogPositionIntervalSeconds
513: SYSTEMTIME SystemTimeStart ;
514: SYSTEMTIME SystemTimeStop ;
515:
516:
517: if (LogPositionSystemTime (pLPStart, &SystemTimeStart) &&
518: LogPositionSystemTime (pLPStop, &SystemTimeStop))
519: return (SystemTimeDifference (&SystemTimeStart, &SystemTimeStop)) ;
520: else
521: return (0) ;
522: } // LogPositionIntervalSeconds
523:
524:
525:
526: int PlaybackSelectedSeconds (void)
527: { // PlaybackSelectedSeconds
528: return (LogPositionIntervalSeconds (&PlaybackLog.StartIndexPos,
529: &PlaybackLog.StopIndexPos)) ;
530: } // PlaybackSelectedSeconds
531:
532: void BuildLogComputerList (HWND hDlg, int DlgID)
533: {
534: PPERFDATA pPerfData;
535: int iNumSystem ;
536: HWND hListBox = GetDlgItem (hDlg, DlgID) ;
537: PLOGINDEX pLogIndex ;
538: TCHAR szLoggedComputerName[MAX_COMPUTERNAME_LENGTH + 3] ;
539:
540: pLogIndex = IndexFromPosition (&(PlaybackLog.StartIndexPos)) ;
541: pPerfData = PlaybackSeek (pLogIndex->lDataOffset) ;
542:
543: for (iNumSystem = 0;
544: iNumSystem < pLogIndex->iSystemsLogged;
545: iNumSystem++)
546: {
547: if ( pPerfData &&
548: pPerfData->Signature[0] == (WCHAR)'P' &&
549: pPerfData->Signature[1] == (WCHAR)'E' &&
550: pPerfData->Signature[2] == (WCHAR)'R' &&
551: pPerfData->Signature[3] == (WCHAR)'F' )
552: {
553: GetPerfComputerName(pPerfData, szLoggedComputerName) ;
554: LBAdd (hListBox, szLoggedComputerName) ;
555: }
556: pPerfData = (PPERFDATA)((PBYTE) pPerfData +
557: pPerfData->TotalByteLength) ;
558: }
559: } // BuildLogComputerList
560:
561: void PlaybackAddCounterName (PLOGINDEX pIndex)
562: {
563: PLOGCOUNTERNAME pLogCounterName, pListCounterName ;
564: PLOGFILECOUNTERNAME pDiskCounterName ;
565: PVOID pCounterData ;
566: BOOL bExist = FALSE ;
567:
568: pDiskCounterName = PlaybackSeek (pIndex->lDataOffset) ;
569:
570: // check we have a record for this system
571: for (pListCounterName = PlaybackLog.pLogCounterNameFirst ;
572: pListCounterName ;
573: pListCounterName = pListCounterName->pCounterNameNext)
574: {
575: if (strsamei(pDiskCounterName->szComputer,
576: pListCounterName->CounterName.szComputer))
577: {
578: // found!
579: pLogCounterName = pListCounterName ;
580: bExist = TRUE ;
581: break ;
582: }
583: }
584:
585: if (!bExist)
586: {
587: // new counter name record
588: if (!(pLogCounterName = MemoryAllocate (sizeof(LOGCOUNTERNAME))))
589: {
590: return ;
591: }
592: }
593: else
594: {
595: // free old memory in previous counter name record.
596: if (pLogCounterName->pRemainNames)
597: {
598: MemoryFree (pLogCounterName->pRemainNames) ;
599: }
600: pLogCounterName->pRemainNames = NULL ;
601: }
602:
603: pLogCounterName->CounterName = *pDiskCounterName ;
604:
605: if (pDiskCounterName->lBaseCounterNameOffset == 0)
606: {
607: // this is the base counter names,
608: // get the master copy of the counter names
609:
610: if (!(pCounterData =
611: MemoryAllocate (pDiskCounterName->lUnmatchCounterNames)))
612: {
613: MemoryFree (pLogCounterName) ;
614: return ;
615: }
616:
617: // free the old one if it exists.
618: if (PlaybackLog.pBaseCounterNames)
619: {
620: MemoryFree (PlaybackLog.pBaseCounterNames) ;
621: }
622:
623: PlaybackLog.pBaseCounterNames = pCounterData ;
624:
625: pCounterData =
626: PlaybackSeek (pDiskCounterName->lCurrentCounterNameOffset) ;
627:
628: memcpy (PlaybackLog.pBaseCounterNames,
629: pCounterData,
630: pDiskCounterName->lUnmatchCounterNames) ;
631:
632: PlaybackLog.lBaseCounterNameSize =
633: pDiskCounterName->lUnmatchCounterNames ;
634:
635: PlaybackLog.lBaseCounterNameOffset =
636: pDiskCounterName->lBaseCounterNameOffset ;
637: }
638: else if (pDiskCounterName->lUnmatchCounterNames)
639: {
640: // this is not a based system and it has extra counter names
641: // allocate a buffer to hold them
642: pLogCounterName->pRemainNames =
643: MemoryAllocate (pDiskCounterName->lUnmatchCounterNames) ;
644:
645: if (pLogCounterName->pRemainNames)
646: {
647: pCounterData =
648: PlaybackSeek (pDiskCounterName->lCurrentCounterNameOffset) ;
649:
650: memcpy(pLogCounterName->pRemainNames,
651: pCounterData,
652: pDiskCounterName->lUnmatchCounterNames) ;
653: }
654: }
655:
656: if (!bExist)
657: {
658: // now add the new counter name record to the linked list
659: if (!PlaybackLog.pLogCounterNameFirst)
660: {
661: PlaybackLog.pLogCounterNameFirst = pLogCounterName ;
662: }
663: else
664: {
665: for (pListCounterName = PlaybackLog.pLogCounterNameFirst ;
666: pListCounterName->pCounterNameNext ;
667: pListCounterName = pListCounterName->pCounterNameNext)
668: {
669: // do nothing until we get to the end of the list
670: ;
671: }
672: pListCounterName->pCounterNameNext = pLogCounterName ;
673: }
674: }
675:
676: } // PlaybackAddCounterName
677:
678:
679: LPWSTR *LogBuildNameTable (PPERFSYSTEM pSysInfo)
680: {
681:
682: DWORD dwArraySize ;
683: PLOGCOUNTERNAME pCounterName ;
684: LPWSTR *lpCounterId = NULL ;
685: LPWSTR lpCounterNames ;
686: NTSTATUS Status ;
687:
688: for (pCounterName = PlaybackLog.pLogCounterNameFirst ;
689: pCounterName ;
690: pCounterName = pCounterName->pCounterNameNext)
691: {
692: if (strsamei (pSysInfo->sysName, pCounterName->CounterName.szComputer))
693: {
694: // found the right system
695: break ;
696: }
697: }
698: if (!pCounterName)
699: {
700: goto ERROR_EXIT ;
701: }
702:
703: dwArraySize = (pCounterName->CounterName.dwLastCounterId + 1)
704: * sizeof (LPWSTR) ;
705:
706: lpCounterId = MemoryAllocate (dwArraySize +
707: pCounterName->CounterName.lMatchLength +
708: pCounterName->CounterName.lUnmatchCounterNames ) ;
709:
710: if (!lpCounterId)
711: {
712: goto ERROR_EXIT ;
713: }
714:
715: // initialize pointers into buffer
716:
717: lpCounterNames = (LPWSTR)((LPBYTE)lpCounterId + dwArraySize);
718: if (pCounterName->CounterName.lBaseCounterNameOffset == 0)
719: {
720: // this is the base system
721: memcpy(lpCounterNames,
722: PlaybackLog.pBaseCounterNames,
723: PlaybackLog.lBaseCounterNameSize) ;
724: }
725: else
726: {
727: // copy the matched portion from the base system
728: memcpy(lpCounterNames,
729: PlaybackLog.pBaseCounterNames,
730: pCounterName->CounterName.lMatchLength) ;
731:
732: // copy the unmatched portion
733: if (pCounterName->CounterName.lUnmatchCounterNames)
734: {
735: memcpy(((PBYTE)lpCounterNames +
736: pCounterName->CounterName.lMatchLength),
737: pCounterName->pRemainNames,
738: pCounterName->CounterName.lUnmatchCounterNames) ;
739: }
740: }
741:
742: Status = AddNamesToArray (lpCounterNames,
743: pCounterName->CounterName.dwLastCounterId,
744: lpCounterId) ;
745:
746: if (Status != ERROR_SUCCESS)
747: {
748: goto ERROR_EXIT ;
749: }
750:
751: pSysInfo->CounterInfo.dwLastId =
752: pCounterName->CounterName.dwLastCounterId ;
753: pSysInfo->CounterInfo.dwLangId =
754: pCounterName->CounterName.dwLangId ;
755: pSysInfo->CounterInfo.dwHelpSize = 0 ;
756: pSysInfo->CounterInfo.dwCounterSize =
757: pCounterName->CounterName.lMatchLength +
758: pCounterName->CounterName.lUnmatchCounterNames ;
759:
760: return (lpCounterId) ;
761:
762: ERROR_EXIT:
763: if (lpCounterId)
764: {
765: MemoryFree (lpCounterId) ;
766: }
767: return (NULL) ;
768: } // LogBuildNameTable
769:
770:
771:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.