PerformancePkg/Dp_App/DpUtilities.c

   1 /** @file
   2   Utility functions used by the Dp application.
   3
   4   Copyright (c) 2009 - 2016, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 **/
  13
  14 #include <Library/BaseLib.h>
  15 #include <Library/BaseMemoryLib.h>
  16 #include <Library/MemoryAllocationLib.h>
  17 #include <Library/DebugLib.h>
  18 #include <Library/UefiBootServicesTableLib.h>
  19 #include <Library/TimerLib.h>
  20 #include <Library/PeCoffGetEntryPointLib.h>
  21 #include <Library/PrintLib.h>
  22 #include <Library/HiiLib.h>
  23 #include <Library/PcdLib.h>
  24 #include <Library/UefiLib.h>
  25 #include <Library/DevicePathLib.h>
  26
  27 #include <Pi/PiFirmwareFile.h>
  28 #include <Library/DxeServicesLib.h>
  29
  30 #include <Protocol/LoadedImage.h>
  31 #include <Protocol/DriverBinding.h>
  32 #include <Protocol/ComponentName2.h>
  33 #include <Protocol/DevicePath.h>
  34
  35 #include <Guid/Performance.h>
  36
  37 #include "Dp.h"
  38 #include "Literals.h"
  39 #include "DpInternal.h"
  40
  41 /**
  42   Wrap original FreePool to check NULL pointer first.
  43
  44   @param[in]    Buffer      The pointer to the buffer to free.
  45
  46 **/
  47 VOID
  48 SafeFreePool (
  49   IN VOID   *Buffer
  50   )
  51 {
  52   if (Buffer != NULL) {
  53     FreePool (Buffer);
  54   }
  55 }
  56
  57 /**
  58   Calculate an event's duration in timer ticks.
  59
  60   Given the count direction and the event's start and end timer values,
  61   calculate the duration of the event in timer ticks.  Information for
  62   the current measurement is pointed to by the parameter.
  63
  64   If the measurement's start time is 1, it indicates that the developer
  65   is indicating that the measurement began at the release of reset.
  66   The start time is adjusted to the timer's starting count before performing
  67   the elapsed time calculation.
  68
  69   The calculated duration, in ticks, is the absolute difference between
  70   the measurement's ending and starting counts.
  71
  72   @param Measurement   Pointer to a MEASUREMENT_RECORD structure containing
  73                        data for the current measurement.
  74
  75   @return              The 64-bit duration of the event.
  76 **/
  77 UINT64
  78 GetDuration (
  79   IN OUT MEASUREMENT_RECORD   *Measurement
  80   )
  81 {
  82   UINT64    Duration;
  83   BOOLEAN   Error;
  84
  85   // PERF_START macros are called with a value of 1 to indicate
  86   // the beginning of time.  So, adjust the start ticker value
  87   // to the real beginning of time.
  88   // Assumes no wraparound.  Even then, there is a very low probability
  89   // of having a valid StartTicker value of 1.
  90   if (Measurement->StartTimeStamp == 1) {
  91     Measurement->StartTimeStamp = TimerInfo.StartCount;
  92   }
  93   if (TimerInfo.CountUp) {
  94     Duration = Measurement->EndTimeStamp - Measurement->StartTimeStamp;
  95     Error = (BOOLEAN)(Duration > Measurement->EndTimeStamp);
  96   }
  97   else {
  98     Duration = Measurement->StartTimeStamp - Measurement->EndTimeStamp;
  99     Error = (BOOLEAN)(Duration > Measurement->StartTimeStamp);
 100   }
 101
 102   if (Error) {
 103     DEBUG ((EFI_D_ERROR, ALit_TimerLibError));
 104     Duration = 0;
 105   }
 106   return Duration;
 107 }
 108
 109 /**
 110   Determine whether the Measurement record is for an EFI Phase.
 111
 112   The Token and Module members of the measurement record are checked.
 113   Module must be empty and Token must be one of SEC, PEI, DXE, BDS, or SHELL.
 114
 115   @param[in]  Measurement A pointer to the Measurement record to test.
 116
 117   @retval     TRUE        The measurement record is for an EFI Phase.
 118   @retval     FALSE       The measurement record is NOT for an EFI Phase.
 119 **/
 120 BOOLEAN
 121 IsPhase(
 122   IN MEASUREMENT_RECORD        *Measurement
 123   )
 124 {
 125   BOOLEAN   RetVal;
 126
 127   RetVal = (BOOLEAN)( ( *Measurement->Module == '\0')                               &&
 128             ((AsciiStrnCmp (Measurement->Token, ALit_SEC, PERF_TOKEN_LENGTH) == 0)    ||
 129              (AsciiStrnCmp (Measurement->Token, ALit_PEI, PERF_TOKEN_LENGTH) == 0)    ||
 130              (AsciiStrnCmp (Measurement->Token, ALit_DXE, PERF_TOKEN_LENGTH) == 0)    ||
 131              (AsciiStrnCmp (Measurement->Token, ALit_BDS, PERF_TOKEN_LENGTH) == 0))
 132             );
 133   return RetVal;
 134 }
 135
 136 /**
 137   Get the file name portion of the Pdb File Name.
 138
 139   The portion of the Pdb File Name between the last backslash and
 140   either a following period or the end of the string is converted
 141   to Unicode and copied into UnicodeBuffer.  The name is truncated,
 142   if necessary, to ensure that UnicodeBuffer is not overrun.
 143
 144   @param[in]  PdbFileName     Pdb file name.
 145   @param[out] UnicodeBuffer   The resultant Unicode File Name.
 146
 147 **/
 148 VOID
 149 GetShortPdbFileName (
 150   IN  CHAR8     *PdbFileName,
 151   OUT CHAR16    *UnicodeBuffer
 152   )
 153 {
 154   UINTN IndexA;     // Current work location within an ASCII string.
 155   UINTN IndexU;     // Current work location within a Unicode string.
 156   UINTN StartIndex;
 157   UINTN EndIndex;
 158
 159   ZeroMem (UnicodeBuffer, (DP_GAUGE_STRING_LENGTH + 1) * sizeof (CHAR16));
 160
 161   if (PdbFileName == NULL) {
 162     StrCpyS (UnicodeBuffer, DP_GAUGE_STRING_LENGTH + 1, L" ");
 163   } else {
 164     StartIndex = 0;
 165     for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++)
 166       ;
 167     for (IndexA = 0; PdbFileName[IndexA] != 0; IndexA++) {
 168       if (PdbFileName[IndexA] == '\\') {
 169         StartIndex = IndexA + 1;
 170       }
 171
 172       if (PdbFileName[IndexA] == '.') {
 173         EndIndex = IndexA;
 174       }
 175     }
 176
 177     IndexU = 0;
 178     for (IndexA = StartIndex; IndexA < EndIndex; IndexA++) {
 179       UnicodeBuffer[IndexU] = (CHAR16) PdbFileName[IndexA];
 180       IndexU++;
 181       if (IndexU >= DP_GAUGE_STRING_LENGTH) {
 182         UnicodeBuffer[DP_GAUGE_STRING_LENGTH] = 0;
 183         break;
 184       }
 185     }
 186   }
 187 }
 188
 189 /**
 190   Get a human readable name for an image handle.
 191   The following methods will be tried orderly:
 192     1. Image PDB
 193     2. ComponentName2 protocol
 194     3. FFS UI section
 195     4. Image GUID
 196     5. Image DevicePath
 197     6. Unknown Driver Name
 198
 199   @param[in]    Handle
 200
 201   @post   The resulting Unicode name string is stored in the
 202           mGaugeString global array.
 203
 204 **/
 205 VOID
 206 GetNameFromHandle (
 207   IN EFI_HANDLE   Handle
 208   )
 209 {
 210   EFI_STATUS                  Status;
 211   EFI_LOADED_IMAGE_PROTOCOL   *Image;
 212   CHAR8                       *PdbFileName;
 213   EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
 214   EFI_STRING                  StringPtr;
 215   EFI_DEVICE_PATH_PROTOCOL    *LoadedImageDevicePath;
 216   EFI_DEVICE_PATH_PROTOCOL    *DevicePath;
 217   EFI_GUID                    *NameGuid;
 218   CHAR16                      *NameString;
 219   UINTN                       StringSize;
 220   CHAR8                       *PlatformLanguage;
 221   CHAR8                       *BestLanguage;
 222   EFI_COMPONENT_NAME2_PROTOCOL      *ComponentName2;
 223
 224   Image = NULL;
 225   LoadedImageDevicePath = NULL;
 226   DevicePath = NULL;
 227   BestLanguage     = NULL;
 228   PlatformLanguage = NULL;
 229
 230   //
 231   // Method 1: Get the name string from image PDB
 232   //
 233   Status = gBS->HandleProtocol (
 234                   Handle,
 235                   &gEfiLoadedImageProtocolGuid,
 236                   (VOID **) &Image
 237                   );
 238
 239   if (EFI_ERROR (Status)) {
 240     Status = gBS->OpenProtocol (
 241                     Handle,
 242                     &gEfiDriverBindingProtocolGuid,
 243                     (VOID **) &DriverBinding,
 244                     NULL,
 245                     NULL,
 246                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 247                     );
 248     if (!EFI_ERROR (Status)) {
 249       Status = gBS->HandleProtocol (
 250                       DriverBinding->ImageHandle,
 251                       &gEfiLoadedImageProtocolGuid,
 252                       (VOID **) &Image
 253                       );
 254     }
 255   }
 256
 257   if (!EFI_ERROR (Status)) {
 258     PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase);
 259
 260     if (PdbFileName != NULL) {
 261       GetShortPdbFileName (PdbFileName, mGaugeString);
 262       return;
 263     }
 264   }
 265
 266   //
 267   // Method 2: Get the name string from ComponentName2 protocol
 268   //
 269   Status = gBS->HandleProtocol (
 270                   Handle,
 271                   &gEfiComponentName2ProtocolGuid,
 272                   (VOID **) &ComponentName2
 273                   );
 274   if (!EFI_ERROR (Status)) {
 275     //
 276     // Get the current platform language setting
 277     //
 278     GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&PlatformLanguage, NULL);
 279
 280     BestLanguage = GetBestLanguage(
 281                      ComponentName2->SupportedLanguages,
 282                      FALSE,
 283                      PlatformLanguage,
 284                      ComponentName2->SupportedLanguages,
 285                      NULL
 286                      );
 287
 288     SafeFreePool (PlatformLanguage);
 289     Status = ComponentName2->GetDriverName (
 290                                ComponentName2,
 291                                BestLanguage,
 292                                &StringPtr
 293                                );
 294     SafeFreePool (BestLanguage);
 295     if (!EFI_ERROR (Status)) {
 296       StrnCpyS (
 297         mGaugeString,
 298         DP_GAUGE_STRING_LENGTH + 1,
 299         StringPtr,
 300         DP_GAUGE_STRING_LENGTH
 301         );
 302       return;
 303     }
 304   }
 305
 306   Status = gBS->HandleProtocol (
 307                   Handle,
 308                   &gEfiLoadedImageDevicePathProtocolGuid,
 309                   (VOID **) &LoadedImageDevicePath
 310                   );
 311   if (!EFI_ERROR (Status) && (LoadedImageDevicePath != NULL)) {
 312     DevicePath = LoadedImageDevicePath;
 313   } else if (Image != NULL) {
 314     DevicePath = Image->FilePath;
 315   }
 316
 317   if (DevicePath != NULL) {
 318     //
 319     // Try to get image GUID from image DevicePath
 320     //
 321     NameGuid = NULL;
 322     while (!IsDevicePathEndType (DevicePath)) {
 323       NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePath);
 324       if (NameGuid != NULL) {
 325         break;
 326       }
 327       DevicePath = NextDevicePathNode (DevicePath);
 328     }
 329
 330     if (NameGuid != NULL) {
 331       //
 332       // Try to get the image's FFS UI section by image GUID
 333       //
 334       NameString = NULL;
 335       StringSize = 0;
 336       Status = GetSectionFromAnyFv (
 337                 NameGuid,
 338                 EFI_SECTION_USER_INTERFACE,
 339                 0,
 340                 (VOID **) &NameString,
 341                 &StringSize
 342                 );
 343
 344       if (!EFI_ERROR (Status)) {
 345         //
 346         // Method 3. Get the name string from FFS UI section
 347         //
 348         StrnCpyS (
 349           mGaugeString,
 350           DP_GAUGE_STRING_LENGTH + 1,
 351           NameString,
 352           DP_GAUGE_STRING_LENGTH
 353           );
 354         FreePool (NameString);
 355       } else {
 356         //
 357         // Method 4: Get the name string from image GUID
 358         //
 359         UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", NameGuid);
 360       }
 361       return;
 362     } else {
 363       //
 364       // Method 5: Get the name string from image DevicePath
 365       //
 366       NameString = ConvertDevicePathToText (DevicePath, TRUE, FALSE);
 367       if (NameString != NULL) {
 368         StrnCpyS (
 369           mGaugeString,
 370           DP_GAUGE_STRING_LENGTH + 1,
 371           NameString,
 372           DP_GAUGE_STRING_LENGTH
 373           );
 374         FreePool (NameString);
 375         return;
 376       }
 377     }
 378   }
 379
 380   //
 381   // Method 6: Unknown Driver Name
 382   //
 383   StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL);
 384   ASSERT (StringPtr != NULL);
 385   StrCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, StringPtr);
 386   FreePool (StringPtr);
 387   return;
 388 }
 389
 390 /**
 391   Calculate the Duration in microseconds.
 392
 393   Duration is multiplied by 1000, instead of Frequency being divided by 1000 or
 394   multiplying the result by 1000, in order to maintain precision.  Since Duration is
 395   a 64-bit value, multiplying it by 1000 is unlikely to produce an overflow.
 396
 397   The time is calculated as (Duration * 1000) / Timer_Frequency.
 398
 399   @param[in]  Duration   The event duration in timer ticks.
 400
 401   @return     A 64-bit value which is the Elapsed time in microseconds.
 402 **/
 403 UINT64
 404 DurationInMicroSeconds (
 405   IN UINT64 Duration
 406   )
 407 {
 408   UINT64 Temp;
 409
 410   Temp = MultU64x32 (Duration, 1000);
 411   return DivU64x32 (Temp, TimerInfo.Frequency);
 412 }
 413
 414 /**
 415   Formatted Print using a Hii Token to reference the localized format string.
 416
 417   @param[in]  Token   A HII token associated with a localized Unicode string.
 418   @param[in]  ...     The variable argument list.
 419
 420   @return             The number of characters converted by UnicodeVSPrint().
 421
 422 **/
 423 UINTN
 424 EFIAPI
 425 PrintToken (
 426   IN UINT16           Token,
 427   ...
 428   )
 429 {
 430   VA_LIST           Marker;
 431   EFI_STRING        StringPtr;
 432   UINTN             Return;
 433   UINTN             BufferSize;
 434
 435   StringPtr = HiiGetString (gHiiHandle, Token, NULL);
 436   ASSERT (StringPtr != NULL);
 437
 438   VA_START (Marker, Token);
 439
 440   BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
 441
 442   if (mPrintTokenBuffer == NULL) {
 443     mPrintTokenBuffer = AllocatePool (BufferSize);
 444     ASSERT (mPrintTokenBuffer != NULL);
 445   }
 446   SetMem( mPrintTokenBuffer, BufferSize, 0);
 447
 448   Return = UnicodeVSPrint (mPrintTokenBuffer, BufferSize, StringPtr, Marker);
 449   VA_END (Marker);
 450
 451   if (Return > 0 && gST->ConOut != NULL) {
 452     gST->ConOut->OutputString (gST->ConOut, mPrintTokenBuffer);
 453   }
 454   FreePool (StringPtr);
 455   return Return;
 456 }
 457
 458 /**
 459   Get index of Measurement Record's match in the CumData array.
 460
 461   If the Measurement's Token value matches a Token in one of the CumData
 462   records, the index of the matching record is returned.  The returned
 463   index is a signed value so that negative values can indicate that
 464   the Measurement didn't match any entry in the CumData array.
 465
 466   @param[in]  Measurement A pointer to a Measurement Record to match against the CumData array.
 467
 468   @retval     <0    Token is not in the CumData array.
 469   @retval     >=0   Return value is the index into CumData where Token is found.
 470 **/
 471 INTN
 472 GetCumulativeItem(
 473   IN MEASUREMENT_RECORD   *Measurement
 474   )
 475 {
 476   INTN    Index;
 477
 478   for( Index = 0; Index < (INTN)NumCum; ++Index) {
 479     if (AsciiStrnCmp (Measurement->Token, CumData[Index].Name, PERF_TOKEN_LENGTH) == 0) {
 480       return Index;  // Exit, we found a match
 481     }
 482   }
 483   // If the for loop exits, Token was not found.
 484   return -1;   // Indicate failure
 485 }