MdeModulePkg: Update performance library instances

Update the performance library instances in MdeModulePkg
to implement the APIs used for new added Perf macros.

V2:
Share the common logics of creating FPDT record for
new added Perf macros and existing Perf macros.

Cc: Liming Gao <liming.gao@intel.com>
Cc: Star Zeng <star.zeng@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Dandan Bi <dandan.bi@intel.com>
Reviewed-by: Liming Gao <liming.gao@intel.com>

1 files changed, 400 insertions, 232 deletions

diff --git a/MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.c b/MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.c
index f770a35a99..cd1b0e34ef 100644
--- a/MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.c
+++ b/MdeModulePkg/Library/PeiPerformanceLib/PeiPerformanceLib.c
@@ -23,6 +23,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #include <PiPei.h>

 

 #include <Guid/ExtendedFirmwarePerformance.h>

+#include <Guid/PerformanceMeasurement.h>

 

 #include <Library/PerformanceLib.h>

 #include <Library/DebugLib.h>

@@ -33,7 +34,85 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #include <Library/BaseMemoryLib.h>

 

 #define  STRING_SIZE            (FPDT_STRING_EVENT_RECORD_NAME_LENGTH * sizeof (CHAR8))

-#define  MAX_RECORD_SIZE        (sizeof (FPDT_DYNAMIC_STRING_EVENT_RECORD) + STRING_SIZE)

+#define  PEI_MAX_RECORD_SIZE    (sizeof (FPDT_DUAL_GUID_STRING_EVENT_RECORD) + STRING_SIZE)

+

+

+/**

+  Return the pointer to the FPDT record in the allocated memory.

+

+  @param  RecordSize                The size of FPDT record.

+  @param  FpdtRecordPtr             Pointer the FPDT record in the allocated memory.

+  @param  PeiPerformanceLogHeader   Pointer to the header of the PEI Performance records in the GUID Hob.

+

+  @retval EFI_SUCCESS               Successfully get the pointer to the FPDT record.

+  @retval EFI_OUT_OF_RESOURCES      Ran out of space to store the records.

+**/

+EFI_STATUS

+GetFpdtRecordPtr (

+  IN     UINT8                     RecordSize,

+  IN OUT FPDT_RECORD_PTR           *FpdtRecordPtr,

+  IN OUT FPDT_PEI_EXT_PERF_HEADER  **PeiPerformanceLogHeader

+)

+{

+  UINT16                                PeiPerformanceLogEntries;

+  UINTN                                 PeiPerformanceSize;

+  UINT8                                 *PeiFirmwarePerformance;

+  EFI_HOB_GUID_TYPE                     *GuidHob;

+

+  //

+  // Get the number of PeiPerformanceLogEntries form PCD.

+  //

+  PeiPerformanceLogEntries = (UINT16) (PcdGet16 (PcdMaxPeiPerformanceLogEntries16) != 0 ?

+                                       PcdGet16 (PcdMaxPeiPerformanceLogEntries16) :

+                                       PcdGet8 (PcdMaxPeiPerformanceLogEntries));

+

+  //

+  // Create GUID HOB Data.

+  //

+  GuidHob = GetFirstGuidHob (&gEdkiiFpdtExtendedFirmwarePerformanceGuid);

+  PeiFirmwarePerformance = NULL;

+  while (GuidHob != NULL) {

+    //

+    // PEI Performance HOB was found, then return the existing one.

+    //

+    PeiFirmwarePerformance  = (UINT8*)GET_GUID_HOB_DATA (GuidHob);

+    *PeiPerformanceLogHeader = (FPDT_PEI_EXT_PERF_HEADER *)PeiFirmwarePerformance;

+    if (!(*PeiPerformanceLogHeader)->HobIsFull && (*PeiPerformanceLogHeader)->SizeOfAllEntries + RecordSize > (UINTN)(PeiPerformanceLogEntries * PEI_MAX_RECORD_SIZE)) {

+      (*PeiPerformanceLogHeader)->HobIsFull = TRUE;

+    }

+    if (!(*PeiPerformanceLogHeader)->HobIsFull && (*PeiPerformanceLogHeader)->SizeOfAllEntries + RecordSize <= (UINTN)(PeiPerformanceLogEntries * PEI_MAX_RECORD_SIZE)) {

+      FpdtRecordPtr->RecordHeader = (EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER *)(PeiFirmwarePerformance + sizeof (FPDT_PEI_EXT_PERF_HEADER) + (*PeiPerformanceLogHeader)->SizeOfAllEntries);

+      break;

+    }

+    //

+    // Previous HOB is used, then find next one.

+    //

+    GuidHob = GetNextGuidHob (&gEdkiiFpdtExtendedFirmwarePerformanceGuid, GET_NEXT_HOB (GuidHob));

+  }

+

+  if (GuidHob == NULL) {

+    //

+    // PEI Performance HOB was not found, then build one.

+    //

+    PeiPerformanceSize      = sizeof (FPDT_PEI_EXT_PERF_HEADER) +

+                              PEI_MAX_RECORD_SIZE * PeiPerformanceLogEntries;

+    PeiFirmwarePerformance  = (UINT8*)BuildGuidHob (&gEdkiiFpdtExtendedFirmwarePerformanceGuid, PeiPerformanceSize);

+    if (PeiFirmwarePerformance != NULL) {

+      ZeroMem (PeiFirmwarePerformance, PeiPerformanceSize);

+      (*PeiPerformanceLogHeader) = (FPDT_PEI_EXT_PERF_HEADER *)PeiFirmwarePerformance;

+      FpdtRecordPtr->RecordHeader = (EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER *)(PeiFirmwarePerformance + sizeof (FPDT_PEI_EXT_PERF_HEADER));

+    }

+  }

+

+  if (PeiFirmwarePerformance == NULL) {

+    //

+    // there is no enough resource to store performance data

+    //

+    return EFI_OUT_OF_RESOURCES;

+  }

+

+  return EFI_SUCCESS;

+}

 

 /**

 Check whether the Token is a known one which is uesed by core.

@@ -100,248 +179,193 @@ IsKnownID (
 }

 

 /**

-  Get the FPDT record info.

+  Get the FPDT record identifier.

 

-  @param  IsStart                 TRUE if the performance log is start log.

-  @param  Handle                  Pointer to environment specific context used

-                                  to identify the component being measured.

-  @param  Token                   Pointer to a Null-terminated ASCII string

-                                  that identifies the component being measured.

-  @param  Module                  Pointer to a Null-terminated ASCII string

-                                  that identifies the module being measured.

-  @param  RecordInfo              On return, pointer to the info of the record.

+  @param Attribute                The attribute of the Record.

+                                  PerfStartEntry: Start Record.

+                                  PerfEndEntry: End Record.

+  @param  Handle                  Pointer to environment specific context used to identify the component being measured.

+  @param  String                  Pointer to a Null-terminated ASCII string that identifies the component being measured.

+  @param  ProgressID              On return, pointer to the ProgressID.

 

-  @retval EFI_SUCCESS             Get record info successfully.

-  @retval EFI_UNSUPPORTED         No matched FPDT record.

+  @retval EFI_SUCCESS              Get record info successfully.

+  @retval EFI_INVALID_PARAMETER    No matched FPDT record.

 

 **/

 EFI_STATUS

-GetFpdtRecordInfo (

-  IN BOOLEAN                 IsStart,

+GetFpdtRecordId (

+  IN BOOLEAN                 Attribute,

   IN CONST VOID              *Handle,

-  IN CONST CHAR8             *Token,

-  IN CONST CHAR8             *Module,

-  OUT FPDT_BASIC_RECORD_INFO *RecordInfo

+  IN CONST CHAR8             *String,

+  OUT UINT16                 *ProgressID

   )

 {

-  UINTN     StringSize;

-  UINT16    RecordType;

-

-  RecordType = FPDT_DYNAMIC_STRING_EVENT_TYPE;

-

   //

   // Get the ProgressID based on the Token.

   // When PcdEdkiiFpdtStringRecordEnableOnly is TRUE, all records are with type of FPDT_DYNAMIC_STRING_EVENT_TYPE.

   //

-  if (Token != NULL) {

-    if (AsciiStrCmp (Token, LOAD_IMAGE_TOK) == 0) {               // "LoadImage:"

-      if (IsStart) {

-        RecordInfo->ProgressID = MODULE_LOADIMAGE_START_ID;

+  if (String != NULL) {

+    if (AsciiStrCmp (String, LOAD_IMAGE_TOK) == 0) {               // "LoadImage:"

+      if (Attribute == PerfStartEntry) {

+        *ProgressID = MODULE_LOADIMAGE_START_ID;

       } else {

-        RecordInfo->ProgressID = MODULE_LOADIMAGE_END_ID;

+        *ProgressID = MODULE_LOADIMAGE_END_ID;

       }

-      if(!PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

-        RecordType = FPDT_GUID_QWORD_EVENT_TYPE;

-      }

-    } else if (AsciiStrCmp (Token, SEC_TOK) == 0 ||               // "SEC"

-               AsciiStrCmp (Token, PEI_TOK) == 0) {               // "PEI"

-      if (IsStart) {

-        RecordInfo->ProgressID = PERF_CROSSMODULE_START_ID;

+    } else if (AsciiStrCmp (String, SEC_TOK) == 0 ||               // "SEC"

+               AsciiStrCmp (String, PEI_TOK) == 0) {               // "PEI"

+      if (Attribute == PerfStartEntry) {

+        *ProgressID = PERF_CROSSMODULE_START_ID;

       } else {

-        RecordInfo->ProgressID = PERF_CROSSMODULE_END_ID;

+        *ProgressID = PERF_CROSSMODULE_END_ID;

       }

-    } else if (AsciiStrCmp (Token, PEIM_TOK) == 0) {              // "PEIM"

-      if (IsStart) {

-        RecordInfo->ProgressID = MODULE_START_ID;

+    } else if (AsciiStrCmp (String, PEIM_TOK) == 0) {              // "PEIM"

+      if (Attribute == PerfStartEntry) {

+        *ProgressID = MODULE_START_ID;

       } else {

-        RecordInfo->ProgressID = MODULE_END_ID;

-      }

-      if(!PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

-        RecordType = FPDT_GUID_EVENT_TYPE;

+        *ProgressID = MODULE_END_ID;

       }

     } else {                                                      //Pref used in Modules.

-      if (IsStart) {

-        RecordInfo->ProgressID = PERF_INMODULE_START_ID;

+      if (Attribute == PerfStartEntry) {

+        *ProgressID = PERF_INMODULE_START_ID;

       } else {

-        RecordInfo->ProgressID = PERF_INMODULE_END_ID;

+        *ProgressID = PERF_INMODULE_END_ID;

       }

     }

-  } else if (Module != NULL || Handle != NULL) {                  //Pref used in Modules.

-    if (IsStart) {

-      RecordInfo->ProgressID = PERF_INMODULE_START_ID;

+  } else if (Handle != NULL) {                                    //Pref used in Modules.

+    if (Attribute == PerfStartEntry) {

+      *ProgressID = PERF_INMODULE_START_ID;

     } else {

-      RecordInfo->ProgressID = PERF_INMODULE_END_ID;

+      *ProgressID = PERF_INMODULE_END_ID;

     }

   } else {

-    return EFI_UNSUPPORTED;

+    return EFI_INVALID_PARAMETER;

   }

 

-  //

-  // Get the Guid and string.

-  //

-  if(PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

-    RecordInfo->RecordSize = sizeof (FPDT_DYNAMIC_STRING_EVENT_RECORD) + STRING_SIZE;

-  } else {

-    switch (RecordType) {

-    case FPDT_GUID_EVENT_TYPE:

-      RecordInfo->RecordSize = sizeof (FPDT_GUID_EVENT_RECORD);

-      break;

+  return EFI_SUCCESS;

+}

 

-    case FPDT_GUID_QWORD_EVENT_TYPE:

-      RecordInfo->RecordSize = sizeof (FPDT_GUID_QWORD_EVENT_RECORD);

-      break;

+/**

+  Copies the string from Source into Destination and updates Length with the

+  size of the string.

 

-    case FPDT_DYNAMIC_STRING_EVENT_TYPE:

-      if (Token != NULL) {

-        StringSize = AsciiStrSize (Token);

-      } else if (Module != NULL) {

-        StringSize = AsciiStrSize (Module);

-      } else {

-        StringSize = STRING_SIZE;

-      }

-      RecordInfo->RecordSize  = (UINT8)(sizeof (FPDT_DYNAMIC_STRING_EVENT_RECORD) + StringSize);

-      break;

+  @param Destination - destination of the string copy

+  @param Source      - pointer to the source string which will get copied

+  @param Length      - pointer to a length variable to be updated

 

-    default:

-      //

-      // Other type is unsupported in PEI phase yet, return EFI_UNSUPPORTED

-      //

-      return EFI_UNSUPPORTED;

+**/

+VOID

+CopyStringIntoPerfRecordAndUpdateLength (

+  IN OUT CHAR8  *Destination,

+  IN     CONST CHAR8  *Source,

+  IN OUT UINT8  *Length

+  )

+{

+  UINTN  StringLen;

+  UINTN  DestMax;

+

+  ASSERT (Source != NULL);

+

+  if (PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

+    DestMax = STRING_SIZE;

+  } else {

+    DestMax = AsciiStrSize (Source);

+    if (DestMax > STRING_SIZE) {

+      DestMax = STRING_SIZE;

     }

   }

-  RecordInfo->Type = RecordType;

-  return EFI_SUCCESS;

+  StringLen = AsciiStrLen (Source);

+  if (StringLen >= DestMax) {

+    StringLen = DestMax -1;

+  }

+

+  AsciiStrnCpyS(Destination, DestMax, Source, StringLen);

+  *Length += (UINT8)DestMax;

+

+  return;

 }

 

+

 /**

   Convert PEI performance log to FPDT String boot record.

 

-  @param  IsStart                 TRUE if the performance log is start log.

-  @param  Handle                  Pointer to environment specific context used

-                                  to identify the component being measured.

-  @param  Token                   Pointer to a Null-terminated ASCII string

-                                  that identifies the component being measured.

-  @param  Module                  Pointer to a Null-terminated ASCII string

-                                  that identifies the module being measured.

-  @param  Ticker                  64-bit time stamp.

-  @param  Identifier              32-bit identifier. If the value is 0, the created record

-                                  is same as the one created by StartGauge of PERFORMANCE_PROTOCOL.

-

-  @retval EFI_SUCCESS              Add FPDT boot record.

-  @retval EFI_OUT_OF_RESOURCES     There are not enough resources to record the measurement.

-  @retval EFI_UNSUPPORTED          No matched FPDT record.

+  @param CallerIdentifier  - Image handle or pointer to caller ID GUID.

+  @param Guid              - Pointer to a GUID.

+  @param String            - Pointer to a string describing the measurement.

+  @param Ticker            - 64-bit time stamp.

+  @param Address           - Pointer to a location in memory relevant to the measurement.

+  @param PerfId            - Performance identifier describing the type of measurement.

+  @param Attribute         - The attribute of the measurement. According to attribute can create a start

+                             record for PERF_START/PERF_START_EX, or a end record for PERF_END/PERF_END_EX,

+                             or a general record for other Perf macros.

+

+  @retval EFI_SUCCESS           - Successfully created performance record.

+  @retval EFI_OUT_OF_RESOURCES  - Ran out of space to store the records.

+  @retval EFI_INVALID_PARAMETER - Invalid parameter passed to function - NULL

+                                  pointer or invalid PerfId.

 

 **/

 EFI_STATUS

-InsertPeiFpdtMeasurement (

-  IN BOOLEAN      IsStart,

-  IN CONST VOID   *Handle,  OPTIONAL

-  IN CONST CHAR8  *Token,   OPTIONAL

-  IN CONST CHAR8  *Module,  OPTIONAL

-  IN UINT64       Ticker,

-  IN UINT32       Identifier

+InsertFpdtRecord (

+  IN CONST VOID                        *CallerIdentifier,  OPTIONAL

+  IN CONST VOID                        *Guid,    OPTIONAL

+  IN CONST CHAR8                       *String,  OPTIONAL

+  IN       UINT64                      Ticker,

+  IN       UINT64                      Address,  OPTIONAL

+  IN       UINT16                      PerfId,

+  IN       PERF_MEASUREMENT_ATTRIBUTE  Attribute

   )

 {

-  EFI_HOB_GUID_TYPE                     *GuidHob;

-  UINTN                                 PeiPerformanceSize;

-  UINT8                                 *PeiFirmwarePerformance;

-  FPDT_PEI_EXT_PERF_HEADER              *PeiPerformanceLogHeader;

   FPDT_RECORD_PTR                       FpdtRecordPtr;

-  FPDT_BASIC_RECORD_INFO                RecordInfo;

   CONST VOID                            *ModuleGuid;

-  UINTN                                 DestMax;

-  UINTN                                 StrLength;

   CONST CHAR8                           *StringPtr;

   EFI_STATUS                            Status;

-  UINT16                                PeiPerformanceLogEntries;

   UINT64                                TimeStamp;

+  FPDT_PEI_EXT_PERF_HEADER              *PeiPerformanceLogHeader;

 

   StringPtr = NULL;

   FpdtRecordPtr.RecordHeader = NULL;

   PeiPerformanceLogHeader = NULL;

 

   //

-  // Get record info (type, size, ProgressID and Module Guid).

-  //

-  Status = GetFpdtRecordInfo (IsStart, Handle, Token, Module, &RecordInfo);

-  if (EFI_ERROR (Status)) {

-    return Status;

-  }

-

-  //

-  // If PERF_START()/PERF_END() have specified the ProgressID,it has high priority.

-  // !!! Note: If the Perf is not the known Token used in the core but have same

-  // ID with the core Token, this case will not be supported.

-  // And in currtnt usage mode, for the unkown ID, there is a general rule:

-  // If it is start pref: the lower 4 bits of the ID should be 0.

-  // If it is end pref: the lower 4 bits of the ID should not be 0.

-  // If input ID doesn't follow the rule, we will adjust it.

+  // 1. Get the Perf Id for records from PERF_START/PERF_END, PERF_START_EX/PERF_END_EX.

+  //    notes: For other Perf macros (Attribute == PerfEntry), their Id is known.

   //

-  if ((Identifier != 0) && (IsKnownID (Identifier)) && (!IsKnownTokens (Token))) {

-    return EFI_UNSUPPORTED;

-  } else if ((Identifier != 0) && (!IsKnownID (Identifier)) && (!IsKnownTokens (Token))) {

-    if (IsStart && ((Identifier & 0x000F) != 0)) {

-      Identifier &= 0xFFF0;

-    } else if ((!IsStart) && ((Identifier & 0x000F) == 0)) {

-      Identifier += 1;

-    }

-    RecordInfo.ProgressID = (UINT16)Identifier;

-  }

-

-  //

-  // Get the number of PeiPerformanceLogEntries form PCD.

-  //

-  PeiPerformanceLogEntries = (UINT16) (PcdGet16 (PcdMaxPeiPerformanceLogEntries16) != 0 ?

-                                       PcdGet16 (PcdMaxPeiPerformanceLogEntries16) :

-                                       PcdGet8 (PcdMaxPeiPerformanceLogEntries));

-

-  //

-  // Create GUID HOB Data.

-  //

-  GuidHob = GetFirstGuidHob (&gEdkiiFpdtExtendedFirmwarePerformanceGuid);

-  PeiFirmwarePerformance = NULL;

-  while (GuidHob != NULL) {

-    //

-    // PEI Performance HOB was found, then return the existing one.

-    //

-    PeiFirmwarePerformance  = (UINT8*)GET_GUID_HOB_DATA (GuidHob);

-    PeiPerformanceLogHeader = (FPDT_PEI_EXT_PERF_HEADER *)PeiFirmwarePerformance;

-    if (!PeiPerformanceLogHeader->HobIsFull && PeiPerformanceLogHeader->SizeOfAllEntries + RecordInfo.RecordSize > PeiPerformanceLogEntries * MAX_RECORD_SIZE) {

-      PeiPerformanceLogHeader->HobIsFull = TRUE;

-    }

-    if (!PeiPerformanceLogHeader->HobIsFull && PeiPerformanceLogHeader->SizeOfAllEntries + RecordInfo.RecordSize <= PeiPerformanceLogEntries * MAX_RECORD_SIZE) {

-      FpdtRecordPtr.RecordHeader = (EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER *)(PeiFirmwarePerformance + sizeof (FPDT_PEI_EXT_PERF_HEADER) + PeiPerformanceLogHeader->SizeOfAllEntries);

-      break;

-    }

-    //

-    // Previous HOB is used, then find next one.

-    //

-    GuidHob = GetNextGuidHob (&gEdkiiFpdtExtendedFirmwarePerformanceGuid, GET_NEXT_HOB (GuidHob));

-  }

-

-  if (GuidHob == NULL) {

+  if (Attribute != PerfEntry) {

     //

-    // PEI Performance HOB was not found, then build one.

+    // If PERF_START_EX()/PERF_END_EX() have specified the ProgressID,it has high priority.

+    // !!! Note: If the Perf is not the known Token used in the core but have same

+    // ID with the core Token, this case will not be supported.

+    // And in currtnt usage mode, for the unkown ID, there is a general rule:

+    // If it is start pref: the lower 4 bits of the ID should be 0.

+    // If it is end pref: the lower 4 bits of the ID should not be 0.

+    // If input ID doesn't follow the rule, we will adjust it.

     //

-    PeiPerformanceSize      = sizeof (FPDT_PEI_EXT_PERF_HEADER) +

-                              MAX_RECORD_SIZE * PeiPerformanceLogEntries;

-    PeiFirmwarePerformance  = (UINT8*)BuildGuidHob (&gEdkiiFpdtExtendedFirmwarePerformanceGuid, PeiPerformanceSize);

-    if (PeiFirmwarePerformance != NULL) {

-      ZeroMem (PeiFirmwarePerformance, PeiPerformanceSize);

+    if ((PerfId != 0) && (IsKnownID (PerfId)) && (!IsKnownTokens (String))) {

+      return EFI_UNSUPPORTED;

+    } else if ((PerfId != 0) && (!IsKnownID (PerfId)) && (!IsKnownTokens (String))) {

+      if (Attribute == PerfStartEntry && ((PerfId & 0x000F) != 0)) {

+        PerfId &= 0xFFF0;

+      } else if ((Attribute == PerfEndEntry) && ((PerfId & 0x000F) == 0)) {

+        PerfId += 1;

+      }

+    } else if (PerfId == 0) {

+      Status = GetFpdtRecordId (Attribute, CallerIdentifier, String, &PerfId);

+      if (EFI_ERROR (Status)) {

+        return Status;

+      }

     }

-    PeiPerformanceLogHeader = (FPDT_PEI_EXT_PERF_HEADER *)PeiFirmwarePerformance;

-    FpdtRecordPtr.RecordHeader = (EFI_ACPI_5_0_FPDT_PERFORMANCE_RECORD_HEADER *)(PeiFirmwarePerformance + sizeof (FPDT_PEI_EXT_PERF_HEADER));

   }

 

-  if (PeiFirmwarePerformance == NULL) {

-    //

-    // there is no enough resource to store performance data

-    //

-    return EFI_OUT_OF_RESOURCES;

+  //

+  // 2. Get the buffer to store the FPDT record.

+  //

+  Status = GetFpdtRecordPtr (PEI_MAX_RECORD_SIZE, &FpdtRecordPtr, &PeiPerformanceLogHeader);

+  if (EFI_ERROR (Status)) {

+    return Status;

   }

 

   //

-  // Get the TimeStamp.

+  // 3 Get the TimeStamp.

   //

   if (Ticker == 0) {

     Ticker    = GetPerformanceCounter ();

@@ -353,70 +377,138 @@ InsertPeiFpdtMeasurement (
   }

 

   //

-  // Get the ModuleGuid.

+  // 4.Get the ModuleGuid.

   //

-  if (Handle != NULL) {

-    ModuleGuid = Handle;

+  if (CallerIdentifier != NULL) {

+    ModuleGuid = CallerIdentifier;

   } else {

     ModuleGuid = &gEfiCallerIdGuid;

   }

 

-  switch (RecordInfo.Type) {

-  case FPDT_GUID_EVENT_TYPE:

-    FpdtRecordPtr.GuidEvent->Header.Type       = FPDT_GUID_EVENT_TYPE;

-    FpdtRecordPtr.GuidEvent->Header.Length     = RecordInfo.RecordSize;;

-    FpdtRecordPtr.GuidEvent->Header.Revision   = FPDT_RECORD_REVISION_1;

-    FpdtRecordPtr.GuidEvent->ProgressID        = RecordInfo.ProgressID;

-    FpdtRecordPtr.GuidEvent->Timestamp         = TimeStamp;

-    CopyMem (&FpdtRecordPtr.GuidEvent->Guid, ModuleGuid, sizeof (EFI_GUID));

-    PeiPerformanceLogHeader->SizeOfAllEntries += RecordInfo.RecordSize;

+  //

+  // 5. Fill in the FPDT record according to different Performance Identifier.

+  //

+  switch (PerfId) {

+  case MODULE_START_ID:

+  case MODULE_END_ID:

+    StringPtr = PEIM_TOK;

+    if (!PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

+      FpdtRecordPtr.GuidEvent->Header.Type       = FPDT_GUID_EVENT_TYPE;

+      FpdtRecordPtr.GuidEvent->Header.Length     = sizeof (FPDT_GUID_EVENT_RECORD);

+      FpdtRecordPtr.GuidEvent->Header.Revision   = FPDT_RECORD_REVISION_1;

+      FpdtRecordPtr.GuidEvent->ProgressID        = PerfId;

+      FpdtRecordPtr.GuidEvent->Timestamp         = TimeStamp;

+      CopyMem (&FpdtRecordPtr.GuidEvent->Guid, ModuleGuid, sizeof (EFI_GUID));

+    }

     break;

 

-  case FPDT_GUID_QWORD_EVENT_TYPE:

-    FpdtRecordPtr.GuidQwordEvent->Header.Type     = FPDT_GUID_QWORD_EVENT_TYPE;

-    FpdtRecordPtr.GuidQwordEvent->Header.Length   = RecordInfo.RecordSize;;

-    FpdtRecordPtr.GuidQwordEvent->Header.Revision = FPDT_RECORD_REVISION_1;

-    FpdtRecordPtr.GuidQwordEvent->ProgressID      = RecordInfo.ProgressID;

-    FpdtRecordPtr.GuidQwordEvent->Timestamp       = TimeStamp;

-    PeiPerformanceLogHeader->LoadImageCount++;

-    FpdtRecordPtr.GuidQwordEvent->Qword           = PeiPerformanceLogHeader->LoadImageCount;

-    CopyMem (&FpdtRecordPtr.GuidQwordEvent->Guid, ModuleGuid, sizeof (EFI_GUID));

-    PeiPerformanceLogHeader->SizeOfAllEntries += RecordInfo.RecordSize;

+  case MODULE_LOADIMAGE_START_ID:

+  case MODULE_LOADIMAGE_END_ID:

+    StringPtr = LOAD_IMAGE_TOK;

+    if (!PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

+      FpdtRecordPtr.GuidQwordEvent->Header.Type     = FPDT_GUID_QWORD_EVENT_TYPE;

+      FpdtRecordPtr.GuidQwordEvent->Header.Length   = sizeof (FPDT_GUID_QWORD_EVENT_RECORD);

+      FpdtRecordPtr.GuidQwordEvent->Header.Revision = FPDT_RECORD_REVISION_1;

+      FpdtRecordPtr.GuidQwordEvent->ProgressID      = PerfId;

+      FpdtRecordPtr.GuidQwordEvent->Timestamp       = TimeStamp;

+      if (PerfId == MODULE_LOADIMAGE_START_ID) {

+        PeiPerformanceLogHeader->LoadImageCount++;

+      }

+      FpdtRecordPtr.GuidQwordEvent->Qword           = PeiPerformanceLogHeader->LoadImageCount;

+      CopyMem (&FpdtRecordPtr.GuidQwordEvent->Guid, ModuleGuid, sizeof (EFI_GUID));

+    }

     break;

 

-  case FPDT_DYNAMIC_STRING_EVENT_TYPE:

-    FpdtRecordPtr.DynamicStringEvent->Header.Type       = FPDT_DYNAMIC_STRING_EVENT_TYPE;

-    FpdtRecordPtr.DynamicStringEvent->Header.Length     = RecordInfo.RecordSize;

-    FpdtRecordPtr.DynamicStringEvent->Header.Revision   = FPDT_RECORD_REVISION_1;

-    FpdtRecordPtr.DynamicStringEvent->ProgressID        = RecordInfo.ProgressID;

-    FpdtRecordPtr.DynamicStringEvent->Timestamp         = TimeStamp;

-    CopyMem (&FpdtRecordPtr.DynamicStringEvent->Guid, ModuleGuid, sizeof (EFI_GUID));

-    PeiPerformanceLogHeader->SizeOfAllEntries += RecordInfo.RecordSize;

-

-    if (Token != NULL) {

-      StringPtr                     = Token;

-    } else if (Module != NULL) {

-      StringPtr                     = Module;

+  case PERF_EVENTSIGNAL_START_ID:

+  case PERF_EVENTSIGNAL_END_ID:

+  case PERF_CALLBACK_START_ID:

+  case PERF_CALLBACK_END_ID:

+    if (String != NULL && AsciiStrLen (String) != 0) {

+      StringPtr = String;

+    } else {

+      StringPtr = "unknown name";

     }

-    if (StringPtr != NULL && AsciiStrLen (StringPtr) != 0) {

-      DestMax                       = (RecordInfo.RecordSize - sizeof (FPDT_DYNAMIC_STRING_EVENT_RECORD)) / sizeof (CHAR8);

-      StrLength                     = AsciiStrLen (StringPtr);

-      if (StrLength >= DestMax) {

-        StrLength                   = DestMax -1;

-      }

-      AsciiStrnCpyS (FpdtRecordPtr.DynamicStringEvent->String, DestMax, StringPtr, StrLength);

+    if (!PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

+      FpdtRecordPtr.DualGuidStringEvent->Header.Type      = FPDT_DUAL_GUID_STRING_EVENT_TYPE;

+      FpdtRecordPtr.DualGuidStringEvent->Header.Length    = sizeof (FPDT_DUAL_GUID_STRING_EVENT_RECORD);

+      FpdtRecordPtr.DualGuidStringEvent->Header.Revision  = FPDT_RECORD_REVISION_1;

+      FpdtRecordPtr.DualGuidStringEvent->ProgressID       = PerfId;

+      FpdtRecordPtr.DualGuidStringEvent->Timestamp        = TimeStamp;

+      CopyMem (&FpdtRecordPtr.DualGuidStringEvent->Guid1, ModuleGuid, sizeof (FpdtRecordPtr.DualGuidStringEvent->Guid1));

+      CopyMem (&FpdtRecordPtr.DualGuidStringEvent->Guid2, Guid, sizeof (FpdtRecordPtr.DualGuidStringEvent->Guid2));

+    }

+    break;

+

+  case PERF_EVENT_ID:

+  case PERF_FUNCTION_START_ID:

+  case PERF_FUNCTION_END_ID:

+  case PERF_INMODULE_START_ID:

+  case PERF_INMODULE_END_ID:

+  case PERF_CROSSMODULE_START_ID:

+  case PERF_CROSSMODULE_END_ID:

+    if (String != NULL && AsciiStrLen (String) != 0) {

+      StringPtr = String;

     } else {

-      AsciiStrCpyS (FpdtRecordPtr.DynamicStringEvent->String, FPDT_STRING_EVENT_RECORD_NAME_LENGTH, "unknown name");

+      StringPtr = "unknown name";

+    }

+    if (!PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

+      FpdtRecordPtr.DynamicStringEvent->Header.Type       = FPDT_DYNAMIC_STRING_EVENT_TYPE;

+      FpdtRecordPtr.DynamicStringEvent->Header.Length     = sizeof (FPDT_DYNAMIC_STRING_EVENT_RECORD);

+      FpdtRecordPtr.DynamicStringEvent->Header.Revision   = FPDT_RECORD_REVISION_1;

+      FpdtRecordPtr.DynamicStringEvent->ProgressID        = PerfId;

+      FpdtRecordPtr.DynamicStringEvent->Timestamp         = TimeStamp;

+      CopyMem (&FpdtRecordPtr.DynamicStringEvent->Guid, ModuleGuid, sizeof (EFI_GUID));

+      CopyStringIntoPerfRecordAndUpdateLength (FpdtRecordPtr.DynamicStringEvent->String, StringPtr, &FpdtRecordPtr.DynamicStringEvent->Header.Length);

     }

     break;

 

   default:

-    //

-    // Record is not supported in current PEI phase, return EFI_ABORTED

-    //

-    return EFI_UNSUPPORTED;

+    if (Attribute != PerfEntry) {

+     if (String != NULL && AsciiStrLen (String) != 0) {

+       StringPtr = String;

+     } else {

+       StringPtr = "unknown name";

+     }

+     if (!PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

+       FpdtRecordPtr.DynamicStringEvent->Header.Type       = FPDT_DYNAMIC_STRING_EVENT_TYPE;

+       FpdtRecordPtr.DynamicStringEvent->Header.Length     = sizeof (FPDT_DYNAMIC_STRING_EVENT_RECORD);

+       FpdtRecordPtr.DynamicStringEvent->Header.Revision   = FPDT_RECORD_REVISION_1;

+       FpdtRecordPtr.DynamicStringEvent->ProgressID        = PerfId;

+       FpdtRecordPtr.DynamicStringEvent->Timestamp         = TimeStamp;

+       CopyMem (&FpdtRecordPtr.DynamicStringEvent->Guid, ModuleGuid, sizeof (FpdtRecordPtr.DynamicStringEvent->Guid));

+       CopyStringIntoPerfRecordAndUpdateLength (FpdtRecordPtr.DynamicStringEvent->String, StringPtr, &FpdtRecordPtr.DynamicStringEvent->Header.Length);

+     }

+  } else {

+    return EFI_INVALID_PARAMETER;

+  }

+   break;

+  }

+

+  //

+  // 5.2 When PcdEdkiiFpdtStringRecordEnableOnly==TRUE, create string record for all Perf entries.

+  //

+  if (PcdGetBool (PcdEdkiiFpdtStringRecordEnableOnly)) {

+    FpdtRecordPtr.DynamicStringEvent->Header.Type       = FPDT_DYNAMIC_STRING_EVENT_TYPE;

+    FpdtRecordPtr.DynamicStringEvent->Header.Length     = sizeof (FPDT_DYNAMIC_STRING_EVENT_RECORD);

+    FpdtRecordPtr.DynamicStringEvent->Header.Revision   = FPDT_RECORD_REVISION_1;

+    FpdtRecordPtr.DynamicStringEvent->ProgressID        = PerfId;

+    FpdtRecordPtr.DynamicStringEvent->Timestamp         = TimeStamp;

+    if (Guid != NULL) {

+      //

+      // Cache the event guid in string event record.

+      //

+      CopyMem (&FpdtRecordPtr.DynamicStringEvent->Guid, Guid, sizeof (EFI_GUID));

+    } else {

+      CopyMem (&FpdtRecordPtr.DynamicStringEvent->Guid, ModuleGuid, sizeof (EFI_GUID));

+    }

+    CopyStringIntoPerfRecordAndUpdateLength (FpdtRecordPtr.DynamicStringEvent->String, StringPtr, &FpdtRecordPtr.DynamicStringEvent->Header.Length);

   }

 

+  //

+  // 6. Update the length of the used buffer after fill in the record.

+  //

+  PeiPerformanceLogHeader->SizeOfAllEntries += FpdtRecordPtr.RecordHeader->Length;

+

   return EFI_SUCCESS;

 }

 

@@ -454,7 +546,18 @@ StartPerformanceMeasurementEx (
   IN UINT32       Identifier

   )

 {

-  return InsertPeiFpdtMeasurement (TRUE, Handle, Token, Module, TimeStamp, Identifier);

+  CONST CHAR8     *String;

+

+  if (Token != NULL) {

+    String = Token;

+  } else if (Module != NULL) {

+    String = Module;

+  } else {

+    String = NULL;

+  }

+

+  return (RETURN_STATUS)InsertFpdtRecord (Handle, NULL, String, TimeStamp, 0, (UINT16)Identifier, PerfStartEntry);

+

 }

 

 /**

@@ -489,7 +592,17 @@ EndPerformanceMeasurementEx (
   IN UINT32       Identifier

   )

 {

-  return InsertPeiFpdtMeasurement (FALSE, Handle, Token, Module, TimeStamp, Identifier);

+  CONST CHAR8     *String;

+

+  if (Token != NULL) {

+    String = Token;

+  } else if (Module != NULL) {

+    String = Module;

+  } else {

+    String = NULL;

+  }

+

+  return (RETURN_STATUS)InsertFpdtRecord (Handle, NULL, String, TimeStamp, 0, (UINT16)Identifier, PerfEndEntry);

 }

 

 /**

@@ -582,7 +695,7 @@ StartPerformanceMeasurement (
   IN UINT64       TimeStamp

   )

 {

-  return InsertPeiFpdtMeasurement (TRUE, Handle, Token, Module, TimeStamp, 0);

+  return StartPerformanceMeasurementEx (Handle, Token, Module, TimeStamp, 0);

 }

 

 /**

@@ -614,7 +727,7 @@ EndPerformanceMeasurement (
   IN UINT64       TimeStamp

   )

 {

-  return InsertPeiFpdtMeasurement (FALSE, Handle, Token, Module, TimeStamp, 0);

+  return EndPerformanceMeasurementEx (Handle, Token, Module, TimeStamp, 0);

 }

 

 /**

@@ -692,3 +805,58 @@ PerformanceMeasurementEnabled (
 {

   return (BOOLEAN) ((PcdGet8(PcdPerformanceLibraryPropertyMask) & PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED) != 0);

 }

+

+/**

+  Create performance record with event description and a timestamp.

+

+  @param CallerIdentifier  - Image handle or pointer to caller ID GUID

+  @param Guid              - Pointer to a GUID

+  @param String            - Pointer to a string describing the measurement

+  @param Address           - Pointer to a location in memory relevant to the measurement

+  @param Identifier        - Performance identifier describing the type of measurement

+

+  @retval RETURN_SUCCESS           - Successfully created performance record

+  @retval RETURN_OUT_OF_RESOURCES  - Ran out of space to store the records

+  @retval RETURN_INVALID_PARAMETER - Invalid parameter passed to function - NULL

+                                     pointer or invalid PerfId

+

+**/

+RETURN_STATUS

+EFIAPI

+LogPerformanceMeasurement (

+  IN CONST VOID   *CallerIdentifier,

+  IN CONST VOID   *Guid,    OPTIONAL

+  IN CONST CHAR8  *String,  OPTIONAL

+  IN UINT64       Address, OPTIONAL

+  IN UINT32       Identifier

+  )

+{

+  return (RETURN_STATUS)InsertFpdtRecord (CallerIdentifier, Guid, String, 0, Address, (UINT16)Identifier, PerfEntry);

+}

+

+/**

+  Check whether the specified performance measurement can be logged.

+

+  This function returns TRUE when the PERFORMANCE_LIBRARY_PROPERTY_MEASUREMENT_ENABLED bit of PcdPerformanceLibraryPropertyMask is set

+  and the Type disable bit in PcdPerformanceLibraryPropertyMask is not set.

+

+  @param Type        - Type of the performance measurement entry.

+

+  @retval TRUE         The performance measurement can be logged.

+  @retval FALSE        The performance measurement can NOT be logged.

+

+**/

+BOOLEAN

+EFIAPI

+LogPerformanceMeasurementEnabled (

+  IN  CONST UINTN        Type

+  )

+{

+  //

+  // When Performance measurement is enabled and the type is not filtered, the performance can be logged.

+  //

+  if (PerformanceMeasurementEnabled () && (PcdGet8(PcdPerformanceLibraryPropertyMask) & Type) == 0) {

+    return TRUE;

+  }

+  return FALSE;

+}