![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to line.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 line.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / perfmon |
1.1 ! root 1: ! 2: ! 3: //==========================================================================// ! 4: // Includes // ! 5: //==========================================================================// ! 6: ! 7: ! 8: #include "perfmon.h" // included by all source files ! 9: #include "line.h" // external declarations for this file ! 10: //#include <tchar.h> // for _tcsncpy ! 11: ! 12: #include "fileutil.h" // for FileRead, FileWrite ! 13: #include "pmemory.h" // for MemoryXXX (mallloc-type) routines ! 14: #include "perfdata.h" // for UpdateSystemData, et al ! 15: #include "perfmops.h" // for InsertLine ! 16: #include "system.h" // for SystemAdd ! 17: #include "utils.h" ! 18: #include "playback.h" // for PlayingBackLog ! 19: #include "counters.h" // CounterEntry ! 20: ! 21: #include <string.h> // for strncpy ! 22: #ifdef UNICODE ! 23: #define _tcsncpy wcsncpy ! 24: #else ! 25: #define _tcsncpy strncpy ! 26: #endif ! 27: ! 28: TCHAR LOCAL_SYS_CODE_NAME[] = TEXT("....") ; ! 29: #define sizeofCodeName sizeof(LOCAL_SYS_CODE_NAME) / sizeof(TCHAR) - 1 ! 30: ! 31: // Local Function prototype ! 32: PLINE ReadLine (PPERFSYSTEM *ppSystem, ! 33: PPPERFSYSTEM ppSystemFirst, ! 34: PPERFDATA *ppPerfData, ! 35: HANDLE hFile, ! 36: int LineType, ! 37: PDISKLINE *ppDiskLine, ! 38: DWORD *pSizeofDiskLine) ; ! 39: ! 40: ! 41: ! 42: //==========================================================================// ! 43: // Exported Functions // ! 44: //==========================================================================// ! 45: ! 46: ! 47: PLINE LineAllocate (void) ! 48: /* ! 49: Effect: Allocate and initialize a Line data structure. Lines ! 50: are used as the primary elements of both charts and ! 51: alerts. ! 52: ! 53: Establish any representation invariants for the Line ! 54: type. ! 55: ! 56: Also alllocate another structure, an array of data ! 57: elements, iNumDataValues long. ! 58: */ ! 59: { // LineAllocate ! 60: PLINE pLine ; ! 61: ! 62: pLine = MemoryAllocate (sizeof (LINESTRUCT)) ; ! 63: ! 64: if (pLine) ! 65: { ! 66: // don't need to zero these again since MemoryAllocate is using ! 67: // GMEM_ZEROPOINT ! 68: // pLine->pLineNext = NULL ; ! 69: // pLine->pLineCounterNext = NULL ; ! 70: ! 71: // do want to do this since (FLOAT)0.0 is not 0 ! 72: pLine->lnMinValue = ! 73: pLine->lnMaxValue = ! 74: pLine->lnAveValue = (FLOAT) 0.0 ; ! 75: ! 76: if (PlayingBackLog()) ! 77: { ! 78: pLine->bFirstTime = FALSE ; ! 79: } ! 80: else ! 81: { ! 82: // pLine->bFirstTime = TRUE ; ! 83: // we want to take 2 samples before plotting the first data ! 84: pLine->bFirstTime = 2 ; ! 85: } ! 86: } // if ! 87: ! 88: return (pLine) ; ! 89: } // LineAllocate ! 90: ! 91: ! 92: void LineFree (PLINE pLine) ! 93: { // LineFree ! 94: // free any memory allocated by this line ! 95: if (pLine->lnSystemName) ! 96: MemoryFree (pLine->lnSystemName) ; ! 97: ! 98: if (pLine->lnObjectName) ! 99: MemoryFree (pLine->lnObjectName) ; ! 100: ! 101: if (pLine->lnCounterName) ! 102: MemoryFree (pLine->lnCounterName) ; ! 103: ! 104: if (pLine->lnInstanceName) ! 105: MemoryFree (pLine->lnInstanceName) ; ! 106: ! 107: if (pLine->lnParentObjName) ! 108: MemoryFree (pLine->lnParentObjName) ; ! 109: ! 110: if (pLine->lnPINName) ! 111: MemoryFree (pLine->lnPINName) ; ! 112: ! 113: if (pLine->lpszAlertProgram) ! 114: MemoryFree (pLine->lpszAlertProgram) ; ! 115: ! 116: if (pLine->hPen) ! 117: DeletePen(pLine->hPen); ! 118: ! 119: if (pLine->hBrush) ! 120: DeletePen(pLine->hBrush); ! 121: ! 122: if (pLine->lnValues) ! 123: MemoryFree (pLine->lnValues) ; ! 124: ! 125: if (pLine->aiLogIndexes) ! 126: MemoryFree (pLine->aiLogIndexes) ; ! 127: ! 128: MemoryFree (pLine) ; ! 129: } // LineFree ! 130: ! 131: ! 132: ! 133: void LineAppend (PPLINE ppLineFirst, ! 134: PLINE pLineNew) ! 135: { ! 136: PLINE pLine ; ! 137: ! 138: if (!*ppLineFirst) ! 139: *ppLineFirst = pLineNew ; ! 140: else ! 141: { // else ! 142: for (pLine = *ppLineFirst ; ! 143: pLine->pLineNext ; ! 144: pLine = pLine->pLineNext) ! 145: /* nothing */ ; ! 146: pLine->pLineNext = pLineNew ; ! 147: } // else ! 148: } ! 149: ! 150: ! 151: ! 152: BOOL LineRemove (PPLINE ppLineFirst, ! 153: PLINE pLineRemove) ! 154: { ! 155: PLINE pLine ; ! 156: ! 157: if (*ppLineFirst == pLineRemove) ! 158: { ! 159: *ppLineFirst = (*ppLineFirst)->pLineNext ; ! 160: return (TRUE) ; ! 161: } ! 162: ! 163: for (pLine = *ppLineFirst ; ! 164: pLine->pLineNext ; ! 165: pLine = pLine->pLineNext) ! 166: { // for ! 167: if (pLine->pLineNext == pLineRemove) ! 168: { ! 169: pLine->pLineNext = pLineRemove->pLineNext ; ! 170: return (TRUE) ; ! 171: } // if ! 172: } // for ! 173: ! 174: return (FALSE) ; ! 175: } // LineRemove ! 176: ! 177: ! 178: ! 179: int NumLines (PLINE pLineFirst) ! 180: { // NumLines ! 181: PLINE pLine ; ! 182: int iNumLines ; ! 183: ! 184: if (!pLineFirst) ! 185: return (0) ; ! 186: ! 187: ! 188: iNumLines = 0 ; ! 189: for (pLine = pLineFirst ; ! 190: pLine ; ! 191: pLine = pLine->pLineNext) ! 192: { // for ! 193: iNumLines++ ; ! 194: } // for ! 195: ! 196: ! 197: return (iNumLines) ; ! 198: } // NumLines ! 199: ! 200: ! 201: ! 202: LPTSTR LineInstanceName (PLINE pLine) ! 203: { ! 204: if (pLine->lnObject.NumInstances <= 0) ! 205: return (NULL) ; ! 206: else ! 207: return (pLine->lnInstanceName) ; ! 208: } ! 209: ! 210: ! 211: LPTSTR LineParentName (PLINE pLine) ! 212: { ! 213: if (pLine->lnObject.NumInstances <= 0) ! 214: return (NULL) ; ! 215: else if (pLine->lnInstanceDef.ParentObjectTitleIndex) ! 216: return (pLine->lnPINName) ; ! 217: else ! 218: return (NULL) ; ! 219: } ! 220: ! 221: ! 222: ! 223: void LineCounterAppend (PPLINE ppLineFirst, ! 224: PLINE pLineNew) ! 225: { ! 226: PLINE pLine ; ! 227: ! 228: if (!*ppLineFirst) ! 229: *ppLineFirst = pLineNew ; ! 230: else ! 231: { // else ! 232: for (pLine = *ppLineFirst ; ! 233: pLine->pLineCounterNext ; ! 234: pLine = pLine->pLineCounterNext) ! 235: /* nothing */ ; ! 236: pLine->pLineCounterNext = pLineNew ; ! 237: } // else ! 238: } ! 239: ! 240: ! 241: ! 242: BOOL EquivalentLine (PLINE pLine1, ! 243: PLINE pLine2) ! 244: { // LineEquivalent ! 245: return (pstrsame (pLine1->lnCounterName, pLine2->lnCounterName) && ! 246: pstrsame (pLine1->lnInstanceName, pLine2->lnInstanceName) && ! 247: pstrsame (pLine1->lnPINName, pLine2->lnPINName) && ! 248: pstrsame (pLine1->lnObjectName, pLine2->lnObjectName) && ! 249: pstrsamei (pLine1->lnSystemName, pLine2->lnSystemName)) ; ! 250: } // LineEquivalent ! 251: ! 252: ! 253: PLINE FindEquivalentLine (PLINE pLineToFind, ! 254: PLINE pLineFirst) ! 255: { ! 256: PLINE pLine ; ! 257: ! 258: for (pLine = pLineFirst ; ! 259: pLine ; ! 260: pLine = pLine->pLineNext) ! 261: { // for ! 262: if (EquivalentLine (pLine, pLineToFind)) ! 263: return (pLine) ; ! 264: } // for ! 265: ! 266: return (NULL) ; ! 267: } // FindEquivalentLine ! 268: ! 269: // This routine is used only to read the system name from a disk string ! 270: // It is mainly for performance improvement. ! 271: LPTSTR DiskStringReadSys (PDISKSTRING pDS) ! 272: { // DiskStringReadSys ! 273: LPTSTR lpszText ; ! 274: LPTSTR pDiskSysName ; ! 275: int iIndex ; ! 276: BOOL bLocalSysName = FALSE ; ! 277: ! 278: if (pDS->dwLength == 0) ! 279: { ! 280: return (NULL) ; ! 281: } ! 282: ! 283: if (pDS->dwLength == sizeofCodeName) ! 284: { ! 285: // check for LOCAL_SYS_CODE_NAME ! 286: bLocalSysName = TRUE ; ! 287: pDiskSysName = (LPTSTR)((PBYTE) pDS + pDS->dwOffset) ; ! 288: for (iIndex = 0 ; iIndex < sizeofCodeName; iIndex++, pDiskSysName++) ! 289: { ! 290: if (*pDiskSysName != LOCAL_SYS_CODE_NAME[iIndex]) ! 291: { ! 292: bLocalSysName = FALSE ; ! 293: break ; ! 294: } ! 295: } ! 296: } ! 297: ! 298: if (bLocalSysName) ! 299: { ! 300: lpszText = ! 301: MemoryAllocate ((lstrlen(LocalComputerName)+1) * sizeof(TCHAR)) ; ! 302: if (lpszText) ! 303: { ! 304: lstrcpy (lpszText, LocalComputerName) ; ! 305: } ! 306: } ! 307: else ! 308: { ! 309: lpszText = MemoryAllocate (sizeof (TCHAR) * (pDS->dwLength + 1)) ; ! 310: if (lpszText) ! 311: { ! 312: _tcsncpy ((WCHAR *)lpszText, (WCHAR *)((PBYTE) pDS + pDS->dwOffset), ! 313: pDS->dwLength) ; ! 314: } ! 315: } ! 316: ! 317: return (lpszText) ; ! 318: } // DiskStringReadSys ! 319: ! 320: ! 321: ! 322: LPTSTR DiskStringRead (PDISKSTRING pDS) ! 323: { // DiskStringRead ! 324: LPTSTR lpszText ; ! 325: ! 326: if (pDS->dwLength == 0) ! 327: { ! 328: return (NULL) ; ! 329: } ! 330: ! 331: lpszText = MemoryAllocate (sizeof (TCHAR) * (pDS->dwLength + 1)) ; ! 332: if (!lpszText) ! 333: { ! 334: return (NULL) ; ! 335: } ! 336: ! 337: _tcsncpy ((WCHAR *)lpszText, (WCHAR *)((PBYTE) pDS + pDS->dwOffset), ! 338: pDS->dwLength) ; ! 339: ! 340: return (lpszText) ; ! 341: } // DiskStringRead ! 342: ! 343: ! 344: int DiskStringLength (LPTSTR lpszText) ! 345: { ! 346: if (!lpszText) ! 347: return (0) ; ! 348: else ! 349: return (lstrlen (lpszText)) ; ! 350: } ! 351: ! 352: PBYTE DiskStringCopy (PDISKSTRING pDS, LPTSTR lpszText, PBYTE pNextFree) ! 353: { ! 354: if (!lpszText) ! 355: { ! 356: pDS->dwOffset = 0 ; ! 357: pDS->dwLength = 0 ; ! 358: return (pNextFree) ; ! 359: } ! 360: else ! 361: { ! 362: pDS->dwOffset = pNextFree - (PBYTE) pDS ; ! 363: pDS->dwLength = DiskStringLength (lpszText) ; ! 364: _tcsncpy ((WCHAR *)pNextFree, (WCHAR *)lpszText, pDS->dwLength) ; ! 365: return (pNextFree + pDS->dwLength * sizeof(TCHAR)) ; ! 366: } ! 367: } // DiskStringCopy ! 368: ! 369: ! 370: void CounterName (PPERFSYSTEM pSystem, ! 371: PPERFCOUNTERDEF pCounter, ! 372: LPTSTR lpszCounter) ! 373: { // CounterName ! 374: //!! strclr (lpszCounter) ; ! 375: lpszCounter [0] = TEXT('\0') ; ! 376: QueryPerformanceName (pSystem, ! 377: pCounter->CounterNameTitleIndex, ! 378: 0, 256, ! 379: lpszCounter, ! 380: FALSE) ; ! 381: } // CounterName ! 382: ! 383: ! 384: ! 385: PPERFOBJECT LineFindObject (PPERFSYSTEM pSystem, ! 386: PPERFDATA pPerfData, ! 387: PLINE pLine) ! 388: /* ! 389: Effect: Set the lnObject field of pLine to the object with the ! 390: name of lnObjectName, and return TRUE. Return FALSE if ! 391: there is no such object. ! 392: */ ! 393: { // LineFindObject ! 394: PPERFOBJECT pObject ; ! 395: ! 396: pObject = GetObjectDefByName (pSystem, pPerfData, pLine->lnObjectName) ; ! 397: ! 398: if (pObject) ! 399: { ! 400: pLine->lnObject = *pObject ; ! 401: return (pObject) ; ! 402: } ! 403: else ! 404: return (NULL) ; ! 405: } // LineFindObject ! 406: ! 407: ! 408: ! 409: PPERFCOUNTERDEF LineFindCounter (PPERFSYSTEM pSystem, ! 410: PPERFOBJECT pObject, ! 411: PPERFDATA pPerfData, ! 412: PLINE pLine) ! 413: { // LineFindCounter ! 414: UINT i ; ! 415: PPERFCOUNTERDEF pCounter ; ! 416: TCHAR szCounter [256] ; ! 417: ! 418: for (i = 0, pCounter = FirstCounter (pObject) ; ! 419: i < pObject->NumCounters ; ! 420: i++, pCounter = NextCounter (pCounter)) ! 421: { // for ! 422: CounterName (pSystem, pCounter, szCounter) ; ! 423: if (strsame (szCounter, pLine->lnCounterName)) ! 424: { ! 425: pLine->lnCounterDef = *pCounter ; ! 426: return (pCounter) ; ! 427: } // if ! 428: } // for ! 429: ! 430: return (NULL) ; ! 431: } // LineFindCounter ! 432: ! 433: ! 434: PPERFINSTANCEDEF LineFindInstance (PPERFDATA pPerfData, ! 435: PPERFOBJECT pObject, ! 436: PLINE pLine) ! 437: { // LineFindInstance ! 438: ! 439: ! 440: PPERFINSTANCEDEF pInstance = NULL ; ! 441: ! 442: if ((pObject->NumInstances > 0) && pLine->lnInstanceName) ! 443: { ! 444: // instances exist, find the right one ! 445: ! 446: if (pLine->lnUniqueID != PERF_NO_UNIQUE_ID) ! 447: { ! 448: pInstance = GetInstanceByUniqueID(pObject, pLine->lnUniqueID) ; ! 449: } ! 450: else ! 451: { ! 452: pInstance = GetInstanceByName(pPerfData, pObject, ! 453: pLine->lnInstanceName, pLine->lnPINName) ; ! 454: } ! 455: } ! 456: ! 457: if (pInstance) ! 458: { ! 459: pLine->lnInstanceDef = *pInstance ; ! 460: } ! 461: ! 462: return (pInstance) ; ! 463: } // LineFindInstance ! 464: ! 465: ! 466: ! 467: ! 468: void ReadLines (HANDLE hFile, ! 469: DWORD dwNumLines, ! 470: PPPERFSYSTEM ppSystemFirst, ! 471: PPLINE ppLineFirst, ! 472: int LineType) ! 473: { ! 474: DWORD i ; ! 475: PPERFDATA pPerfData ; ! 476: PLINE pLine ; ! 477: PPERFSYSTEM pSystem ; ! 478: PDISKLINE pDiskLine = NULL ; ! 479: DWORD SizeofDiskLine = 0 ; // bytes in pDiskLine ! 480: ! 481: ! 482: pPerfData = AllocatePerfData () ; ! 483: pSystem = *ppSystemFirst ; ! 484: ! 485: #if 0 ! 486: if (!pSystem) ! 487: { ! 488: pSystem = SystemAdd (ppSystemFirst, LocalComputerName) ; ! 489: pSystem = *ppSystemFirst ; //!! ! 490: } ! 491: ! 492: UpdateSystemData (pSystem, &pPerfData) ; ! 493: #endif ! 494: pDiskLine = MemoryAllocate (FilePathLen) ; ! 495: if (!pDiskLine) ! 496: { ! 497: // no memory to begin with, forget it ! 498: DlgErrorBox (hWndMain, ERR_NO_MEMORY) ; ! 499: return ; ! 500: } ! 501: SizeofDiskLine = FilePathLen ; ! 502: ! 503: for (i = 0 ; ! 504: i < dwNumLines ; ! 505: i++) ! 506: { ! 507: pLine = ReadLine (&pSystem, ppSystemFirst, &pPerfData, hFile, ! 508: LineType, &pDiskLine, &SizeofDiskLine) ; ! 509: if (pLine) ! 510: InsertLine (pLine) ; ! 511: } ! 512: ! 513: if (pDiskLine) ! 514: { ! 515: MemoryFree (pDiskLine); ! 516: } ! 517: ! 518: BuildValueListForSystems (*ppSystemFirst, *ppLineFirst) ; ! 519: ! 520: MemoryFree (pPerfData) ; ! 521: } // ReadLines ! 522: ! 523: ! 524: ! 525: void LineSetCounter (PLINE pLine, ! 526: PPERFSYSTEM pSystem, ! 527: PPERFCOUNTERDEF pCounter, ! 528: PPERFINSTANCEDEF pInstance) ! 529: /* ! 530: Effect: Set the counter-specific portions of pLine to point to ! 531: the desired counter. ! 532: ! 533: Called By: AddLine, ReadLine. ! 534: */ ! 535: { ! 536: } ! 537: ! 538: ! 539: PLINE ReadLine (PPERFSYSTEM *ppSystem, ! 540: PPPERFSYSTEM ppSystemFirst, ! 541: PPERFDATA *ppPerfData, ! 542: HANDLE hFile, ! 543: int LineType, ! 544: PDISKLINE *ppDiskLine, ! 545: DWORD *pSizeofDiskLine) ! 546: ! 547: ! 548: /* ! 549: Effect: Read in a line from the file hFile, at the current file ! 550: position. ! 551: ! 552: Internals: The very first characters are a line signature, then a ! 553: length integer. If the signature is correct, then allocate ! 554: the length amount, and work with that. ! 555: */ ! 556: { // ReadLine ! 557: PLINE pLine ; ! 558: ! 559: struct ! 560: { ! 561: DWORD dwSignature ; ! 562: DWORD dwLength ; ! 563: } LineHeader ; ! 564: ! 565: PPERFOBJECT pObject ; ! 566: PPERFCOUNTERDEF pCounter ; ! 567: PDISKLINE pDiskLine ; // Local copy of the pointer ! 568: ! 569: #ifdef KEEP_IT ! 570: int i ; ! 571: int iCounterIndex ; ! 572: int j ; ! 573: PERF_COUNTER_BLOCK *pCounterBlock ; ! 574: #endif ! 575: ! 576: PPERFINSTANCEDEF pInstance ; ! 577: // PPERFINSTANCEDEF pInstanceParent ; ! 578: // TCHAR szInstanceParent [256] ; ! 579: // TCHAR szObjectParent [PerfObjectLen] ; ! 580: ! 581: pLine = NULL ; ! 582: ! 583: ! 584: //=============================// ! 585: // read and compare signature // ! 586: //=============================// ! 587: ! 588: if (!FileRead (hFile, &LineHeader, sizeof (LineHeader))) ! 589: return (NULL) ; ! 590: ! 591: ! 592: if (LineHeader.dwSignature != dwLineSignature || ! 593: LineHeader.dwLength == 0) ! 594: { ! 595: SetLastError (ERROR_BAD_FORMAT) ; ! 596: return (NULL) ; ! 597: } ! 598: ! 599: ! 600: //=============================// ! 601: // read and allocate length // ! 602: //=============================// ! 603: ! 604: ! 605: // if (!FileRead (hFile, &dwLength, sizeof (dwLength)) || dwLength == 0) ! 606: // return (NULL) ; ! 607: ! 608: ! 609: // check if we need a bigger buffer, ! 610: // normally, it should be the same except the first time... ! 611: if (LineHeader.dwLength > *pSizeofDiskLine) ! 612: { ! 613: if (*ppDiskLine) ! 614: { ! 615: // free the previous buffer ! 616: MemoryFree (*ppDiskLine); ! 617: *pSizeofDiskLine = 0 ; ! 618: } ! 619: ! 620: // re-allocate a new buffer ! 621: *ppDiskLine = (PDISKLINE) MemoryAllocate (LineHeader.dwLength) ; ! 622: if (!(*ppDiskLine)) ! 623: { ! 624: // no memory, should flag an error... ! 625: return (NULL) ; ! 626: } ! 627: *pSizeofDiskLine = LineHeader.dwLength ; ! 628: } ! 629: ! 630: pDiskLine = *ppDiskLine ; ! 631: ! 632: ! 633: //=============================// ! 634: // copy diskline, alloc line // ! 635: //=============================// ! 636: ! 637: if (!FileRead (hFile, pDiskLine, LineHeader.dwLength)) ! 638: return (NULL) ; ! 639: ! 640: ! 641: pLine = LineAllocate () ; ! 642: if (!pLine) ! 643: { ! 644: return (NULL) ; ! 645: } ! 646: ! 647: pLine->iLineType = pDiskLine->iLineType ; ! 648: ! 649: ! 650: //=============================// ! 651: // convert system information // ! 652: //=============================// ! 653: ! 654: pLine->lnSystemName = DiskStringReadSys (&(pDiskLine->dsSystemName)) ; ! 655: if (!pLine->lnSystemName) ! 656: goto ErrorBadLine ; ! 657: ! 658: if (!*ppSystem || !strsamei (pLine->lnSystemName, (*ppSystem)->sysName)) ! 659: { ! 660: *ppSystem = SystemAdd (ppSystemFirst, pLine->lnSystemName) ; ! 661: if (!*ppSystem) ! 662: { ! 663: SetLastError (ERROR_BAD_FORMAT) ; ! 664: goto ErrorBadLine ; ! 665: } ! 666: ! 667: UpdateSystemData (*ppSystem, ppPerfData) ; ! 668: } // if ! 669: ! 670: //=============================// ! 671: // convert object information // ! 672: //=============================// ! 673: ! 674: pLine->lnObjectName = DiskStringRead (&(pDiskLine->dsObjectName)) ; ! 675: if (!pLine->lnObjectName) ! 676: goto ErrorBadLine ; ! 677: ! 678: pObject = LineFindObject (*ppSystem, *ppPerfData, pLine) ; ! 679: if (!pObject) ! 680: { ! 681: SetLastError (ERROR_BAD_FORMAT) ; ! 682: goto ErrorBadLine ; ! 683: } ! 684: ! 685: //=============================// ! 686: // convert counter information // ! 687: //=============================// ! 688: ! 689: pLine->lnCounterName = DiskStringRead (&(pDiskLine->dsCounterName)) ; ! 690: if (!pLine->lnCounterName) ! 691: goto ErrorBadLine ; ! 692: ! 693: pCounter = LineFindCounter (*ppSystem, pObject, *ppPerfData, pLine) ; ! 694: if (!pCounter) ! 695: { ! 696: SetLastError (ERROR_BAD_FORMAT) ; ! 697: goto ErrorBadLine ; ! 698: } ! 699: ! 700: //=============================// ! 701: // convert instance info // ! 702: //=============================// ! 703: ! 704: pLine->lnUniqueID = pDiskLine->dwUniqueID ; ! 705: pLine->lnInstanceName = DiskStringRead (&(pDiskLine->dsInstanceName)) ; ! 706: pLine->lnPINName = DiskStringRead (&(pDiskLine->dsPINName)) ; ! 707: ! 708: pInstance = LineFindInstance (*ppPerfData, pObject, pLine) ; ! 709: ! 710: if (pInstance) ! 711: { ! 712: pLine->lnParentObjName = DiskStringRead (&(pDiskLine->dsParentObjName)) ; ! 713: } ! 714: ! 715: ! 716: //=============================// ! 717: // convert chart information // ! 718: //=============================// ! 719: ! 720: if (LineType == IDM_VIEWCHART) ! 721: { ! 722: pLine->Visual = pDiskLine->Visual ; ! 723: pLine->hPen = CreatePen (pLine->Visual.iStyle, ! 724: pLine->Visual.iWidth, ! 725: pLine->Visual.crColor) ; ! 726: pLine->iScaleIndex = pDiskLine->iScaleIndex ; ! 727: pLine->eScale = pDiskLine->eScale ; ! 728: } ! 729: ! 730: ! 731: //=============================// ! 732: // convert alert information // ! 733: //=============================// ! 734: ! 735: if (LineType == IDM_VIEWALERT) ! 736: { ! 737: pLine->Visual = pDiskLine->Visual ; ! 738: pLine->hBrush = CreateSolidBrush (pLine->Visual.crColor) ; ! 739: pLine->bAlertOver = pDiskLine->bAlertOver ; ! 740: pLine->eAlertValue = pDiskLine->eAlertValue ; ! 741: pLine->lpszAlertProgram = DiskStringRead (&(pDiskLine->dsAlertProgram)) ; ! 742: pLine->bEveryTime = pDiskLine->bEveryTime ; ! 743: pLine->bAlerted = FALSE ; ! 744: } ! 745: ! 746: ! 747: //=============================// ! 748: // Convert the nasty stuff // ! 749: //=============================// ! 750: ! 751: ! 752: pLine->lnCounterType = pCounter->CounterType; ! 753: pLine->lnCounterLength = pCounter->CounterSize; ! 754: ! 755: ! 756: // we don't need these line info since we will get it ! 757: // from the first couple clock ticks... ! 758: // If we decide to keep these line, just define KEEP_IT ! 759: #ifdef KEEP_IT ! 760: pLine->lnOldTime = (*ppPerfData)->PerfTime ; ! 761: pLine->lnNewTime = (*ppPerfData)->PerfTime ; ! 762: pLine->lnOldTime100Ns = (*ppPerfData)->PerfTime100nSec ; ! 763: pLine->lnNewTime100Ns = (*ppPerfData)->PerfTime100nSec; ! 764: ! 765: pLine->lnPerfFreq = (*ppPerfData)->PerfFreq ; ! 766: ! 767: for (j = 0 ; j < 2 ; j++) ! 768: { ! 769: pLine->lnaCounterValue[j].LowPart = 0 ; ! 770: pLine->lnaCounterValue[j].HighPart = 0 ; ! 771: } ! 772: ! 773: ! 774: if (pObject->NumInstances > 0 && pInstance) ! 775: { ! 776: pCounterBlock = (PERF_COUNTER_BLOCK *) ( (PBYTE) pInstance + ! 777: pInstance->ByteLength); ! 778: } ! 779: else ! 780: { ! 781: pCounterBlock = (PERF_COUNTER_BLOCK *) ( (PBYTE) pObject + ! 782: pObject->DefinitionLength); ! 783: } ! 784: ! 785: if (pLine->lnCounterLength <= 4) ! 786: pLine->lnaOldCounterValue[0].LowPart = ! 787: * ( (DWORD FAR *) ( (PBYTE)pCounterBlock + ! 788: pCounter[0].CounterOffset)); ! 789: else ! 790: { ! 791: pLine->lnaOldCounterValue[0] = ! 792: * ( (LARGE_INTEGER *) ( (PBYTE)pCounterBlock + ! 793: pCounter[0].CounterOffset)); ! 794: } ! 795: ! 796: // Get second counter, only if we are not at ! 797: // the end of the counters; some computations ! 798: // require a second counter ! 799: ! 800: iCounterIndex = CounterIndex (pCounter, pObject) ; ! 801: if ((UINT) iCounterIndex < pObject->NumCounters - 1 && ! 802: iCounterIndex != -1) ! 803: { ! 804: if (pLine->lnCounterLength <= 4) ! 805: pLine->lnaOldCounterValue[1].LowPart = ! 806: * ( (DWORD FAR *) ( (PBYTE)pCounterBlock + ! 807: pCounter[1].CounterOffset)); ! 808: else ! 809: pLine->lnaOldCounterValue[1] = ! 810: * ( (LARGE_INTEGER *) ( (PBYTE)pCounterBlock + ! 811: pCounter[1].CounterOffset)); ! 812: } ! 813: ! 814: // pLine->valNext = CounterFuncEntry ; ! 815: pLine->valNext = CounterEntry ; ! 816: ! 817: pLine->lnaOldCounterValue[0] = pLine->lnaCounterValue[0]; ! 818: pLine->lnaOldCounterValue[1] = pLine->lnaCounterValue[1]; ! 819: #endif // KEEP_IT ! 820: ! 821: ! 822: // pLine->valNext = CounterFuncEntry ; ! 823: pLine->valNext = CounterEntry ; ! 824: ! 825: return (pLine) ; ! 826: ! 827: ! 828: ErrorBadLine: ! 829: if (!pLine) ! 830: { ! 831: LineFree (pLine) ; ! 832: } ! 833: return (NULL) ; ! 834: } // ReadLine ! 835: ! 836: ! 837: ! 838: ! 839: BOOL WriteLine (PLINE pLine, ! 840: HANDLE hFile) ! 841: { // WriteLine ! 842: PDISKLINE pDiskLine ; ! 843: DWORD dwSignature ; ! 844: DWORD dwLength ; ! 845: PBYTE pNextFree ; ! 846: BOOL bConvertName ; ! 847: ! 848: //=============================// ! 849: // write signature // ! 850: //=============================// ! 851: ! 852: dwSignature = dwLineSignature ; ! 853: if (!FileWrite (hFile, &dwSignature, sizeof (dwSignature))) ! 854: return (FALSE) ; ! 855: ! 856: if (IsLocalComputer(pLine->lnSystemName)) ! 857: { ! 858: bConvertName = TRUE ; ! 859: } ! 860: else ! 861: { ! 862: bConvertName = FALSE ; ! 863: } ! 864: ! 865: //=============================// ! 866: // compute and allocate length // ! 867: //=============================// ! 868: ! 869: ! 870: dwLength = sizeof (DISKLINE) ; ! 871: if (bConvertName) ! 872: { ! 873: dwLength += DiskStringLength (LOCAL_SYS_CODE_NAME) * sizeof (TCHAR) ; ! 874: } ! 875: else ! 876: { ! 877: dwLength += DiskStringLength (pLine->lnSystemName) * sizeof (TCHAR) ; ! 878: } ! 879: dwLength += DiskStringLength (pLine->lnObjectName) * sizeof (TCHAR) ; ! 880: dwLength += DiskStringLength (pLine->lnCounterName) * sizeof (TCHAR) ; ! 881: dwLength += DiskStringLength (pLine->lnInstanceName) * sizeof (TCHAR) ; ! 882: dwLength += DiskStringLength (pLine->lnPINName) * sizeof (TCHAR) ; ! 883: dwLength += DiskStringLength (pLine->lnParentObjName) * sizeof (TCHAR) ; ! 884: dwLength += DiskStringLength (pLine->lpszAlertProgram) * sizeof (TCHAR) ; ! 885: ! 886: ! 887: if (!FileWrite (hFile, &dwLength, sizeof (dwLength))) ! 888: return (FALSE) ; ! 889: ! 890: pDiskLine = (PDISKLINE) MemoryAllocate (dwLength) ; ! 891: if (!pDiskLine) ! 892: return (FALSE) ; ! 893: ! 894: pNextFree = (PBYTE) pDiskLine + sizeof (DISKLINE) ; ! 895: ! 896: ! 897: //=============================// ! 898: // convert fixed size fields // ! 899: //=============================// ! 900: ! 901: pDiskLine->iLineType = pLine->iLineType ; ! 902: pDiskLine->dwUniqueID = pLine->lnUniqueID ; ! 903: pDiskLine->Visual = pLine->Visual ; ! 904: pDiskLine->iScaleIndex = pLine->iScaleIndex ; ! 905: pDiskLine->eScale = pLine->eScale ; ! 906: pDiskLine->bAlertOver = pLine->bAlertOver ; ! 907: pDiskLine->eAlertValue = pLine->eAlertValue ; ! 908: pDiskLine->bEveryTime = pLine->bEveryTime ; ! 909: ! 910: ! 911: //=============================// ! 912: // copy disk string fields // ! 913: //=============================// ! 914: ! 915: if (bConvertName) ! 916: { ! 917: pNextFree = DiskStringCopy (&pDiskLine->dsSystemName, ! 918: LOCAL_SYS_CODE_NAME, ! 919: pNextFree) ; ! 920: } ! 921: else ! 922: { ! 923: pNextFree = DiskStringCopy (&pDiskLine->dsSystemName, ! 924: pLine->lnSystemName, ! 925: pNextFree) ; ! 926: } ! 927: ! 928: pNextFree = DiskStringCopy (&pDiskLine->dsObjectName, ! 929: pLine->lnObjectName, ! 930: pNextFree) ; ! 931: ! 932: pNextFree = DiskStringCopy (&pDiskLine->dsCounterName, ! 933: pLine->lnCounterName, ! 934: pNextFree) ; ! 935: ! 936: pNextFree = DiskStringCopy (&pDiskLine->dsParentObjName, ! 937: pLine->lnParentObjName, ! 938: pNextFree) ; ! 939: ! 940: pNextFree = DiskStringCopy (&pDiskLine->dsInstanceName, ! 941: pLine->lnInstanceName, ! 942: pNextFree) ; ! 943: ! 944: pNextFree = DiskStringCopy (&pDiskLine->dsPINName, ! 945: pLine->lnPINName, ! 946: pNextFree) ; ! 947: ! 948: pNextFree = DiskStringCopy (&pDiskLine->dsAlertProgram, ! 949: pLine->lpszAlertProgram, ! 950: pNextFree) ; ! 951: ! 952: ! 953: ! 954: FileWrite (hFile, pDiskLine, dwLength) ; ! 955: MemoryFree (pDiskLine) ; ! 956: return (TRUE) ; ! 957: ! 958: //ErrorBadLine: ! 959: MemoryFree (pDiskLine) ; ! 960: return (FALSE) ; ! 961: } // WriteLine ! 962: ! 963: ! 964: // we are not doing printing. In case we need this ! 965: // later, then define DO_PRINTING ! 966: #ifdef DO_PRINTING ! 967: int aiPrinterLineStyles [] = ! 968: { ! 969: PS_SOLID, ! 970: PS_DASH, ! 971: PS_DOT, ! 972: PS_DASHDOT, ! 973: PS_DASHDOTDOT ! 974: } ; ! 975: #define NumPrinterLineStyles() \ ! 976: (sizeof (aiPrinterLineStyles) / sizeof (aiPrinterLineStyles [0])) ! 977: ! 978: ! 979: COLORREF acrPrinterLineColors [] = ! 980: { ! 981: RGB (192, 192, 192), ! 982: RGB (128, 128, 128), ! 983: RGB (64, 64, 64), ! 984: RGB (0, 0, 0) ! 985: } ; ! 986: ! 987: ! 988: #define NumPrinterLineColors() \ ! 989: (sizeof (acrPrinterLineColors) / sizeof (acrPrinterLineColors [0])) ! 990: #endif // DO_PRINTING ! 991: ! 992: ! 993: HPEN LineCreatePen (HDC hDC, ! 994: PLINEVISUAL pVisual, ! 995: BOOL bForPrint) ! 996: { // LineCreatePen ! 997: HPEN hPen ; ! 998: #ifdef DO_PRINTING ! 999: LOGBRUSH logBrush ; ! 1000: ! 1001: ! 1002: if (bForPrint) ! 1003: { ! 1004: logBrush.lbStyle = PS_SOLID ; ! 1005: //!! aiPrinterLineStyles [pVisual->iColorIndex % NumPrinterLineStyles ()] ; ! 1006: logBrush.lbColor = ! 1007: acrPrinterLineColors [pVisual->iColorIndex % NumPrinterLineColors ()] ; ! 1008: logBrush.lbHatch = 0 ; ! 1009: ! 1010: hPen = ExtCreatePen (logBrush.lbStyle | ! 1011: PS_GEOMETRIC | ! 1012: PS_ENDCAP_SQUARE | ! 1013: PS_JOIN_BEVEL, ! 1014: VertInchPixels (hDC, pVisual->iWidth, 20), ! 1015: &logBrush, ! 1016: 0, NULL) ; ! 1017: } ! 1018: else ! 1019: #endif ! 1020: hPen = CreatePen (pVisual->iStyle, ! 1021: pVisual->iWidth, ! 1022: pVisual->crColor) ; ! 1023: ! 1024: return (hPen) ; ! 1025: } // LineCreatePen ! 1026: ! 1027: ! 1028: ! 1029: VOID FreeLines (PLINESTRUCT pLineFirst) ! 1030: { // FreeLines ! 1031: PLINESTRUCT pLine,next_line; ! 1032: ! 1033: ! 1034: for (pLine = pLineFirst; pLine; pLine = next_line) ! 1035: { ! 1036: next_line = pLine->pLineNext; ! 1037: LineFree (pLine) ; ! 1038: } ! 1039: } // FreeLines ! 1040: ! 1041:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.