1 /** @file 2 Trace reporting for the Dp utility. 3 4 Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR> 5 (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR> 6 This program and the accompanying materials 7 are licensed and made available under the terms and conditions of the BSD License 8 which accompanies this distribution. The full text of the license may be found at 9 http://opensource.org/licenses/bsd-license.php 10 11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 13 **/ 14 15 #include <Library/BaseLib.h> 16 #include <Library/BaseMemoryLib.h> 17 #include <Library/MemoryAllocationLib.h> 18 #include <Library/DebugLib.h> 19 #include <Library/UefiBootServicesTableLib.h> 20 #include <Library/TimerLib.h> 21 #include <Library/PeCoffGetEntryPointLib.h> 22 #include <Library/PerformanceLib.h> 23 #include <Library/PrintLib.h> 24 #include <Library/HiiLib.h> 25 #include <Library/PcdLib.h> 26 27 #include <Guid/Performance.h> 28 29 #include "Dp.h" 30 #include "Literals.h" 31 #include "DpInternal.h" 32 33 /** 34 Collect verbose statistics about the logged performance measurements. 35 36 General Summary information for all Trace measurements is gathered and 37 stored within the SummaryData structure. This information is both 38 used internally by subsequent reporting functions, and displayed 39 at the end of verbose reports. 40 41 @pre The SummaryData and CumData structures must be initialized 42 prior to calling this function. 43 44 @post The SummaryData and CumData structures contain statistics for the 45 current performance logs. 46 47 @param[in, out] CustomCumulativeData A pointer to the cumtom cumulative data. 48 49 **/ 50 VOID 51 GatherStatistics( 52 IN OUT PERF_CUM_DATA *CustomCumulativeData OPTIONAL 53 ) 54 { 55 MEASUREMENT_RECORD Measurement; 56 UINT64 Duration; 57 UINTN LogEntryKey; 58 INTN TIndex; 59 60 LogEntryKey = 0; 61 while ((LogEntryKey = GetPerformanceMeasurementEx ( 62 LogEntryKey, 63 &Measurement.Handle, 64 &Measurement.Token, 65 &Measurement.Module, 66 &Measurement.StartTimeStamp, 67 &Measurement.EndTimeStamp, 68 &Measurement.Identifier)) != 0) 69 { 70 ++SummaryData.NumTrace; // Count the number of TRACE Measurement records 71 if (Measurement.EndTimeStamp == 0) { 72 ++SummaryData.NumIncomplete; // Count the incomplete records 73 continue; 74 } 75 76 if (Measurement.Handle != NULL) { 77 ++SummaryData.NumHandles; // Count the number of measurements with non-NULL handles 78 } 79 80 if (IsPhase( &Measurement)) { 81 ++SummaryData.NumSummary; // Count the number of major phases 82 } 83 else { // !IsPhase(... 84 if(Measurement.Handle == NULL) { 85 ++SummaryData.NumGlobal; 86 } 87 } 88 89 if (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) == 0) { 90 ++SummaryData.NumPEIMs; // Count PEIM measurements 91 } 92 93 Duration = GetDuration (&Measurement); 94 TIndex = GetCumulativeItem (&Measurement); 95 if (TIndex >= 0) { 96 CumData[TIndex].Duration += Duration; 97 CumData[TIndex].Count++; 98 if ( Duration < CumData[TIndex].MinDur ) { 99 CumData[TIndex].MinDur = Duration; 100 } 101 if ( Duration > CumData[TIndex].MaxDur ) { 102 CumData[TIndex].MaxDur = Duration; 103 } 104 } 105 106 // 107 // Collect the data for custom cumulative data. 108 // 109 if ((CustomCumulativeData != NULL) && (AsciiStrCmp (Measurement.Token, CustomCumulativeData->Name) == 0)) { 110 CustomCumulativeData->Duration += Duration; 111 CustomCumulativeData->Count++; 112 if (Duration < CustomCumulativeData->MinDur) { 113 CustomCumulativeData->MinDur = Duration; 114 } 115 if (Duration > CustomCumulativeData->MaxDur) { 116 CustomCumulativeData->MaxDur = Duration; 117 } 118 } 119 } 120 } 121 122 /** 123 Gather and print ALL Trace Records. 124 125 Displays all "interesting" Trace measurements in order.<BR> 126 The number of records displayed is controlled by: 127 - records with a duration less than mInterestThreshold microseconds are not displayed. 128 - No more than Limit records are displayed. A Limit of zero will not limit the output. 129 - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not 130 displayed. 131 132 @pre The mInterestThreshold global variable is set to the shortest duration to be printed. 133 The mGaugeString and mUnicodeToken global arrays are used for temporary string storage. 134 They must not be in use by a calling function. 135 136 @param[in] Limit The number of records to print. Zero is ALL. 137 @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display. 138 139 @retval EFI_SUCCESS The operation was successful. 140 @retval EFI_ABORTED The user aborts the operation. 141 @return Others from a call to gBS->LocateHandleBuffer(). 142 **/ 143 EFI_STATUS 144 DumpAllTrace( 145 IN UINTN Limit, 146 IN BOOLEAN ExcludeFlag 147 ) 148 { 149 MEASUREMENT_RECORD Measurement; 150 UINT64 ElapsedTime; 151 UINT64 Duration; 152 const CHAR16 *IncFlag; 153 UINTN LogEntryKey; 154 UINTN Count; 155 UINTN Index; 156 UINTN TIndex; 157 158 EFI_HANDLE *HandleBuffer; 159 UINTN HandleCount; 160 EFI_STATUS Status; 161 EFI_STRING StringPtrUnknown; 162 163 StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); 164 IncFlag = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_ALL), NULL); 165 PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), 166 (IncFlag == NULL) ? StringPtrUnknown : IncFlag); 167 FreePool (StringPtrUnknown); 168 169 // Get Handle information 170 // 171 Status = gBS->LocateHandleBuffer (AllHandles, NULL, NULL, &HandleCount, &HandleBuffer); 172 if (EFI_ERROR (Status)) { 173 PrintToken (STRING_TOKEN (STR_DP_HANDLES_ERROR), Status); 174 } 175 else { 176 // We have successfully populated the HandleBuffer 177 // Display ALL Measurement Records 178 // Up to Limit lines displayed 179 // Display only records with Elapsed times >= mInterestThreshold 180 // Display driver names in Module field for records with Handles. 181 // 182 if (mShowId) { 183 PrintToken (STRING_TOKEN (STR_DP_ALL_HEADR2) ); 184 PrintToken (STRING_TOKEN (STR_DP_ALL_DASHES2) ); 185 } else { 186 PrintToken (STRING_TOKEN (STR_DP_ALL_HEADR) ); 187 PrintToken (STRING_TOKEN (STR_DP_DASHES) ); 188 } 189 190 LogEntryKey = 0; 191 Count = 0; 192 Index = 0; 193 while ( WITHIN_LIMIT(Count, Limit) && 194 ((LogEntryKey = GetPerformanceMeasurementEx ( 195 LogEntryKey, 196 &Measurement.Handle, 197 &Measurement.Token, 198 &Measurement.Module, 199 &Measurement.StartTimeStamp, 200 &Measurement.EndTimeStamp, 201 &Measurement.Identifier)) != 0) 202 ) 203 { 204 ++Index; // Count every record. First record is 1. 205 ElapsedTime = 0; 206 SafeFreePool ((VOID *) IncFlag); 207 if (Measurement.EndTimeStamp != 0) { 208 Duration = GetDuration (&Measurement); 209 ElapsedTime = DurationInMicroSeconds ( Duration ); 210 IncFlag = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_COMPLETE), NULL); 211 } 212 else { 213 IncFlag = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_INCOMPLETE), NULL); // Mark incomplete records 214 } 215 if (((Measurement.EndTimeStamp != 0) && (ElapsedTime < mInterestThreshold)) || 216 ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0)) 217 ) { // Ignore "uninteresting" or excluded records 218 continue; 219 } 220 ++Count; // Count the number of records printed 221 222 // If Handle is non-zero, see if we can determine a name for the driver 223 AsciiStrToUnicodeStrS (Measurement.Module, mGaugeString, ARRAY_SIZE (mGaugeString)); // Use Module by default 224 AsciiStrToUnicodeStrS (Measurement.Token, mUnicodeToken, ARRAY_SIZE (mUnicodeToken)); 225 if (Measurement.Handle != NULL) { 226 // See if the Handle is in the HandleBuffer 227 for (TIndex = 0; TIndex < HandleCount; TIndex++) { 228 if (Measurement.Handle == HandleBuffer[TIndex]) { 229 GetNameFromHandle (HandleBuffer[TIndex]); 230 break; 231 } 232 } 233 } 234 235 if (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) == 0) { 236 UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", Measurement.Handle); 237 } 238 239 // Ensure that the argument strings are not too long. 240 mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; 241 mUnicodeToken[13] = 0; 242 243 if (mShowId) { 244 PrintToken( STRING_TOKEN (STR_DP_ALL_VARS2), 245 Index, // 1 based, Which measurement record is being printed 246 IncFlag, 247 Measurement.Handle, 248 mGaugeString, 249 mUnicodeToken, 250 ElapsedTime, 251 Measurement.Identifier 252 ); 253 } else { 254 PrintToken( STRING_TOKEN (STR_DP_ALL_VARS), 255 Index, // 1 based, Which measurement record is being printed 256 IncFlag, 257 Measurement.Handle, 258 mGaugeString, 259 mUnicodeToken, 260 ElapsedTime 261 ); 262 } 263 if (ShellGetExecutionBreakFlag ()) { 264 Status = EFI_ABORTED; 265 break; 266 } 267 } 268 } 269 if (HandleBuffer != NULL) { 270 FreePool (HandleBuffer); 271 } 272 SafeFreePool ((VOID *) IncFlag); 273 return Status; 274 } 275 276 /** 277 Gather and print Raw Trace Records. 278 279 All Trace measurements with a duration greater than or equal to 280 mInterestThreshold are printed without interpretation. 281 282 The number of records displayed is controlled by: 283 - records with a duration less than mInterestThreshold microseconds are not displayed. 284 - No more than Limit records are displayed. A Limit of zero will not limit the output. 285 - If the ExcludeFlag is TRUE, records matching entries in the CumData array are not 286 displayed. 287 288 @pre The mInterestThreshold global variable is set to the shortest duration to be printed. 289 290 @param[in] Limit The number of records to print. Zero is ALL. 291 @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display. 292 293 @retval EFI_SUCCESS The operation was successful. 294 @retval EFI_ABORTED The user aborts the operation. 295 **/ 296 EFI_STATUS 297 DumpRawTrace( 298 IN UINTN Limit, 299 IN BOOLEAN ExcludeFlag 300 ) 301 { 302 MEASUREMENT_RECORD Measurement; 303 UINT64 ElapsedTime; 304 UINT64 Duration; 305 UINTN LogEntryKey; 306 UINTN Count; 307 UINTN Index; 308 309 EFI_STRING StringPtr; 310 EFI_STRING StringPtrUnknown; 311 EFI_STATUS Status; 312 313 Status = EFI_SUCCESS; 314 315 StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); 316 StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_RAWTRACE), NULL); 317 PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), 318 (StringPtr == NULL) ? StringPtrUnknown : StringPtr); 319 FreePool (StringPtr); 320 FreePool (StringPtrUnknown); 321 322 if (mShowId) { 323 PrintToken (STRING_TOKEN (STR_DP_RAW_HEADR2) ); 324 PrintToken (STRING_TOKEN (STR_DP_RAW_DASHES2) ); 325 } else { 326 PrintToken (STRING_TOKEN (STR_DP_RAW_HEADR) ); 327 PrintToken (STRING_TOKEN (STR_DP_RAW_DASHES) ); 328 } 329 330 LogEntryKey = 0; 331 Count = 0; 332 Index = 0; 333 while ( WITHIN_LIMIT(Count, Limit) && 334 ((LogEntryKey = GetPerformanceMeasurementEx ( 335 LogEntryKey, 336 &Measurement.Handle, 337 &Measurement.Token, 338 &Measurement.Module, 339 &Measurement.StartTimeStamp, 340 &Measurement.EndTimeStamp, 341 &Measurement.Identifier)) != 0) 342 ) 343 { 344 ++Index; // Count every record. First record is 1. 345 ElapsedTime = 0; 346 if (Measurement.EndTimeStamp != 0) { 347 Duration = GetDuration (&Measurement); 348 ElapsedTime = DurationInMicroSeconds ( Duration ); 349 } 350 if ((ElapsedTime < mInterestThreshold) || 351 ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0)) 352 ) { // Ignore "uninteresting" or Excluded records 353 continue; 354 } 355 ++Count; // Count the number of records printed 356 357 if (mShowId) { 358 PrintToken (STRING_TOKEN (STR_DP_RAW_VARS2), 359 Index, // 1 based, Which measurement record is being printed 360 Measurement.Handle, 361 Measurement.StartTimeStamp, 362 Measurement.EndTimeStamp, 363 Measurement.Token, 364 Measurement.Module, 365 Measurement.Identifier 366 ); 367 } else { 368 PrintToken (STRING_TOKEN (STR_DP_RAW_VARS), 369 Index, // 1 based, Which measurement record is being printed 370 Measurement.Handle, 371 Measurement.StartTimeStamp, 372 Measurement.EndTimeStamp, 373 Measurement.Token, 374 Measurement.Module 375 ); 376 } 377 if (ShellGetExecutionBreakFlag ()) { 378 Status = EFI_ABORTED; 379 break; 380 } 381 } 382 return Status; 383 } 384 385 /** 386 Gather and print Major Phase metrics. 387 388 @param[in] Ticker The timer value for the END of Shell phase 389 390 **/ 391 VOID 392 ProcessPhases( 393 IN UINT64 Ticker 394 ) 395 { 396 MEASUREMENT_RECORD Measurement; 397 UINT64 BdsTimeoutValue; 398 UINT64 SecTime; 399 UINT64 PeiTime; 400 UINT64 DxeTime; 401 UINT64 BdsTime; 402 UINT64 ShellTime; 403 UINT64 ElapsedTime; 404 UINT64 Duration; 405 UINT64 Total; 406 EFI_STRING StringPtr; 407 UINTN LogEntryKey; 408 EFI_STRING StringPtrUnknown; 409 410 BdsTimeoutValue = 0; 411 SecTime = 0; 412 PeiTime = 0; 413 DxeTime = 0; 414 BdsTime = 0; 415 ShellTime = 0; 416 // 417 // Get Execution Phase Statistics 418 // 419 StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); 420 StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_PHASES), NULL); 421 PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), 422 (StringPtr == NULL) ? StringPtrUnknown : StringPtr); 423 FreePool (StringPtr); 424 FreePool (StringPtrUnknown); 425 426 LogEntryKey = 0; 427 while ((LogEntryKey = GetPerformanceMeasurementEx ( 428 LogEntryKey, 429 &Measurement.Handle, 430 &Measurement.Token, 431 &Measurement.Module, 432 &Measurement.StartTimeStamp, 433 &Measurement.EndTimeStamp, 434 &Measurement.Identifier)) != 0) 435 { 436 if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) { 437 Measurement.EndTimeStamp = Ticker; 438 } 439 if (Measurement.EndTimeStamp == 0) { // Skip "incomplete" records 440 continue; 441 } 442 Duration = GetDuration (&Measurement); 443 if ( Measurement.Handle != NULL 444 && (AsciiStrnCmp (Measurement.Token, ALit_BdsTO, PERF_TOKEN_LENGTH) == 0) 445 ) 446 { 447 BdsTimeoutValue = Duration; 448 } else if (AsciiStrnCmp (Measurement.Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0) { 449 SecTime = Duration; 450 } else if (AsciiStrnCmp (Measurement.Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0) { 451 PeiTime = Duration; 452 } else if (AsciiStrnCmp (Measurement.Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0) { 453 DxeTime = Duration; 454 } else if (AsciiStrnCmp (Measurement.Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0) { 455 BdsTime = Duration; 456 } else if (AsciiStrnCmp (Measurement.Token, ALit_SHELL, PERF_TOKEN_LENGTH) == 0) { 457 ShellTime = Duration; 458 } 459 } 460 461 Total = 0; 462 463 // print SEC phase duration time 464 // 465 if (SecTime > 0) { 466 ElapsedTime = DurationInMicroSeconds ( SecTime ); // Calculate elapsed time in microseconds 467 Total += DivU64x32 (ElapsedTime, 1000); // Accumulate time in milliseconds 468 PrintToken (STRING_TOKEN (STR_DP_SEC_PHASE), ElapsedTime); 469 } 470 471 // print PEI phase duration time 472 // 473 if (PeiTime > 0) { 474 ElapsedTime = DivU64x32 ( 475 PeiTime, 476 (UINT32)TimerInfo.Frequency 477 ); 478 Total += ElapsedTime; 479 PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_PEI, ElapsedTime); 480 } 481 482 // print DXE phase duration time 483 // 484 if (DxeTime > 0) { 485 ElapsedTime = DivU64x32 ( 486 DxeTime, 487 (UINT32)TimerInfo.Frequency 488 ); 489 Total += ElapsedTime; 490 PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_DXE, ElapsedTime); 491 } 492 493 // print BDS phase duration time 494 // 495 if (BdsTime > 0) { 496 ElapsedTime = DivU64x32 ( 497 BdsTime, 498 (UINT32)TimerInfo.Frequency 499 ); 500 Total += ElapsedTime; 501 PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_BDS, ElapsedTime); 502 } 503 504 if (BdsTimeoutValue > 0) { 505 ElapsedTime = DivU64x32 ( 506 BdsTimeoutValue, 507 (UINT32)TimerInfo.Frequency 508 ); 509 PrintToken (STRING_TOKEN (STR_DP_PHASE_BDSTO), ALit_BdsTO, ElapsedTime); 510 } 511 512 // print SHELL phase duration time 513 // 514 if (ShellTime > 0) { 515 ElapsedTime = DivU64x32 ( 516 ShellTime, 517 (UINT32)TimerInfo.Frequency 518 ); 519 Total += ElapsedTime; 520 PrintToken (STRING_TOKEN (STR_DP_PHASE_DURATION), ALit_SHELL, ElapsedTime); 521 } 522 523 PrintToken (STRING_TOKEN (STR_DP_TOTAL_DURATION), Total); 524 } 525 526 /** 527 Gather and print Handle data. 528 529 @param[in] ExcludeFlag TRUE to exclude individual Cumulative items from display. 530 531 @retval EFI_SUCCESS The operation was successful. 532 @retval EFI_ABORTED The user aborts the operation. 533 @return Others from a call to gBS->LocateHandleBuffer(). 534 **/ 535 EFI_STATUS 536 ProcessHandles( 537 IN BOOLEAN ExcludeFlag 538 ) 539 { 540 MEASUREMENT_RECORD Measurement; 541 UINT64 ElapsedTime; 542 UINT64 Duration; 543 EFI_HANDLE *HandleBuffer; 544 EFI_STRING StringPtr; 545 UINTN Index; 546 UINTN LogEntryKey; 547 UINTN Count; 548 UINTN HandleCount; 549 EFI_STATUS Status; 550 EFI_STRING StringPtrUnknown; 551 552 StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); 553 StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_DRIVERS), NULL); 554 PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), 555 (StringPtr == NULL) ? StringPtrUnknown : StringPtr); 556 FreePool (StringPtr); 557 FreePool (StringPtrUnknown); 558 559 Status = gBS->LocateHandleBuffer (AllHandles, NULL, NULL, &HandleCount, &HandleBuffer); 560 if (EFI_ERROR (Status)) { 561 PrintToken (STRING_TOKEN (STR_DP_HANDLES_ERROR), Status); 562 } 563 else { 564 #if DP_DEBUG == 2 565 Print (L"There are %,d Handles defined.\n", (Size / sizeof(HandleBuffer[0]))); 566 #endif 567 568 if (mShowId) { 569 PrintToken (STRING_TOKEN (STR_DP_HANDLE_SECTION2) ); 570 } else { 571 PrintToken (STRING_TOKEN (STR_DP_HANDLE_SECTION) ); 572 } 573 PrintToken (STRING_TOKEN (STR_DP_DASHES) ); 574 575 LogEntryKey = 0; 576 Count = 0; 577 while ((LogEntryKey = GetPerformanceMeasurementEx ( 578 LogEntryKey, 579 &Measurement.Handle, 580 &Measurement.Token, 581 &Measurement.Module, 582 &Measurement.StartTimeStamp, 583 &Measurement.EndTimeStamp, 584 &Measurement.Identifier)) != 0) 585 { 586 Count++; 587 Duration = GetDuration (&Measurement); 588 ElapsedTime = DurationInMicroSeconds ( Duration ); 589 if ((ElapsedTime < mInterestThreshold) || 590 (Measurement.EndTimeStamp == 0) || 591 (Measurement.Handle == NULL) || 592 ((ExcludeFlag) && (GetCumulativeItem(&Measurement) >= 0)) 593 ) { // Ignore "uninteresting" or excluded records 594 continue; 595 } 596 mGaugeString[0] = 0; // Empty driver name by default 597 AsciiStrToUnicodeStrS (Measurement.Token, mUnicodeToken, ARRAY_SIZE (mUnicodeToken)); 598 // See if the Handle is in the HandleBuffer 599 for (Index = 0; Index < HandleCount; Index++) { 600 if (Measurement.Handle == HandleBuffer[Index]) { 601 GetNameFromHandle (HandleBuffer[Index]); // Name is put into mGaugeString 602 break; 603 } 604 } 605 // Ensure that the argument strings are not too long. 606 mGaugeString[DP_GAUGE_STRING_LENGTH] = 0; 607 mUnicodeToken[11] = 0; 608 if (mGaugeString[0] != 0) { 609 // Display the record if it has a valid handle. 610 if (mShowId) { 611 PrintToken ( 612 STRING_TOKEN (STR_DP_HANDLE_VARS2), 613 Count, // 1 based, Which measurement record is being printed 614 Index + 1, // 1 based, Which handle is being printed 615 mGaugeString, 616 mUnicodeToken, 617 ElapsedTime, 618 Measurement.Identifier 619 ); 620 } else { 621 PrintToken ( 622 STRING_TOKEN (STR_DP_HANDLE_VARS), 623 Count, // 1 based, Which measurement record is being printed 624 Index + 1, // 1 based, Which handle is being printed 625 mGaugeString, 626 mUnicodeToken, 627 ElapsedTime 628 ); 629 } 630 } 631 if (ShellGetExecutionBreakFlag ()) { 632 Status = EFI_ABORTED; 633 break; 634 } 635 } 636 } 637 if (HandleBuffer != NULL) { 638 FreePool (HandleBuffer); 639 } 640 return Status; 641 } 642 643 /** 644 Gather and print PEIM data. 645 646 Only prints complete PEIM records 647 648 @retval EFI_SUCCESS The operation was successful. 649 @retval EFI_ABORTED The user aborts the operation. 650 **/ 651 EFI_STATUS 652 ProcessPeims( 653 VOID 654 ) 655 { 656 MEASUREMENT_RECORD Measurement; 657 UINT64 Duration; 658 UINT64 ElapsedTime; 659 EFI_STRING StringPtr; 660 UINTN LogEntryKey; 661 UINTN TIndex; 662 EFI_STRING StringPtrUnknown; 663 EFI_STATUS Status; 664 665 Status = EFI_SUCCESS; 666 667 StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); 668 StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_PEIMS), NULL); 669 PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), 670 (StringPtr == NULL) ? StringPtrUnknown : StringPtr); 671 FreePool (StringPtr); 672 FreePool (StringPtrUnknown); 673 674 if (mShowId) { 675 PrintToken (STRING_TOKEN (STR_DP_PEIM_SECTION2)); 676 } else { 677 PrintToken (STRING_TOKEN (STR_DP_PEIM_SECTION)); 678 } 679 PrintToken (STRING_TOKEN (STR_DP_DASHES)); 680 TIndex = 0; 681 LogEntryKey = 0; 682 while ((LogEntryKey = GetPerformanceMeasurementEx ( 683 LogEntryKey, 684 &Measurement.Handle, 685 &Measurement.Token, 686 &Measurement.Module, 687 &Measurement.StartTimeStamp, 688 &Measurement.EndTimeStamp, 689 &Measurement.Identifier)) != 0) 690 { 691 TIndex++; 692 if ((Measurement.EndTimeStamp == 0) || 693 (AsciiStrnCmp (Measurement.Token, ALit_PEIM, PERF_TOKEN_LENGTH) != 0) 694 ) { 695 continue; 696 } 697 698 Duration = GetDuration (&Measurement); 699 ElapsedTime = DurationInMicroSeconds ( Duration ); // Calculate elapsed time in microseconds 700 if (ElapsedTime >= mInterestThreshold) { 701 // PEIM FILE Handle is the start address of its FFS file that contains its file guid. 702 if (mShowId) { 703 PrintToken (STRING_TOKEN (STR_DP_PEIM_VARS2), 704 TIndex, // 1 based, Which measurement record is being printed 705 Measurement.Handle, // base address 706 Measurement.Handle, // file guid 707 ElapsedTime, 708 Measurement.Identifier 709 ); 710 } else { 711 PrintToken (STRING_TOKEN (STR_DP_PEIM_VARS), 712 TIndex, // 1 based, Which measurement record is being printed 713 Measurement.Handle, // base address 714 Measurement.Handle, // file guid 715 ElapsedTime 716 ); 717 } 718 } 719 if (ShellGetExecutionBreakFlag ()) { 720 Status = EFI_ABORTED; 721 break; 722 } 723 } 724 return Status; 725 } 726 727 /** 728 Gather and print global data. 729 730 Strips out incomplete or "Execution Phase" records 731 Only prints records where Handle is NULL 732 Increment TIndex for every record, even skipped ones, so that we have an 733 indication of every measurement record taken. 734 735 @retval EFI_SUCCESS The operation was successful. 736 @retval EFI_ABORTED The user aborts the operation. 737 **/ 738 EFI_STATUS 739 ProcessGlobal( 740 VOID 741 ) 742 { 743 MEASUREMENT_RECORD Measurement; 744 UINT64 Duration; 745 UINT64 ElapsedTime; 746 EFI_STRING StringPtr; 747 UINTN LogEntryKey; 748 UINTN Index; // Index, or number, of the measurement record being processed 749 EFI_STRING StringPtrUnknown; 750 EFI_STATUS Status; 751 752 Status = EFI_SUCCESS; 753 754 StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); 755 StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_GENERAL), NULL); 756 PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), 757 (StringPtr == NULL) ? StringPtrUnknown: StringPtr); 758 FreePool (StringPtr); 759 FreePool (StringPtrUnknown); 760 761 if (mShowId) { 762 PrintToken (STRING_TOKEN (STR_DP_GLOBAL_SECTION2)); 763 } else { 764 PrintToken (STRING_TOKEN (STR_DP_GLOBAL_SECTION)); 765 } 766 PrintToken (STRING_TOKEN (STR_DP_DASHES)); 767 768 Index = 1; 769 LogEntryKey = 0; 770 771 while ((LogEntryKey = GetPerformanceMeasurementEx ( 772 LogEntryKey, 773 &Measurement.Handle, 774 &Measurement.Token, 775 &Measurement.Module, 776 &Measurement.StartTimeStamp, 777 &Measurement.EndTimeStamp, 778 &Measurement.Identifier)) != 0) 779 { 780 AsciiStrToUnicodeStrS (Measurement.Module, mGaugeString, ARRAY_SIZE (mGaugeString)); 781 AsciiStrToUnicodeStrS (Measurement.Token, mUnicodeToken, ARRAY_SIZE (mUnicodeToken)); 782 mGaugeString[25] = 0; 783 mUnicodeToken[31] = 0; 784 if ( ! ( IsPhase( &Measurement) || 785 (Measurement.Handle != NULL) || 786 (Measurement.EndTimeStamp == 0) 787 )) 788 { 789 Duration = GetDuration (&Measurement); 790 ElapsedTime = DurationInMicroSeconds ( Duration ); 791 if (ElapsedTime >= mInterestThreshold) { 792 if (mShowId) { 793 PrintToken ( 794 STRING_TOKEN (STR_DP_GLOBAL_VARS2), 795 Index, 796 mGaugeString, 797 mUnicodeToken, 798 ElapsedTime, 799 Measurement.Identifier 800 ); 801 } else { 802 PrintToken ( 803 STRING_TOKEN (STR_DP_GLOBAL_VARS), 804 Index, 805 mGaugeString, 806 mUnicodeToken, 807 ElapsedTime 808 ); 809 } 810 } 811 } 812 if (ShellGetExecutionBreakFlag ()) { 813 Status = EFI_ABORTED; 814 break; 815 } 816 Index++; 817 } 818 return Status; 819 } 820 821 /** 822 Gather and print cumulative data. 823 824 Traverse the measurement records and:<BR> 825 For each record with a Token listed in the CumData array:<BR> 826 - Update the instance count and the total, minimum, and maximum durations. 827 Finally, print the gathered cumulative statistics. 828 829 @param[in] CustomCumulativeData A pointer to the cumtom cumulative data. 830 831 **/ 832 VOID 833 ProcessCumulative( 834 IN PERF_CUM_DATA *CustomCumulativeData OPTIONAL 835 ) 836 { 837 UINT64 AvgDur; // the computed average duration 838 UINT64 Dur; 839 UINT64 MinDur; 840 UINT64 MaxDur; 841 EFI_STRING StringPtr; 842 UINTN TIndex; 843 EFI_STRING StringPtrUnknown; 844 845 StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL); 846 StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_CUMULATIVE), NULL); 847 PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER), 848 (StringPtr == NULL) ? StringPtrUnknown: StringPtr); 849 FreePool (StringPtr); 850 FreePool (StringPtrUnknown); 851 852 PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_SECT_1)); 853 PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_SECT_2)); 854 PrintToken (STRING_TOKEN (STR_DP_DASHES)); 855 856 for ( TIndex = 0; TIndex < NumCum; ++TIndex) { 857 if (CumData[TIndex].Count != 0) { 858 AvgDur = DivU64x32 (CumData[TIndex].Duration, CumData[TIndex].Count); 859 AvgDur = DurationInMicroSeconds(AvgDur); 860 Dur = DurationInMicroSeconds(CumData[TIndex].Duration); 861 MaxDur = DurationInMicroSeconds(CumData[TIndex].MaxDur); 862 MinDur = DurationInMicroSeconds(CumData[TIndex].MinDur); 863 864 PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_STATS), 865 CumData[TIndex].Name, 866 CumData[TIndex].Count, 867 Dur, 868 AvgDur, 869 MinDur, 870 MaxDur 871 ); 872 } 873 } 874 875 // 876 // Print the custom cumulative data. 877 // 878 if (CustomCumulativeData != NULL) { 879 if (CustomCumulativeData->Count != 0) { 880 AvgDur = DivU64x32 (CustomCumulativeData->Duration, CustomCumulativeData->Count); 881 AvgDur = DurationInMicroSeconds (AvgDur); 882 Dur = DurationInMicroSeconds (CustomCumulativeData->Duration); 883 MaxDur = DurationInMicroSeconds (CustomCumulativeData->MaxDur); 884 MinDur = DurationInMicroSeconds (CustomCumulativeData->MinDur); 885 } else { 886 AvgDur = 0; 887 Dur = 0; 888 MaxDur = 0; 889 MinDur = 0; 890 } 891 PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_STATS), 892 CustomCumulativeData->Name, 893 CustomCumulativeData->Count, 894 Dur, 895 AvgDur, 896 MinDur, 897 MaxDur 898 ); 899 } 900 } 901
