PerformancePkg/Dp_App/DpUtilities.c

   1 /** @file
   2   Utility functions used by the Dp application.
   3
   4   Copyright (c) 2009 - 2015, 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, DXE_PERFORMANCE_STRING_LENGTH * sizeof (CHAR16));
 160
 161   if (PdbFileName == NULL) {
 162     StrCpyS (UnicodeBuffer, DXE_PERFORMANCE_STRING_SIZE, 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 >= DXE_PERFORMANCE_STRING_LENGTH) {
 182         UnicodeBuffer[DXE_PERFORMANCE_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   BestLanguage     = NULL;
 225   PlatformLanguage = NULL;
 226
 227   //
 228   // Method 1: Get the name string from image PDB
 229   //
 230   Status = gBS->HandleProtocol (
 231                   Handle,
 232                   &gEfiLoadedImageProtocolGuid,
 233                   (VOID **) &Image
 234                   );
 235
 236   if (EFI_ERROR (Status)) {
 237     Status = gBS->OpenProtocol (
 238                     Handle,
 239                     &gEfiDriverBindingProtocolGuid,
 240                     (VOID **) &DriverBinding,
 241                     NULL,
 242                     NULL,
 243                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 244                     );
 245     if (!EFI_ERROR (Status)) {
 246       Status = gBS->HandleProtocol (
 247                       DriverBinding->ImageHandle,
 248                       &gEfiLoadedImageProtocolGuid,
 249                       (VOID **) &Image
 250                       );
 251     }
 252   }
 253
 254   if (!EFI_ERROR (Status)) {
 255     PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase);
 256
 257     if (PdbFileName != NULL) {
 258       GetShortPdbFileName (PdbFileName, mGaugeString);
 259       return;
 260     }
 261   }
 262
 263   //
 264   // Method 2: Get the name string from ComponentName2 protocol
 265   //
 266   Status = gBS->HandleProtocol (
 267                   Handle,
 268                   &gEfiComponentName2ProtocolGuid,
 269                   (VOID **) &ComponentName2
 270                   );
 271   if (!EFI_ERROR (Status)) {
 272     //
 273     // Get the current platform language setting
 274     //
 275     GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&PlatformLanguage, NULL);
 276
 277     BestLanguage = GetBestLanguage(
 278                      ComponentName2->SupportedLanguages,
 279                      FALSE,
 280                      PlatformLanguage,
 281                      ComponentName2->SupportedLanguages,
 282                      NULL
 283                      );
 284
 285     SafeFreePool (PlatformLanguage);
 286     Status = ComponentName2->GetDriverName (
 287                                ComponentName2,
 288                                BestLanguage,
 289                                &StringPtr
 290                                );
 291     SafeFreePool (BestLanguage);
 292     if (!EFI_ERROR (Status)) {
 293       StrCpyS (
 294         mGaugeString,
 295         DP_GAUGE_STRING_LENGTH + 1,
 296         StringPtr
 297         );
 298       return;
 299     }
 300   }
 301
 302   Status = gBS->HandleProtocol (
 303                   Handle,
 304                   &gEfiLoadedImageDevicePathProtocolGuid,
 305                   (VOID **) &LoadedImageDevicePath
 306                   );
 307   if (!EFI_ERROR (Status) && (LoadedImageDevicePath != NULL)) {
 308     DevicePath = LoadedImageDevicePath;
 309
 310     //
 311     // Try to get image GUID from LoadedImageDevicePath protocol
 312     //
 313     NameGuid = NULL;
 314     while (!IsDevicePathEndType (DevicePath)) {
 315       NameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePath);
 316       if (NameGuid != NULL) {
 317         break;
 318       }
 319       DevicePath = NextDevicePathNode (DevicePath);
 320     }
 321
 322     if (NameGuid != NULL) {
 323       //
 324       // Try to get the image's FFS UI section by image GUID
 325       //
 326       NameString = NULL;
 327       StringSize = 0;
 328       Status = GetSectionFromAnyFv (
 329                 NameGuid,
 330                 EFI_SECTION_USER_INTERFACE,
 331                 0,
 332                 (VOID **) &NameString,
 333                 &StringSize
 334                 );
 335
 336       if (!EFI_ERROR (Status)) {
 337         //
 338         // Method 3. Get the name string from FFS UI section
 339         //
 340         StrCpyS (
 341           mGaugeString,
 342           DP_GAUGE_STRING_LENGTH + 1,
 343           NameString
 344           );
 345         FreePool (NameString);
 346       } else {
 347         //
 348         // Method 4: Get the name string from image GUID
 349         //
 350         UnicodeSPrint (mGaugeString, sizeof (mGaugeString), L"%g", NameGuid);
 351       }
 352       return;
 353     } else {
 354       //
 355       // Method 5: Get the name string from image DevicePath
 356       //
 357       NameString = ConvertDevicePathToText (LoadedImageDevicePath, TRUE, FALSE);
 358       if (NameString != NULL) {
 359         StrCpyS (
 360           mGaugeString,
 361           DP_GAUGE_STRING_LENGTH + 1,
 362           NameString
 363           );
 364         FreePool (NameString);
 365         return;
 366       }
 367     }
 368   }
 369
 370   //
 371   // Method 6: Unknown Driver Name
 372   //
 373   StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_ERROR_NAME), NULL);
 374   ASSERT (StringPtr != NULL);
 375   StrCpyS (mGaugeString, DP_GAUGE_STRING_LENGTH + 1, StringPtr);
 376   FreePool (StringPtr);
 377   return;
 378 }
 379
 380 /**
 381   Calculate the Duration in microseconds.
 382
 383   Duration is multiplied by 1000, instead of Frequency being divided by 1000 or
 384   multiplying the result by 1000, in order to maintain precision.  Since Duration is
 385   a 64-bit value, multiplying it by 1000 is unlikely to produce an overflow.
 386
 387   The time is calculated as (Duration * 1000) / Timer_Frequency.
 388
 389   @param[in]  Duration   The event duration in timer ticks.
 390
 391   @return     A 64-bit value which is the Elapsed time in microseconds.
 392 **/
 393 UINT64
 394 DurationInMicroSeconds (
 395   IN UINT64 Duration
 396   )
 397 {
 398   UINT64 Temp;
 399
 400   Temp = MultU64x32 (Duration, 1000);
 401   return DivU64x32 (Temp, TimerInfo.Frequency);
 402 }
 403
 404 /**
 405   Formatted Print using a Hii Token to reference the localized format string.
 406
 407   @param[in]  Token   A HII token associated with a localized Unicode string.
 408   @param[in]  ...     The variable argument list.
 409
 410   @return             The number of characters converted by UnicodeVSPrint().
 411
 412 **/
 413 UINTN
 414 EFIAPI
 415 PrintToken (
 416   IN UINT16           Token,
 417   ...
 418   )
 419 {
 420   VA_LIST           Marker;
 421   EFI_STRING        StringPtr;
 422   UINTN             Return;
 423   UINTN             BufferSize;
 424
 425   StringPtr = HiiGetString (gHiiHandle, Token, NULL);
 426   ASSERT (StringPtr != NULL);
 427
 428   VA_START (Marker, Token);
 429
 430   BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16);
 431
 432   if (mPrintTokenBuffer == NULL) {
 433     mPrintTokenBuffer = AllocatePool (BufferSize);
 434     ASSERT (mPrintTokenBuffer != NULL);
 435   }
 436   SetMem( mPrintTokenBuffer, BufferSize, 0);
 437
 438   Return = UnicodeVSPrint (mPrintTokenBuffer, BufferSize, StringPtr, Marker);
 439   VA_END (Marker);
 440
 441   if (Return > 0 && gST->ConOut != NULL) {
 442     gST->ConOut->OutputString (gST->ConOut, mPrintTokenBuffer);
 443   }
 444   FreePool (StringPtr);
 445   return Return;
 446 }
 447
 448 /**
 449   Get index of Measurement Record's match in the CumData array.
 450
 451   If the Measurement's Token value matches a Token in one of the CumData
 452   records, the index of the matching record is returned.  The returned
 453   index is a signed value so that negative values can indicate that
 454   the Measurement didn't match any entry in the CumData array.
 455
 456   @param[in]  Measurement A pointer to a Measurement Record to match against the CumData array.
 457
 458   @retval     <0    Token is not in the CumData array.
 459   @retval     >=0   Return value is the index into CumData where Token is found.
 460 **/
 461 INTN
 462 GetCumulativeItem(
 463   IN MEASUREMENT_RECORD   *Measurement
 464   )
 465 {
 466   INTN    Index;
 467
 468   for( Index = 0; Index < (INTN)NumCum; ++Index) {
 469     if (AsciiStrnCmp (Measurement->Token, CumData[Index].Name, PERF_TOKEN_LENGTH) == 0) {
 470       return Index;  // Exit, we found a match
 471     }
 472   }
 473   // If the for loop exits, Token was not found.
 474   return -1;   // Indicate failure
 475 }