DpUtilities.c

Go to the documentation of this file.

 
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/DebugLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/PeCoffGetEntryPointLib.h>
#include <Library/PrintLib.h>
#include <Library/HiiLib.h>
#include <Library/PcdLib.h>
#include <Library/UefiLib.h>
#include <Library/DevicePathLib.h>
#include <Library/HandleParsingLib.h>
 
#include <Pi/PiFirmwareFile.h>
#include <Library/DxeServicesLib.h>
 
#include <Protocol/LoadedImage.h>
#include <Protocol/DriverBinding.h>
#include <Protocol/ComponentName2.h>
#include <Protocol/DevicePath.h>
 
#include <Guid/Performance.h>
 
#include "Dp.h"
#include "Literals.h"
#include "DpInternal.h"
 
UINT64
GetDuration (
  IN OUT MEASUREMENT_RECORD  *Measurement
  )
{
  UINT64   Duration;
  BOOLEAN  Error;
 
  if (Measurement->EndTimeStamp == 0) {
    return 0;
  }
 
  Duration = Measurement->EndTimeStamp - Measurement->StartTimeStamp;
  Error    = (BOOLEAN)(Duration > Measurement->EndTimeStamp);
 
  if (Error) {
    DEBUG ((DEBUG_ERROR, ALit_TimerLibError));
    Duration = 0;
  }
 
  return Duration;
}
 
BOOLEAN
IsPhase (
  IN MEASUREMENT_RECORD  *Measurement
  )
{
  BOOLEAN  RetVal;
 
  RetVal = (BOOLEAN)(
                     ((AsciiStrCmp (Measurement->Token, ALit_SEC) == 0)    ||
                      (AsciiStrCmp (Measurement->Token, ALit_PEI) == 0)    ||
                      (AsciiStrCmp (Measurement->Token, ALit_DXE) == 0)    ||
                      (AsciiStrCmp (Measurement->Token, ALit_BDS) == 0))
                     );
  return RetVal;
}
 
BOOLEAN
IsCorePerf (
  IN MEASUREMENT_RECORD  *Measurement
  )
{
  BOOLEAN  RetVal;
 
  RetVal = (BOOLEAN)(
                     ((Measurement->Identifier == MODULE_START_ID)            ||
                      (Measurement->Identifier == MODULE_END_ID)              ||
                      (Measurement->Identifier == MODULE_LOADIMAGE_START_ID)  ||
                      (Measurement->Identifier == MODULE_LOADIMAGE_END_ID)    ||
                      (Measurement->Identifier == MODULE_DB_START_ID)         ||
                      (Measurement->Identifier == MODULE_DB_END_ID)           ||
                      (Measurement->Identifier == MODULE_DB_SUPPORT_START_ID) ||
                      (Measurement->Identifier == MODULE_DB_SUPPORT_END_ID)   ||
                      (Measurement->Identifier == MODULE_DB_STOP_START_ID)    ||
                      (Measurement->Identifier == MODULE_DB_STOP_START_ID))
                     );
  return RetVal;
}
 
VOID
DpGetShortPdbFileName (
  IN  CHAR8   *PdbFileName,
  OUT CHAR16  *UnicodeBuffer
  )
{
  UINTN  IndexA;    // Current work location within an ASCII string.
  UINTN  IndexU;    // Current work location within a Unicode string.
  UINTN  StartIndex;
  UINTN  EndIndex;
 
  ZeroMem (UnicodeBuffer, (DP_GAUGE_STRING_LENGTH + 1) * sizeof (CHAR16));
 
  if (PdbFileName == NULL) {
    StrnCpyS (UnicodeBuffer, DP_GAUGE_STRING_LENGTH + 1, L" ", 1);
  } else {
    StartIndex = 0;
    for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++) {
    }
 
    for (IndexA = 0; PdbFileName[IndexA] != 0; IndexA++) {
      if ((PdbFileName[IndexA] == '\\') || (PdbFileName[IndexA] == '/')) {
        StartIndex = IndexA + 1;
      }
 
      if (PdbFileName[IndexA] == '.') {
        EndIndex = IndexA;
      }
    }
 
    IndexU = 0;
    for (IndexA = StartIndex; IndexA < EndIndex; IndexA++) {
      UnicodeBuffer[IndexU] = (CHAR16)PdbFileName[IndexA];
      IndexU++;
      if (IndexU >= DP_GAUGE_STRING_LENGTH) {
        UnicodeBuffer[DP_GAUGE_STRING_LENGTH] = 0;
        break;
      }
    }
  }
}
 
VOID
DpGetNameFromHandle (
  IN EFI_HANDLE  Handle
  )
{
  EFI_STATUS                    Status;
  EFI_LOADED_IMAGE_PROTOCOL     *Image;
  CHAR8                         *PdbFileName;
  EFI_DRIVER_BINDING_PROTOCOL   *DriverBinding;
  EFI_STRING                    StringPtr;
  EFI_DEVICE_PATH_PROTOCOL      *LoadedImageDevicePath;
  EFI_DEVICE_PATH_PROTOCOL      *DevicePath;
  EFI_GUID                      *NameGuid;
  CHAR16                        *NameString;
  UINTN                         StringSize;
  CHAR8                         *PlatformLanguage;
  CHAR8                         *BestLanguage;
  EFI_COMPONENT_NAME2_PROTOCOL  *ComponentName2;
 
  Image                 = NULL;
  LoadedImageDevicePath = NULL;
  DevicePath            = NULL;
 
  //
  // Method 1: Get the name string from image PDB
  //
  Status = gBS->HandleProtocol (
                  Handle,
                  &gEfiLoadedImageProtocolGuid,
                  (VOID **)&Image
                  );
 
  if (EFI_ERROR (Status)) {
    Status = gBS->OpenProtocol (
                    Handle,
                    &gEfiDriverBindingProtocolGuid,
                    (VOID **)&DriverBinding,
                    NULL,
                    NULL,
                    EFI_OPEN_PROTOCOL_GET_PROTOCOL
                    );
    if (!EFI_ERROR (Status)) {
      Status = gBS->HandleProtocol (
                      DriverBinding->ImageHandle,
                      &gEfiLoadedImageProtocolGuid,
                      (VOID **)&Image
                      );
    }
  }
 
  if (!EFI_ERROR (Status)) {
    PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase);
 
    if (PdbFileName != NULL) {
      DpGetShortPdbFileName (PdbFileName, mGaugeString);
      return;
    }
  }
 
  //
  // Method 2: Get the name string from ComponentName2 protocol
  //
  Status = gBS->HandleProtocol (
                  Handle,
                  &gEfiComponentName2ProtocolGuid,
                  (VOID **)&ComponentName2
                  );
  if (!EFI_ERROR (Status)) {
    //
    // Firstly use platform language setting, secondly use driver's first supported language.
    //
    GetVariable2 (L"PlatformLang", &gEfiGlobalVariableGuid, (VOID **)&PlatformLanguage, NULL);
    BestLanguage = GetBestLanguage (
                     ComponentName2->SupportedLanguages,
                     FALSE,
                     (PlatformLanguage != NULL) ? PlatformLanguage : "",
                     ComponentName2->SupportedLanguages,
                     NULL
                     );
    SHELL_FREE_NON_NULL (PlatformLanguage);
 
    Status = ComponentName2->GetDriverName (
                               ComponentName2,
                               BestLanguage != NULL ? BestLanguage : "en-US",
                               &StringPtr
                               );
    if (!EFI_ERROR (Status)) {
      SHELL_FREE_NON_NULL (BestLanguage);
      StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, StringPtr, DP_GAUGE_STRING_LENGTH);
      mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;
      return;
    }
  }
 
  Status = gBS->HandleProtocol (
                  Handle,
                  &gEfiLoadedImageDevicePathProtocolGuid,
                  (VOID **)&LoadedImageDevicePath
                  );
  if (!EFI_ERROR (Status) && (LoadedImageDevicePath != NULL)) {
    DevicePath = LoadedImageDevicePath;
  } else if (Image != NULL) {
    DevicePath = Image->FilePath;
  }
 
  if (DevicePath != NULL) {
    //
    // Try to get image GUID from image DevicePath
    //
    NameGuid = NULL;
    while (!IsDevicePathEndType (DevicePath)) {
      NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)DevicePath);
      if (NameGuid != NULL) {
        break;
      }
 
      DevicePath = NextDevicePathNode (DevicePath);
    }
 
    if (NameGuid != NULL) {
      //
      // Try to get the image's FFS UI section by image GUID
      //
      NameString = NULL;
      StringSize = 0;
      Status     = GetSectionFromAnyFv (
                     NameGuid,
                     EFI_SECTION_USER_INTERFACE,
                     0,
                     (VOID **)&NameString,
                     &StringSize
                     );
 
      if (!EFI_ERROR (Status)) {
        //
        // Method 3. Get the name string from FFS UI section
        //
        StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, NameString, DP_GAUGE_STRING_LENGTH);
        mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;
        FreePool (NameString);
      } else {
        //
        // Method 4: Get the name string from image GUID
        //
        UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", NameGuid);
      }
 
      return;
    } else {
      //
      // Method 5: Get the name string from image DevicePath
      //
      NameString = ConvertDevicePathToText (DevicePath, TRUE, FALSE);
      if (NameString != NULL) {
        StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, NameString, DP_GAUGE_STRING_LENGTH);
        mGaugeString[DP_GAUGE_STRING_LENGTH] = 0;
        FreePool (NameString);
        return;
      }
    }
  }
 
  //
  // Method 6: Unknown Driver Name
  //
  StringPtr = HiiGetString (mDpHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL);
  ASSERT (StringPtr != NULL);
  StrnCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, StringPtr, DP_GAUGE_STRING_LENGTH);
  FreePool (StringPtr);
}
 
UINT64
DurationInMicroSeconds (
  IN UINT64  Duration
  )
{
  return DivU64x32 (Duration, 1000);
}
 
INTN
GetCumulativeItem (
  IN MEASUREMENT_RECORD  *Measurement
  )
{
  INTN  Index;
 
  for ( Index = 0; Index < (INTN)NumCum; ++Index) {
    if (AsciiStrCmp (Measurement->Token, CumData[Index].Name) == 0) {
      return Index;  // Exit, we found a match
    }
  }
 
  // If the for loop exits, Token was not found.
  return -1;   // Indicate failure
}