Vlv2TbltDevicePkg/Override/IntelFrameworkModulePkg/Library/GenericBdsLib/Performance.c

   1 /** @file
   2   This file include the file which can help to get the system
   3   performance, all the function will only include if the performance
   4   switch is set.
   5
   6 Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>
   7 This program and the accompanying materials
   8 are licensed and made available under the terms and conditions of the BSD License
   9 which accompanies this distribution.  The full text of the license may be found at
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "InternalBdsLib.h"
  18
  19 PERF_HEADER               mPerfHeader;
  20 PERF_DATA                 mPerfData;
  21 EFI_PHYSICAL_ADDRESS      mAcpiLowMemoryBase = 0x0FFFFFFFFULL;
  22
  23 /**
  24   Get the short verion of PDB file name to be
  25   used in performance data logging.
  26
  27   @param PdbFileName     The long PDB file name.
  28   @param GaugeString     The output string to be logged by performance logger.
  29
  30 **/
  31 VOID
  32 GetShortPdbFileName (
  33   IN  CONST CHAR8  *PdbFileName,
  34   OUT       CHAR8  *GaugeString
  35   )
  36 {
  37   UINTN Index;
  38   UINTN Index1;
  39   UINTN StartIndex;
  40   UINTN EndIndex;
  41
  42   if (PdbFileName == NULL) {
  43     AsciiStrCpy (GaugeString, " ");
  44   } else {
  45     StartIndex = 0;
  46     for (EndIndex = 0; PdbFileName[EndIndex] != 0; EndIndex++)
  47       ;
  48
  49     for (Index = 0; PdbFileName[Index] != 0; Index++) {
  50       if (PdbFileName[Index] == '\\') {
  51         StartIndex = Index + 1;
  52       }
  53
  54       if (PdbFileName[Index] == '.') {
  55         EndIndex = Index;
  56       }
  57     }
  58
  59     Index1 = 0;
  60     for (Index = StartIndex; Index < EndIndex; Index++) {
  61       GaugeString[Index1] = PdbFileName[Index];
  62       Index1++;
  63       if (Index1 == PERF_TOKEN_LENGTH - 1) {
  64         break;
  65       }
  66     }
  67
  68     GaugeString[Index1] = 0;
  69   }
  70
  71   return ;
  72 }
  73
  74 /**
  75   Get the name from the Driver handle, which can be a handle with
  76   EFI_LOADED_IMAGE_PROTOCOL or EFI_DRIVER_BINDING_PROTOCOL installed.
  77   This name can be used in performance data logging.
  78
  79   @param Handle          Driver handle.
  80   @param GaugeString     The output string to be logged by performance logger.
  81
  82 **/
  83 VOID
  84 GetNameFromHandle (
  85   IN  EFI_HANDLE     Handle,
  86   OUT CHAR8          *GaugeString
  87   )
  88 {
  89   EFI_STATUS                  Status;
  90   EFI_LOADED_IMAGE_PROTOCOL   *Image;
  91   CHAR8                       *PdbFileName;
  92   EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
  93
  94   AsciiStrCpy (GaugeString, " ");
  95
  96   //
  97   // Get handle name from image protocol
  98   //
  99   Status = gBS->HandleProtocol (
 100                   Handle,
 101                   &gEfiLoadedImageProtocolGuid,
 102                   (VOID **) &Image
 103                   );
 104
 105   if (EFI_ERROR (Status)) {
 106     Status = gBS->OpenProtocol (
 107                     Handle,
 108                     &gEfiDriverBindingProtocolGuid,
 109                     (VOID **) &DriverBinding,
 110                     NULL,
 111                     NULL,
 112                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 113                     );
 114     if (EFI_ERROR (Status)) {
 115       return ;
 116     }
 117     //
 118     // Get handle name from image protocol
 119     //
 120     Status = gBS->HandleProtocol (
 121                     DriverBinding->ImageHandle,
 122                     &gEfiLoadedImageProtocolGuid,
 123                     (VOID **) &Image
 124                     );
 125   }
 126
 127   PdbFileName = PeCoffLoaderGetPdbPointer (Image->ImageBase);
 128
 129   if (PdbFileName != NULL) {
 130     GetShortPdbFileName (PdbFileName, GaugeString);
 131   }
 132
 133   return ;
 134 }
 135
 136 /**
 137
 138   Writes performance data of booting into the allocated memory.
 139   OS can process these records.
 140
 141   @param  Event                 The triggered event.
 142   @param  Context               Context for this event.
 143
 144 **/
 145 VOID
 146 EFIAPI
 147 WriteBootToOsPerformanceData (
 148   IN EFI_EVENT  Event,
 149   IN VOID       *Context
 150   )
 151 {
 152   EFI_STATUS                Status;
 153   UINT32                    LimitCount;
 154   EFI_HANDLE                *Handles;
 155   UINTN                     NoHandles;
 156   CHAR8                     GaugeString[PERF_TOKEN_LENGTH];
 157   UINT8                     *Ptr;
 158   UINT32                    Index;
 159   UINT64                    Ticker;
 160   UINT64                    Freq;
 161   UINT32                    Duration;
 162   UINTN                     LogEntryKey;
 163   CONST VOID                *Handle;
 164   CONST CHAR8               *Token;
 165   CONST CHAR8               *Module;
 166   UINT64                    StartTicker;
 167   UINT64                    EndTicker;
 168   UINT64                    StartValue;
 169   UINT64                    EndValue;
 170   BOOLEAN                   CountUp;
 171   UINTN                     EntryIndex;
 172   UINTN                     NumPerfEntries;
 173   //
 174   // List of flags indicating PerfEntry contains DXE handle
 175   //
 176   BOOLEAN                   *PerfEntriesAsDxeHandle;
 177   UINTN                     VarSize;
 178
 179   //
 180   // Record the performance data for End of BDS
 181   //
 182   PERF_END(NULL, "BDS", NULL, 0);
 183
 184   //
 185   // Retrieve time stamp count as early as possible
 186   //
 187   Ticker  = GetPerformanceCounter ();
 188
 189   Freq    = GetPerformanceCounterProperties (&StartValue, &EndValue);
 190
 191   Freq    = DivU64x32 (Freq, 1000);
 192
 193   mPerfHeader.CpuFreq = Freq;
 194
 195   //
 196   // Record BDS raw performance data
 197   //
 198   if (EndValue >= StartValue) {
 199     mPerfHeader.BDSRaw = Ticker - StartValue;
 200     CountUp            = TRUE;
 201   } else {
 202     mPerfHeader.BDSRaw = StartValue - Ticker;
 203     CountUp            = FALSE;
 204   }
 205
 206   if (mAcpiLowMemoryBase == 0x0FFFFFFFF) {
 207     VarSize = sizeof (EFI_PHYSICAL_ADDRESS);
 208     Status = gRT->GetVariable (
 209                     L"PerfDataMemAddr",
 210                     &gPerformanceProtocolGuid,
 211                     NULL,
 212                     &VarSize,
 213                     &mAcpiLowMemoryBase
 214                     );
 215     if (EFI_ERROR (Status)) {
 216       //
 217       // Fail to get the variable, return.
 218       //
 219       return;
 220     }
 221   }
 222
 223   //
 224   // Put Detailed performance data into memory
 225   //
 226   Handles = NULL;
 227   Status = gBS->LocateHandleBuffer (
 228                   AllHandles,
 229                   NULL,
 230                   NULL,
 231                   &NoHandles,
 232                   &Handles
 233                   );
 234   if (EFI_ERROR (Status)) {
 235     return ;
 236   }
 237
 238   Ptr        = (UINT8 *) ((UINT32) mAcpiLowMemoryBase + sizeof (PERF_HEADER));
 239   LimitCount = (UINT32) (PERF_DATA_MAX_LENGTH - sizeof (PERF_HEADER)) / sizeof (PERF_DATA);
 240
 241   NumPerfEntries = 0;
 242   LogEntryKey    = 0;
 243   while ((LogEntryKey = GetPerformanceMeasurement (
 244                           LogEntryKey,
 245                           &Handle,
 246                           &Token,
 247                           &Module,
 248                           &StartTicker,
 249                           &EndTicker)) != 0) {
 250     NumPerfEntries++;
 251   }
 252   PerfEntriesAsDxeHandle = AllocateZeroPool (NumPerfEntries * sizeof (BOOLEAN));
 253   ASSERT (PerfEntriesAsDxeHandle != NULL);
 254
 255   //
 256   // Get DXE drivers performance
 257   //
 258   for (Index = 0; Index < NoHandles; Index++) {
 259     Ticker = 0;
 260     LogEntryKey = 0;
 261     EntryIndex  = 0;
 262     while ((LogEntryKey = GetPerformanceMeasurement (
 263                             LogEntryKey,
 264                             &Handle,
 265                             &Token,
 266                             &Module,
 267                             &StartTicker,
 268                             &EndTicker)) != 0) {
 269       if (Handle == Handles[Index] && !PerfEntriesAsDxeHandle[EntryIndex]) {
 270         PerfEntriesAsDxeHandle[EntryIndex] = TRUE;
 271       }
 272       EntryIndex++;
 273       if ((Handle == Handles[Index]) && (EndTicker != 0)) {
 274         if (StartTicker == 1) {
 275           StartTicker = StartValue;
 276         }
 277         if (EndTicker == 1) {
 278           EndTicker = StartValue;
 279         }
 280         Ticker += CountUp ? (EndTicker - StartTicker) : (StartTicker - EndTicker);
 281       }
 282     }
 283
 284     Duration = (UINT32) DivU64x32 (Ticker, (UINT32) Freq);
 285
 286     if (Duration > 0) {
 287
 288       GetNameFromHandle (Handles[Index], GaugeString);
 289
 290       AsciiStrCpy (mPerfData.Token, GaugeString);
 291       mPerfData.Duration = Duration;
 292
 293       CopyMem (Ptr, &mPerfData, sizeof (PERF_DATA));
 294       Ptr += sizeof (PERF_DATA);
 295
 296       mPerfHeader.Count++;
 297       if (mPerfHeader.Count == LimitCount) {
 298         goto Done;
 299       }
 300     }
 301   }
 302
 303   //
 304   // Get inserted performance data
 305   //
 306   LogEntryKey = 0;
 307   EntryIndex  = 0;
 308   while ((LogEntryKey = GetPerformanceMeasurement (
 309                           LogEntryKey,
 310                           &Handle,
 311                           &Token,
 312                           &Module,
 313                           &StartTicker,
 314                           &EndTicker)) != 0) {
 315     if (!PerfEntriesAsDxeHandle[EntryIndex] && EndTicker != 0) {
 316
 317       ZeroMem (&mPerfData, sizeof (PERF_DATA));
 318
 319       AsciiStrnCpy (mPerfData.Token, Token, PERF_TOKEN_LENGTH);
 320       if (StartTicker == 1) {
 321         StartTicker = StartValue;
 322       }
 323       if (EndTicker == 1) {
 324         EndTicker = StartValue;
 325       }
 326       Ticker = CountUp ? (EndTicker - StartTicker) : (StartTicker - EndTicker);
 327
 328       mPerfData.Duration = (UINT32) DivU64x32 (Ticker, (UINT32) Freq);
 329
 330       CopyMem (Ptr, &mPerfData, sizeof (PERF_DATA));
 331       Ptr += sizeof (PERF_DATA);
 332
 333       mPerfHeader.Count++;
 334       if (mPerfHeader.Count == LimitCount) {
 335         goto Done;
 336       }
 337     }
 338     EntryIndex++;
 339   }
 340
 341 Done:
 342
 343   FreePool (Handles);
 344   FreePool (PerfEntriesAsDxeHandle);
 345
 346   mPerfHeader.Signiture = PERFORMANCE_SIGNATURE;
 347
 348   //
 349   // Put performance data to Reserved memory
 350   //
 351   CopyMem (
 352     (UINTN *) (UINTN) mAcpiLowMemoryBase,
 353     &mPerfHeader,
 354     sizeof (PERF_HEADER)
 355     );
 356
 357   return ;
 358 }