ShellPkg/DynamicCommand/DpDynamicCommand/Dp.c

   1 /** @file
   2   Shell command for Displaying Performance Metrics.
   3
   4   The Dp command reads performance data and presents it in several
   5   different formats depending upon the needs of the user.  Both
   6   Trace and Measured Profiling information is processed and presented.
   7
   8   Dp uses the "PerformanceLib" to read the measurement records.
   9   The "TimerLib" provides information about the timer, such as frequency,
  10   beginning, and ending counter values.
  11   Measurement records contain identifying information (Handle, Token, Module)
  12   and start and end time values.
  13   Dp uses this information to group records in different ways.  It also uses
  14   timer information to calculate elapsed time for each measurement.
  15
  16   Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.
  17   (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
  18   This program and the accompanying materials
  19   are licensed and made available under the terms and conditions of the BSD License
  20   which accompanies this distribution.  The full text of the license may be found at
  21   http://opensource.org/licenses/bsd-license.php
  22
  23   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  24   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  25 **/
  26
  27 #include "Dp.h"
  28 #include "Literals.h"
  29 #include "DpInternal.h"
  30
  31 #pragma pack(1)
  32
  33 typedef struct {
  34   EFI_ACPI_DESCRIPTION_HEADER  Header;
  35   UINT32                       Entry;
  36 } RSDT_TABLE;
  37
  38 typedef struct {
  39   EFI_ACPI_DESCRIPTION_HEADER  Header;
  40   UINT64                       Entry;
  41 } XSDT_TABLE;
  42
  43 #pragma pack()
  44
  45 EFI_HANDLE   mDpHiiHandle;
  46
  47 typedef struct {
  48   EFI_HANDLE    Handle;
  49   EFI_GUID      ModuleGuid;
  50 } HANDLE_GUID_MAP;
  51
  52 HANDLE_GUID_MAP  *mCacheHandleGuidTable;
  53 UINTN            mCachePairCount = 0;
  54
  55 //
  56 /// Module-Global Variables
  57 ///@{
  58 CHAR16           mGaugeString[DP_GAUGE_STRING_LENGTH + 1];
  59 CHAR16           mUnicodeToken[DXE_PERFORMANCE_STRING_SIZE];
  60 UINT64           mInterestThreshold;
  61 BOOLEAN          mShowId = FALSE;
  62 UINT8            *mBootPerformanceTable;
  63 UINTN            mBootPerformanceTableSize;
  64 BOOLEAN          mPeiPhase = FALSE;
  65 BOOLEAN          mDxePhase = FALSE;
  66
  67 PERF_SUMMARY_DATA SummaryData = { 0 };    ///< Create the SummaryData structure and init. to ZERO.
  68 MEASUREMENT_RECORD  *mMeasurementList = NULL;
  69 UINTN               mMeasurementNum    = 0;
  70
  71 /// Items for which to gather cumulative statistics.
  72 PERF_CUM_DATA CumData[] = {
  73   PERF_INIT_CUM_DATA (LOAD_IMAGE_TOK),
  74   PERF_INIT_CUM_DATA (START_IMAGE_TOK),
  75   PERF_INIT_CUM_DATA (DRIVERBINDING_START_TOK),
  76   PERF_INIT_CUM_DATA (DRIVERBINDING_SUPPORT_TOK)
  77 };
  78
  79 /// Number of items for which we are gathering cumulative statistics.
  80 UINT32 const      NumCum = sizeof(CumData) / sizeof(PERF_CUM_DATA);
  81
  82 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
  83   {L"-v", TypeFlag},   // -v   Verbose Mode
  84   {L"-A", TypeFlag},   // -A   All, Cooked
  85   {L"-R", TypeFlag},   // -R   RAW All
  86   {L"-s", TypeFlag},   // -s   Summary
  87   {L"-x", TypeFlag},   // -x   eXclude Cumulative Items
  88   {L"-i", TypeFlag},   // -i   Display Identifier
  89   {L"-c", TypeValue},  // -c   Display cumulative data.
  90   {L"-n", TypeValue},  // -n # Number of records to display for A and R
  91   {L"-t", TypeValue},  // -t # Threshold of interest
  92   {NULL, TypeMax}
  93   };
  94
  95 ///@}
  96
  97 /**
  98    Display the trailing Verbose information.
  99 **/
 100 VOID
 101 DumpStatistics( void )
 102 {
 103   EFI_STRING                StringPtr;
 104   EFI_STRING                StringPtrUnknown;
 105   StringPtr        = HiiGetString (mDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_STATISTICS), NULL);
 106   StringPtrUnknown = HiiGetString (mDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
 107   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), mDpHiiHandle,
 108               (StringPtr == NULL) ? StringPtrUnknown : StringPtr);
 109   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMTRACE), mDpHiiHandle,      SummaryData.NumTrace);
 110   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMINCOMPLETE), mDpHiiHandle, SummaryData.NumIncomplete);
 111   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPHASES), mDpHiiHandle,     SummaryData.NumSummary);
 112   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMHANDLES), mDpHiiHandle,    SummaryData.NumHandles, SummaryData.NumTrace - SummaryData.NumHandles);
 113   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPEIMS), mDpHiiHandle,      SummaryData.NumPEIMs);
 114   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMGLOBALS), mDpHiiHandle,    SummaryData.NumGlobal);
 115   SHELL_FREE_NON_NULL (StringPtr);
 116   SHELL_FREE_NON_NULL (StringPtrUnknown);
 117 }
 118
 119 /**
 120   This function scan ACPI table in RSDT.
 121
 122   @param  Rsdt        ACPI RSDT
 123   @param  Signature   ACPI table signature
 124
 125   @return ACPI table
 126 **/
 127 VOID *
 128 ScanTableInRSDT (
 129   IN RSDT_TABLE                   *Rsdt,
 130   IN UINT32                       Signature
 131   )
 132 {
 133   UINTN                         Index;
 134   UINT32                        EntryCount;
 135   UINT32                        *EntryPtr;
 136   EFI_ACPI_DESCRIPTION_HEADER   *Table;
 137
 138   EntryCount = (Rsdt->Header.Length - sizeof (EFI_ACPI_DESCRIPTION_HEADER)) / sizeof(UINT32);
 139
 140   EntryPtr = &Rsdt->Entry;
 141   for (Index = 0; Index < EntryCount; Index ++, EntryPtr ++) {
 142     Table = (EFI_ACPI_DESCRIPTION_HEADER*)((UINTN)(*EntryPtr));
 143     if (Table->Signature == Signature) {
 144       return Table;
 145     }
 146   }
 147
 148   return NULL;
 149 }
 150
 151 /**
 152   This function scan ACPI table in XSDT.
 153
 154   @param  Xsdt       ACPI XSDT
 155   @param  Signature  ACPI table signature
 156
 157   @return ACPI table
 158 **/
 159 VOID *
 160 ScanTableInXSDT (
 161   IN XSDT_TABLE                   *Xsdt,
 162   IN UINT32                       Signature
 163   )
 164 {
 165   UINTN                        Index;
 166   UINT32                       EntryCount;
 167   UINT64                       EntryPtr;
 168   UINTN                        BasePtr;
 169   EFI_ACPI_DESCRIPTION_HEADER  *Table;
 170
 171   EntryCount = (Xsdt->Header.Length - sizeof (EFI_ACPI_DESCRIPTION_HEADER)) / sizeof(UINT64);
 172
 173   BasePtr = (UINTN)(&(Xsdt->Entry));
 174   for (Index = 0; Index < EntryCount; Index ++) {
 175     CopyMem (&EntryPtr, (VOID *)(BasePtr + Index * sizeof(UINT64)), sizeof(UINT64));
 176     Table = (EFI_ACPI_DESCRIPTION_HEADER*)((UINTN)(EntryPtr));
 177     if (Table->Signature == Signature) {
 178       return Table;
 179     }
 180   }
 181
 182   return NULL;
 183 }
 184
 185 /**
 186   This function scan ACPI table in RSDP.
 187
 188   @param  Rsdp       ACPI RSDP
 189   @param  Signature  ACPI table signature
 190
 191   @return ACPI table
 192 **/
 193 VOID *
 194 FindAcpiPtr (
 195   IN EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_POINTER *Rsdp,
 196   IN UINT32                                       Signature
 197   )
 198 {
 199   EFI_ACPI_DESCRIPTION_HEADER                    *AcpiTable;
 200   RSDT_TABLE                                     *Rsdt;
 201   XSDT_TABLE                                     *Xsdt;
 202
 203   AcpiTable = NULL;
 204
 205   //
 206   // Check ACPI2.0 table
 207   //
 208   Rsdt = (RSDT_TABLE *)(UINTN)Rsdp->RsdtAddress;
 209   Xsdt = NULL;
 210   if ((Rsdp->Revision >= 2) && (Rsdp->XsdtAddress < (UINT64)(UINTN)-1)) {
 211     Xsdt = (XSDT_TABLE *)(UINTN)Rsdp->XsdtAddress;
 212   }
 213   //
 214   // Check Xsdt
 215   //
 216   if (Xsdt != NULL) {
 217     AcpiTable = ScanTableInXSDT (Xsdt, Signature);
 218   }
 219   //
 220   // Check Rsdt
 221   //
 222   if ((AcpiTable == NULL) && (Rsdt != NULL)) {
 223     AcpiTable = ScanTableInRSDT (Rsdt, Signature);
 224   }
 225
 226   return AcpiTable;
 227 }
 228
 229 /**
 230   Get Boot performance table form Acpi table.
 231
 232 **/
 233 EFI_STATUS
 234 GetBootPerformanceTable (
 235   )
 236 {
 237   EFI_STATUS                  Status;
 238   VOID                        *AcpiTable;
 239   FIRMWARE_PERFORMANCE_TABLE  *FirmwarePerformanceTable;
 240
 241   AcpiTable = NULL;
 242
 243   Status = EfiGetSystemConfigurationTable (
 244              &gEfiAcpi20TableGuid,
 245              &AcpiTable
 246              );
 247   if (EFI_ERROR (Status)) {
 248     Status = EfiGetSystemConfigurationTable (
 249                &gEfiAcpi10TableGuid,
 250                &AcpiTable
 251                  );
 252   }
 253   if (EFI_ERROR(Status) || AcpiTable == NULL) {
 254     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GET_ACPI_TABLE_FAIL), mDpHiiHandle);
 255     return Status;
 256   }
 257
 258   FirmwarePerformanceTable = FindAcpiPtr (
 259                       (EFI_ACPI_5_0_ROOT_SYSTEM_DESCRIPTION_POINTER *)AcpiTable,
 260                       EFI_ACPI_5_0_FIRMWARE_PERFORMANCE_DATA_TABLE_SIGNATURE
 261                       );
 262   if (FirmwarePerformanceTable == NULL) {
 263     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_GET_ACPI_FPDT_FAIL), mDpHiiHandle);
 264     return EFI_NOT_FOUND;
 265   }
 266
 267   mBootPerformanceTable = (UINT8*) (UINTN)FirmwarePerformanceTable->BootPointerRecord.BootPerformanceTablePointer;
 268   mBootPerformanceTableSize = ((BOOT_PERFORMANCE_TABLE *) mBootPerformanceTable)->Header.Length;
 269
 270   return EFI_SUCCESS;
 271 }
 272
 273 /**
 274   Get Handle form Module Guid.
 275
 276   @param  ModuleGuid     Module Guid.
 277   @param  Handle         The handle to be returned.
 278
 279 **/
 280 VOID
 281 GetHandleFormModuleGuid (
 282   IN      EFI_GUID        *ModuleGuid,
 283   IN OUT  EFI_HANDLE      *Handle
 284   )
 285 {
 286   UINTN                             Index;
 287
 288   if (IsZeroGuid (ModuleGuid)) {
 289     *Handle = NULL;
 290   }
 291   //
 292   // Try to get the Handle form the caached array.
 293   //
 294   for (Index = 0; Index < mCachePairCount; Index++) {
 295     if (CompareGuid (ModuleGuid, &mCacheHandleGuidTable[Index].ModuleGuid)) {
 296       *Handle = mCacheHandleGuidTable[Index].Handle;
 297       break;
 298     }
 299   }
 300   if (Index >= mCachePairCount) {
 301     *Handle = NULL;
 302   }
 303 }
 304
 305 /**
 306 Cache the GUID and handle mapping pairs. In order to save time for searching.
 307
 308 **/
 309 EFI_STATUS
 310 BuildCachedGuidHandleTable (
 311   VOID
 312   )
 313 {
 314   EFI_STATUS                        Status;
 315   EFI_HANDLE                        *HandleBuffer;
 316   UINTN                             HandleCount;
 317   UINTN                             Index;
 318   EFI_LOADED_IMAGE_PROTOCOL         *LoadedImage;
 319   EFI_DRIVER_BINDING_PROTOCOL       *DriverBinding;
 320   EFI_GUID                          *TempGuid;
 321   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *FvFilePath;
 322
 323   Status = gBS->LocateHandleBuffer (AllHandles, NULL, NULL, &HandleCount, &HandleBuffer);
 324   if (EFI_ERROR (Status)) {
 325     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_HANDLES_ERROR), mDpHiiHandle, Status);
 326     return Status;
 327   }
 328
 329   mCacheHandleGuidTable = AllocateZeroPool (HandleCount * sizeof (HANDLE_GUID_MAP));
 330   if (mCacheHandleGuidTable == NULL) {
 331     return EFI_OUT_OF_RESOURCES;
 332   }
 333
 334   for (Index = 0; Index < HandleCount; Index++) {
 335     //
 336     // Try Handle as ImageHandle.
 337     //
 338     Status = gBS->HandleProtocol (
 339                   HandleBuffer[Index],
 340                   &gEfiLoadedImageProtocolGuid,
 341                   (VOID**) &LoadedImage
 342                   );
 343     if (EFI_ERROR (Status)) {
 344       //
 345       // Try Handle as Controller Handle
 346       //
 347       Status = gBS->OpenProtocol (
 348                     HandleBuffer[Index],
 349                     &gEfiDriverBindingProtocolGuid,
 350                     (VOID **) &DriverBinding,
 351                     NULL,
 352                     NULL,
 353                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 354                     );
 355       if (!EFI_ERROR (Status)) {
 356         //
 357         // Get Image protocol from ImageHandle
 358         //
 359         Status = gBS->HandleProtocol (
 360                       DriverBinding->ImageHandle,
 361                       &gEfiLoadedImageProtocolGuid,
 362                       (VOID**) &LoadedImage
 363                       );
 364       }
 365     }
 366
 367     if (!EFI_ERROR (Status) && LoadedImage != NULL) {
 368       //
 369       // Get Module Guid from DevicePath.
 370       //
 371       if (LoadedImage->FilePath != NULL &&
 372           LoadedImage->FilePath->Type == MEDIA_DEVICE_PATH &&
 373           LoadedImage->FilePath->SubType == MEDIA_PIWG_FW_FILE_DP
 374          ) {
 375         FvFilePath      = (MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) LoadedImage->FilePath;
 376         TempGuid        = &FvFilePath->FvFileName;
 377
 378         mCacheHandleGuidTable[mCachePairCount].Handle = HandleBuffer[Index];
 379         CopyGuid (&mCacheHandleGuidTable[mCachePairCount].ModuleGuid, TempGuid);
 380         mCachePairCount ++;
 381       }
 382     }
 383   }
 384   if (HandleBuffer != NULL) {
 385     FreePool (HandleBuffer);
 386     HandleBuffer = NULL;
 387   }
 388   return EFI_SUCCESS;
 389 }
 390
 391 /**
 392   Get Measurement form Fpdt records.
 393
 394   @param  RecordHeader        Pointer to the start record.
 395   @param  IsStart             Is start record or End record.
 396   @param  Measurement         Pointer to the measurement which need to be filled.
 397
 398 **/
 399 VOID
 400 GetMeasurementInfo (
 401   IN     EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER  *RecordHeader,
 402   IN     BOOLEAN                                      IsStart,
 403   IN OUT MEASUREMENT_RECORD                           *Measurement
 404   )
 405 {
 406   VOID                                         *ModuleGuid;
 407   EFI_HANDLE                                   StartHandle;
 408
 409   switch (RecordHeader->Type) {
 410   case FPDT_GUID_EVENT_TYPE:
 411     ModuleGuid                    = &(((FPDT_GUID_EVENT_RECORD *)RecordHeader)->Guid);
 412     Measurement->Identifier       = ((UINT32)((FPDT_GUID_EVENT_RECORD *)RecordHeader)->ProgressID);
 413     if (IsStart) {
 414       Measurement->StartTimeStamp = ((FPDT_GUID_EVENT_RECORD *)RecordHeader)->Timestamp;
 415     } else {
 416       Measurement->EndTimeStamp   = ((FPDT_GUID_EVENT_RECORD *)RecordHeader)->Timestamp;
 417     }
 418     switch (Measurement->Identifier) {
 419     case MODULE_START_ID:
 420     case MODULE_END_ID:
 421       if (mPeiPhase) {
 422         Measurement->Token        = ALit_PEIM;
 423         Measurement->Module       = ALit_PEIM;
 424       } else if (mDxePhase) {
 425         Measurement->Token        = ALit_START_IMAGE;
 426         Measurement->Module       = ALit_START_IMAGE;
 427       }
 428       break;
 429     default:
 430       ASSERT(FALSE);
 431     }
 432
 433     if (Measurement->Token != NULL && AsciiStrCmp (Measurement->Token, ALit_PEIM) == 0) {
 434       Measurement->Handle         = &(((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Guid);
 435     } else {
 436       GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
 437       Measurement->Handle = StartHandle;
 438       //
 439       // When no perf entry to record the PEI and DXE phase,
 440       // For start image, we need detect the PEIM and non PEIM here.
 441       //
 442       if (Measurement->Token == NULL) {
 443         if (StartHandle == NULL && !IsZeroGuid (ModuleGuid)) {
 444           Measurement->Token      = ALit_PEIM;
 445           Measurement->Module     = ALit_PEIM;
 446           Measurement->Handle     = ModuleGuid;
 447         } else {
 448           Measurement->Token      = ALit_START_IMAGE;
 449           Measurement->Module     = ALit_START_IMAGE;
 450         }
 451       }
 452     }
 453     break;
 454
 455   case FPDT_DYNAMIC_STRING_EVENT_TYPE:
 456     ModuleGuid                    = &(((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Guid);
 457     Measurement->Identifier       = ((UINT32)((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->ProgressID);
 458     if (IsStart) {
 459       Measurement->StartTimeStamp = ((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
 460     } else {
 461       Measurement->EndTimeStamp   = ((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
 462     }
 463     switch (Measurement->Identifier) {
 464     case MODULE_START_ID:
 465     case MODULE_END_ID:
 466       if (mPeiPhase) {
 467         Measurement->Token        = ALit_PEIM;
 468       } else if (mDxePhase) {
 469         Measurement->Token        = ALit_START_IMAGE;
 470       }
 471       break;
 472
 473     case MODULE_LOADIMAGE_START_ID:
 474     case MODULE_LOADIMAGE_END_ID:
 475       Measurement->Token          = ALit_LOAD_IMAGE;
 476       break;
 477
 478     case MODULE_DB_START_ID:
 479     case MODULE_DB_END_ID:
 480       Measurement->Token          = ALit_DB_START;
 481       break;
 482
 483     case MODULE_DB_SUPPORT_START_ID:
 484     case MODULE_DB_SUPPORT_END_ID:
 485       Measurement->Token          = ALit_DB_SUPPORT;
 486       break;
 487
 488     case MODULE_DB_STOP_START_ID:
 489     case MODULE_DB_STOP_END_ID:
 490       Measurement->Token          = ALit_DB_STOP;
 491       break;
 492
 493     default:
 494       Measurement->Token          = ((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->String;
 495       break;
 496     }
 497
 498     Measurement->Module           = ((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->String;
 499
 500     if (Measurement->Token != NULL && AsciiStrCmp (Measurement->Token, ALit_PEIM) == 0) {
 501       Measurement->Handle         = &(((FPDT_DYNAMIC_STRING_EVENT_RECORD *)RecordHeader)->Guid);
 502     } else {
 503       GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
 504       Measurement->Handle = StartHandle;
 505       //
 506       // When no perf entry to record the PEI and DXE phase,
 507       // For start image, we need detect the PEIM and non PEIM here.
 508       //
 509       if (Measurement->Token == NULL  && (Measurement->Identifier == MODULE_START_ID || Measurement->Identifier == MODULE_END_ID)) {
 510         if (StartHandle == NULL && !IsZeroGuid (ModuleGuid)) {
 511           Measurement->Token      = ALit_PEIM;
 512           Measurement->Handle     = ModuleGuid;
 513         } else {
 514           Measurement->Token      = ALit_START_IMAGE;
 515         }
 516       }
 517     }
 518     break;
 519
 520   case FPDT_GUID_QWORD_EVENT_TYPE:
 521     ModuleGuid                    = &(((FPDT_GUID_QWORD_EVENT_RECORD *)RecordHeader)->Guid);
 522     Measurement->Identifier       = ((UINT32)((FPDT_GUID_QWORD_EVENT_RECORD *)RecordHeader)->ProgressID);
 523     if (IsStart) {
 524       Measurement->StartTimeStamp = ((FPDT_GUID_QWORD_EVENT_RECORD *)RecordHeader)->Timestamp;
 525     } else {
 526       Measurement->EndTimeStamp   = ((FPDT_GUID_QWORD_EVENT_RECORD *)RecordHeader)->Timestamp;
 527     }
 528     switch (Measurement->Identifier) {
 529     case MODULE_DB_START_ID:
 530       Measurement->Token          = ALit_DB_START;
 531       Measurement->Module         = ALit_DB_START;
 532       break;
 533
 534     case MODULE_DB_SUPPORT_START_ID:
 535     case MODULE_DB_SUPPORT_END_ID:
 536       Measurement->Token          = ALit_DB_SUPPORT;
 537       Measurement->Module         = ALit_DB_SUPPORT;
 538       break;
 539
 540     case MODULE_DB_STOP_START_ID:
 541     case MODULE_DB_STOP_END_ID:
 542       Measurement->Token          = ALit_DB_STOP;
 543       Measurement->Module         = ALit_DB_STOP;
 544       break;
 545
 546     case MODULE_LOADIMAGE_START_ID:
 547     case MODULE_LOADIMAGE_END_ID:
 548       Measurement->Token          = ALit_LOAD_IMAGE;
 549       Measurement->Module         = ALit_LOAD_IMAGE;
 550       break;
 551
 552     default:
 553       ASSERT(FALSE);
 554     }
 555     GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
 556     Measurement->Handle = StartHandle;
 557     break;
 558
 559   case  FPDT_GUID_QWORD_STRING_EVENT_TYPE:
 560     ModuleGuid                    = &(((FPDT_GUID_QWORD_STRING_EVENT_RECORD *)RecordHeader)->Guid);
 561     Measurement->Identifier       = ((UINT32)((FPDT_GUID_QWORD_STRING_EVENT_RECORD *)RecordHeader)->ProgressID);
 562     if (IsStart) {
 563       Measurement->StartTimeStamp = ((FPDT_GUID_QWORD_STRING_EVENT_RECORD*)RecordHeader)->Timestamp;
 564     } else {
 565       Measurement->EndTimeStamp   = ((FPDT_GUID_QWORD_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
 566     }
 567     //
 568     // Currently only "DB:Start:" end record with FPDT_GUID_QWORD_STRING_EVENT_TYPE.
 569     //
 570     switch (Measurement->Identifier) {
 571     case MODULE_DB_END_ID:
 572       Measurement->Token          = ALit_DB_START;
 573       Measurement->Module         = ALit_DB_START;
 574       break;
 575     default:
 576       ASSERT(FALSE);
 577     }
 578     GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
 579     Measurement->Handle = StartHandle;
 580     break;
 581
 582   case FPDT_DUAL_GUID_STRING_EVENT_TYPE:
 583     ModuleGuid                    = &(((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->Guid1);
 584     Measurement->Identifier       = ((UINT32)((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->ProgressID);
 585     if (IsStart) {
 586       Measurement->StartTimeStamp = ((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
 587     } else {
 588       Measurement->EndTimeStamp   = ((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->Timestamp;
 589     }
 590     Measurement->Token            = ((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->String;
 591     Measurement->Module           = ((FPDT_DUAL_GUID_STRING_EVENT_RECORD *)RecordHeader)->String;
 592     GetHandleFormModuleGuid(ModuleGuid, &StartHandle);
 593     Measurement->Handle = StartHandle;
 594     break;
 595
 596   default:
 597     break;
 598   }
 599 }
 600
 601 /**
 602   Search the start measurement in the mMeasurementList for the end measurement.
 603
 604   @param  EndMeasureMent        Measurement for end record.
 605
 606 **/
 607 VOID
 608 SearchMeasurement (
 609   IN MEASUREMENT_RECORD                           *EndMeasureMent
 610   )
 611 {
 612   INTN                            Index;
 613
 614   for (Index = mMeasurementNum - 1; Index >= 0; Index--) {
 615     if (AsciiStrCmp (EndMeasureMent->Token, ALit_PEIM) == 0) {
 616       if (mMeasurementList[Index].EndTimeStamp == 0 && EndMeasureMent->Handle!= NULL && mMeasurementList[Index].Handle != NULL&&
 617           CompareGuid(mMeasurementList[Index].Handle, EndMeasureMent->Handle) &&
 618           (AsciiStrCmp (mMeasurementList[Index].Token, EndMeasureMent->Token) == 0) &&
 619           (AsciiStrCmp (mMeasurementList[Index].Module, EndMeasureMent->Module) == 0)) {
 620         mMeasurementList[Index].EndTimeStamp = EndMeasureMent->EndTimeStamp;
 621         break;
 622       }
 623     } else if (EndMeasureMent->Identifier == PERF_CROSSMODULE_END_ID) {
 624       if (mMeasurementList[Index].EndTimeStamp == 0 &&
 625          (AsciiStrCmp (mMeasurementList[Index].Token, EndMeasureMent->Token) == 0) &&
 626          (AsciiStrCmp (mMeasurementList[Index].Module, EndMeasureMent->Module) == 0) &&
 627          mMeasurementList[Index].Identifier == PERF_CROSSMODULE_START_ID) {
 628         mMeasurementList[Index].EndTimeStamp = EndMeasureMent->EndTimeStamp;
 629         break;
 630       }
 631     } else {
 632       if (mMeasurementList[Index].EndTimeStamp == 0 && mMeasurementList[Index].Handle == EndMeasureMent->Handle &&
 633          (AsciiStrCmp (mMeasurementList[Index].Token, EndMeasureMent->Token) == 0) &&
 634          (AsciiStrCmp (mMeasurementList[Index].Module, EndMeasureMent->Module) == 0)) {
 635         mMeasurementList[Index].EndTimeStamp = EndMeasureMent->EndTimeStamp;
 636         break;
 637       }
 638     }
 639   }
 640 }
 641
 642 /**
 643   Generate the measure record array.
 644
 645 **/
 646 EFI_STATUS
 647 BuildMeasurementList (
 648   )
 649 {
 650   EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER  *RecordHeader;
 651   UINT8                                        *PerformanceTablePtr;
 652   UINT16                                       StartProgressId;
 653   UINTN                                        TableLength;
 654   UINT8                                        *StartRecordEvent;
 655   MEASUREMENT_RECORD                           MeasureMent;
 656
 657   mMeasurementList = AllocateZeroPool (mBootPerformanceTableSize);
 658   if (mMeasurementList == NULL) {
 659     return EFI_OUT_OF_RESOURCES;
 660   }
 661
 662   TableLength         = sizeof (BOOT_PERFORMANCE_TABLE);
 663   PerformanceTablePtr = (mBootPerformanceTable + TableLength);
 664
 665   while (TableLength < mBootPerformanceTableSize) {
 666     RecordHeader      = (EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER*) PerformanceTablePtr;
 667     StartRecordEvent  = (UINT8 *)RecordHeader;
 668     StartProgressId   = ((FPDT_GUID_EVENT_RECORD *)StartRecordEvent)->ProgressID;
 669
 670     //
 671     // If the record with ProgressId 0, the record doesn't appear in pairs. The timestamp in the record is the EndTimeStamp, its StartTimeStamp is 0.
 672     // If the record is the start record, fill the info to the measurement in the mMeasurementList.
 673     // If the record is the end record, find the related start measurement in the mMeasurementList and fill the EndTimeStamp.
 674     //
 675     if (StartProgressId == 0) {
 676       GetMeasurementInfo (RecordHeader, FALSE, &(mMeasurementList[mMeasurementNum]));
 677       mMeasurementNum ++;
 678     } else if (((StartProgressId >= PERF_EVENTSIGNAL_START_ID && ((StartProgressId & 0x000F) == 0)) ||
 679         (StartProgressId < PERF_EVENTSIGNAL_START_ID && ((StartProgressId & 0x0001) != 0)))) {
 680       //
 681       // Since PEIM and StartImage has same Type and ID when PCD PcdEdkiiFpdtStringRecordEnableOnly = FALSE
 682       // So we need to identify these two kinds of record through different phase.
 683       //
 684       if(StartProgressId == PERF_CROSSMODULE_START_ID ){
 685         if (AsciiStrCmp (((FPDT_DYNAMIC_STRING_EVENT_RECORD *)StartRecordEvent)->String, ALit_PEI) == 0) {
 686           mPeiPhase = TRUE;
 687         } else if (AsciiStrCmp (((FPDT_DYNAMIC_STRING_EVENT_RECORD *)StartRecordEvent)->String, ALit_DXE) == 0) {
 688           mDxePhase = TRUE;
 689           mPeiPhase = FALSE;
 690         }
 691       }
 692       // Get measurement info form the start record to the mMeasurementList.
 693       GetMeasurementInfo (RecordHeader, TRUE, &(mMeasurementList[mMeasurementNum]));
 694       mMeasurementNum ++;
 695     } else {
 696       ZeroMem(&MeasureMent, sizeof(MEASUREMENT_RECORD));
 697       GetMeasurementInfo (RecordHeader, FALSE, &MeasureMent);
 698       SearchMeasurement (&MeasureMent);
 699     }
 700     TableLength         += RecordHeader->Length;
 701     PerformanceTablePtr += RecordHeader->Length;
 702   }
 703   return EFI_SUCCESS;
 704 }
 705
 706 /**
 707   Initialize the cumulative data.
 708
 709 **/
 710 VOID
 711 InitCumulativeData (
 712   VOID
 713   )
 714 {
 715   UINTN                             Index;
 716
 717   for (Index = 0; Index < NumCum; ++Index) {
 718     CumData[Index].Count = 0;
 719     CumData[Index].MinDur = PERF_MAXDUR;
 720     CumData[Index].MaxDur = 0;
 721     CumData[Index].Duration = 0;
 722   }
 723 }
 724
 725 /**
 726   Initialize the Summary data.
 727
 728 **/
 729 VOID
 730 InitSummaryData (
 731   VOID
 732   )
 733 {
 734   SummaryData.NumTrace      = 0;
 735   SummaryData.NumIncomplete = 0;
 736   SummaryData.NumSummary    = 0;
 737   SummaryData.NumHandles    = 0;
 738   SummaryData.NumPEIMs      = 0;
 739   SummaryData.NumGlobal     = 0;
 740 }
 741
 742 /**
 743   Dump performance data.
 744
 745   @param[in]  ImageHandle     The image handle.
 746   @param[in]  SystemTable     The system table.
 747
 748   @retval SHELL_SUCCESS            Command completed successfully.
 749   @retval SHELL_INVALID_PARAMETER  Command usage error.
 750   @retval SHELL_ABORTED            The user aborts the operation.
 751   @retval value                    Unknown error.
 752 **/
 753 SHELL_STATUS
 754 RunDp (
 755   IN EFI_HANDLE               ImageHandle,
 756   IN EFI_SYSTEM_TABLE         *SystemTable
 757   )
 758 {
 759   LIST_ENTRY                *ParamPackage;
 760   CONST CHAR16              *CmdLineArg;
 761   EFI_STATUS                Status;
 762
 763   PERFORMANCE_PROPERTY      *PerformanceProperty;
 764   UINTN                     Number2Display;
 765
 766   EFI_STRING                StringPtr;
 767   BOOLEAN                   SummaryMode;
 768   BOOLEAN                   VerboseMode;
 769   BOOLEAN                   AllMode;
 770   BOOLEAN                   RawMode;
 771   BOOLEAN                   ExcludeMode;
 772   BOOLEAN                   CumulativeMode;
 773   CONST CHAR16              *CustomCumulativeToken;
 774   PERF_CUM_DATA             *CustomCumulativeData;
 775   UINTN                     NameSize;
 776   SHELL_STATUS              ShellStatus;
 777   TIMER_INFO                TimerInfo;
 778
 779   StringPtr   = NULL;
 780   SummaryMode = FALSE;
 781   VerboseMode = FALSE;
 782   AllMode     = FALSE;
 783   RawMode     = FALSE;
 784   ExcludeMode = FALSE;
 785   CumulativeMode = FALSE;
 786   CustomCumulativeData = NULL;
 787   ShellStatus = SHELL_SUCCESS;
 788
 789   //
 790   // initialize the shell lib (we must be in non-auto-init...)
 791   //
 792   Status = ShellInitialize();
 793   ASSERT_EFI_ERROR(Status);
 794
 795   //
 796   // Process Command Line arguments
 797   //
 798   Status = ShellCommandLineParse (ParamList, &ParamPackage, NULL, TRUE);
 799   if (EFI_ERROR(Status)) {
 800     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_INVALID_ARG), mDpHiiHandle);
 801     return SHELL_INVALID_PARAMETER;
 802   }
 803
 804   //
 805   // Boolean options
 806   //
 807   VerboseMode = ShellCommandLineGetFlag (ParamPackage, L"-v");
 808   SummaryMode = (BOOLEAN) (ShellCommandLineGetFlag (ParamPackage, L"-S") || ShellCommandLineGetFlag (ParamPackage, L"-s"));
 809   AllMode     = ShellCommandLineGetFlag (ParamPackage, L"-A");
 810   RawMode     = ShellCommandLineGetFlag (ParamPackage, L"-R");
 811   ExcludeMode = ShellCommandLineGetFlag (ParamPackage, L"-x");
 812   mShowId     = ShellCommandLineGetFlag (ParamPackage, L"-i");
 813   CumulativeMode = ShellCommandLineGetFlag (ParamPackage, L"-c");
 814
 815   // Options with Values
 816   CmdLineArg  = ShellCommandLineGetValue (ParamPackage, L"-n");
 817   if (CmdLineArg == NULL) {
 818     Number2Display = DEFAULT_DISPLAYCOUNT;
 819   } else {
 820     Number2Display = StrDecimalToUintn(CmdLineArg);
 821     if (Number2Display == 0) {
 822       Number2Display = MAXIMUM_DISPLAYCOUNT;
 823     }
 824   }
 825
 826   CmdLineArg  = ShellCommandLineGetValue (ParamPackage, L"-t");
 827   if (CmdLineArg == NULL) {
 828     mInterestThreshold = DEFAULT_THRESHOLD;  // 1ms := 1,000 us
 829   } else {
 830     mInterestThreshold = StrDecimalToUint64(CmdLineArg);
 831   }
 832
 833
 834   //
 835   // DP dump performance data by parsing FPDT table in ACPI table.
 836   // Folloing 3 steps are to get the measurement form the FPDT table.
 837   //
 838
 839   //
 840   //1. Get FPDT from ACPI table.
 841   //
 842   Status = GetBootPerformanceTable ();
 843   if (EFI_ERROR (Status)) {
 844     ShellStatus = Status;
 845     goto Done;
 846   }
 847
 848   //
 849   //2. Cache the ModuleGuid and hanlde mapping table.
 850   //
 851   Status = BuildCachedGuidHandleTable();
 852   if (EFI_ERROR (Status)) {
 853     ShellStatus = Status;
 854     goto Done;
 855   }
 856
 857   //
 858   //3. Build the measurement array form the FPDT records.
 859   //
 860   Status = BuildMeasurementList ();
 861   if (EFI_ERROR (Status)) {
 862     ShellStatus = SHELL_OUT_OF_RESOURCES;
 863     goto Done;
 864   }
 865
 866   //
 867   // Initialize the pre-defined cumulative data.
 868   //
 869   InitCumulativeData ();
 870
 871   //
 872   // Initialize the Summary data.
 873   //
 874   InitSummaryData ();
 875
 876   //
 877   // Init the custom cumulative data.
 878   //
 879   CustomCumulativeToken = ShellCommandLineGetValue (ParamPackage, L"-c");
 880   if (CustomCumulativeToken != NULL) {
 881     CustomCumulativeData = AllocateZeroPool (sizeof (PERF_CUM_DATA));
 882     if (CustomCumulativeData == NULL) {
 883       ShellStatus = SHELL_OUT_OF_RESOURCES;
 884       goto Done;
 885     }
 886     CustomCumulativeData->MinDur = PERF_MAXDUR;
 887     CustomCumulativeData->MaxDur = 0;
 888     CustomCumulativeData->Count  = 0;
 889     CustomCumulativeData->Duration = 0;
 890     NameSize = StrLen (CustomCumulativeToken) + 1;
 891     CustomCumulativeData->Name   = AllocateZeroPool (NameSize);
 892     if (CustomCumulativeData->Name == NULL) {
 893       ShellStatus = SHELL_OUT_OF_RESOURCES;
 894       goto Done;
 895     }
 896     UnicodeStrToAsciiStrS (CustomCumulativeToken, CustomCumulativeData->Name, NameSize);
 897   }
 898
 899   //
 900   // Timer specific processing
 901   //
 902   // Get the Performance counter characteristics:
 903   //          Freq = Frequency in Hz
 904   //    StartCount = Value loaded into the counter when it starts counting
 905   //      EndCount = Value counter counts to before it needs to be reset
 906   //
 907   Status = EfiGetSystemConfigurationTable (&gPerformanceProtocolGuid, (VOID **) &PerformanceProperty);
 908   if (EFI_ERROR (Status) || (PerformanceProperty == NULL)) {
 909     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_PERF_PROPERTY_NOT_FOUND), mDpHiiHandle);
 910     goto Done;
 911   }
 912
 913   TimerInfo.Frequency  = (UINT32)DivU64x32 (PerformanceProperty->Frequency, 1000);
 914   TimerInfo.StartCount = 0;
 915   TimerInfo.EndCount   = 0xFFFF;
 916   TimerInfo.CountUp = TRUE;
 917
 918   //
 919   // Print header
 920   //
 921   // print DP's build version
 922   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_BUILD_REVISION), mDpHiiHandle, DP_MAJOR_VERSION, DP_MINOR_VERSION);
 923
 924   // print performance timer characteristics
 925   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_KHZ), mDpHiiHandle, TimerInfo.Frequency);
 926
 927   if (VerboseMode && !RawMode) {
 928     StringPtr = HiiGetString (mDpHiiHandle,
 929                   (EFI_STRING_ID) (TimerInfo.CountUp ? STRING_TOKEN (STR_DP_UP) : STRING_TOKEN (STR_DP_DOWN)), NULL);
 930     ASSERT (StringPtr != NULL);
 931     // Print Timer count range and direction
 932     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_TIMER_PROPERTIES), mDpHiiHandle,
 933                 StringPtr,
 934                 TimerInfo.StartCount,
 935                 TimerInfo.EndCount
 936                 );
 937     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_VERBOSE_THRESHOLD), mDpHiiHandle, mInterestThreshold);
 938   }
 939
 940 /****************************************************************************
 941 ****            Print Sections based on command line options
 942 ****
 943 ****  Option modes have the following priority:
 944 ****    v Verbose     --  Valid in combination with any other options
 945 ****    t Threshold   --  Modifies All, Raw, and Cooked output
 946 ****                      Default is 0 for All and Raw mode
 947 ****                      Default is DEFAULT_THRESHOLD for "Cooked" mode
 948 ****    n Number2Display  Used by All and Raw mode.  Otherwise ignored.
 949 ****    A All         --  R and S options are ignored
 950 ****    R Raw         --  S option is ignored
 951 ****    s Summary     --  Modifies "Cooked" output only
 952 ****    Cooked (Default)
 953 ****************************************************************************/
 954   GatherStatistics (CustomCumulativeData);
 955   if (CumulativeMode) {
 956     ProcessCumulative (CustomCumulativeData);
 957   } else if (AllMode) {
 958     Status = DumpAllTrace( Number2Display, ExcludeMode);
 959     if (Status == EFI_ABORTED) {
 960       ShellStatus = SHELL_ABORTED;
 961       goto Done;
 962     }
 963   } else if (RawMode) {
 964     Status = DumpRawTrace( Number2Display, ExcludeMode);
 965     if (Status == EFI_ABORTED) {
 966       ShellStatus = SHELL_ABORTED;
 967       goto Done;
 968     }
 969   } else {
 970     //------------- Begin Cooked Mode Processing
 971     ProcessPhases ();
 972     if ( ! SummaryMode) {
 973       Status = ProcessHandles ( ExcludeMode);
 974       if (Status == EFI_ABORTED) {
 975         ShellStatus = SHELL_ABORTED;
 976         goto Done;
 977       }
 978
 979       Status = ProcessPeims ();
 980       if (Status == EFI_ABORTED) {
 981         ShellStatus = SHELL_ABORTED;
 982         goto Done;
 983       }
 984
 985       Status = ProcessGlobal ();
 986       if (Status == EFI_ABORTED) {
 987         ShellStatus = SHELL_ABORTED;
 988         goto Done;
 989       }
 990
 991        ProcessCumulative (NULL);
 992     }
 993   } //------------- End of Cooked Mode Processing
 994   if ( VerboseMode || SummaryMode) {
 995     DumpStatistics();
 996   }
 997
 998 Done:
 999   if (ParamPackage != NULL) {
1000     ShellCommandLineFreeVarList (ParamPackage);
1001   }
1002   SHELL_FREE_NON_NULL (StringPtr);
1003   if (CustomCumulativeData != NULL) {
1004     SHELL_FREE_NON_NULL (CustomCumulativeData->Name);
1005   }
1006   SHELL_FREE_NON_NULL (CustomCumulativeData);
1007
1008   SHELL_FREE_NON_NULL (mMeasurementList);
1009
1010   SHELL_FREE_NON_NULL (mCacheHandleGuidTable);
1011
1012   mMeasurementNum = 0;
1013   mCachePairCount = 0;
1014   return ShellStatus;
1015 }
1016
1017
1018 /**
1019   Retrive HII package list from ImageHandle and publish to HII database.
1020
1021   @param ImageHandle            The image handle of the process.
1022
1023   @return HII handle.
1024 **/
1025 EFI_HANDLE
1026 InitializeHiiPackage (
1027   EFI_HANDLE                  ImageHandle
1028   )
1029 {
1030   EFI_STATUS                  Status;
1031   EFI_HII_PACKAGE_LIST_HEADER *PackageList;
1032   EFI_HANDLE                  HiiHandle;
1033
1034   //
1035   // Retrieve HII package list from ImageHandle
1036   //
1037   Status = gBS->OpenProtocol (
1038                   ImageHandle,
1039                   &gEfiHiiPackageListProtocolGuid,
1040                   (VOID **)&PackageList,
1041                   ImageHandle,
1042                   NULL,
1043                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1044                   );
1045   ASSERT_EFI_ERROR (Status);
1046   if (EFI_ERROR (Status)) {
1047     return NULL;
1048   }
1049
1050   //
1051   // Publish HII package list to HII Database.
1052   //
1053   Status = gHiiDatabase->NewPackageList (
1054                            gHiiDatabase,
1055                            PackageList,
1056                            NULL,
1057                            &HiiHandle
1058                            );
1059   ASSERT_EFI_ERROR (Status);
1060   if (EFI_ERROR (Status)) {
1061     return NULL;
1062   }
1063   return HiiHandle;
1064 }