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