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 - 2009, Intel Corporation. <BR>
   7 All rights reserved. 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   Allocates a block of memory and writes performance data of booting into it.
 139   OS can processing these record.
 140
 141 **/
 142 VOID
 143 WriteBootToOsPerformanceData (
 144   VOID
 145   )
 146 {
 147   EFI_STATUS                Status;
 148   UINT32                    AcpiLowMemoryLength;
 149   UINT32                    LimitCount;
 150   EFI_HANDLE                *Handles;
 151   UINTN                     NoHandles;
 152   CHAR8                     GaugeString[PERF_TOKEN_LENGTH];
 153   UINT8                     *Ptr;
 154   UINT32                    Index;
 155   UINT64                    Ticker;
 156   UINT64                    Freq;
 157   UINT32                    Duration;
 158   UINTN                     LogEntryKey;
 159   CONST VOID                *Handle;
 160   CONST CHAR8               *Token;
 161   CONST CHAR8               *Module;
 162   UINT64                    StartTicker;
 163   UINT64                    EndTicker;
 164   UINT64                    StartValue;
 165   UINT64                    EndValue;
 166   BOOLEAN                   CountUp;
 167
 168   //
 169   // Retrieve time stamp count as early as possible
 170   //
 171   Ticker  = GetPerformanceCounter ();
 172
 173   Freq    = GetPerformanceCounterProperties (&StartValue, &EndValue);
 174
 175   Freq    = DivU64x32 (Freq, 1000);
 176
 177   mPerfHeader.CpuFreq = Freq;
 178
 179   //
 180   // Record BDS raw performance data
 181   //
 182   if (EndValue >= StartValue) {
 183     mPerfHeader.BDSRaw = Ticker - StartValue;
 184     CountUp            = TRUE;
 185   } else {
 186     mPerfHeader.BDSRaw = StartValue - Ticker;
 187     CountUp            = FALSE;
 188   }
 189
 190   //
 191   // Put Detailed performance data into memory
 192   //
 193   Handles = NULL;
 194   Status = gBS->LocateHandleBuffer (
 195                   AllHandles,
 196                   NULL,
 197                   NULL,
 198                   &NoHandles,
 199                   &Handles
 200                   );
 201   if (EFI_ERROR (Status)) {
 202     return ;
 203   }
 204
 205
 206   AcpiLowMemoryLength = 0x4000;
 207   if (mAcpiLowMemoryBase == 0x0FFFFFFFF) {
 208     //
 209     // Allocate a block of memory that contain performance data to OS
 210     //
 211     Status = gBS->AllocatePages (
 212                     AllocateMaxAddress,
 213                     EfiReservedMemoryType,
 214                     EFI_SIZE_TO_PAGES (AcpiLowMemoryLength),
 215                     &mAcpiLowMemoryBase
 216                     );
 217     if (EFI_ERROR (Status)) {
 218       FreePool (Handles);
 219       return ;
 220     }
 221   }
 222
 223
 224   Ptr        = (UINT8 *) ((UINT32) mAcpiLowMemoryBase + sizeof (PERF_HEADER));
 225   LimitCount = (AcpiLowMemoryLength - sizeof (PERF_HEADER)) / sizeof (PERF_DATA);
 226
 227
 228
 229   //
 230   // Get DXE drivers performance
 231   //
 232   for (Index = 0; Index < NoHandles; Index++) {
 233     Ticker = 0;
 234     LogEntryKey = 0;
 235     while ((LogEntryKey = GetPerformanceMeasurement (
 236                             LogEntryKey,
 237                             &Handle,
 238                             &Token,
 239                             &Module,
 240                             &StartTicker,
 241                             &EndTicker)) != 0) {
 242       if ((Handle == Handles[Index]) && (EndTicker != 0)) {
 243         Ticker += CountUp ? (EndTicker - StartTicker) : (StartTicker - EndTicker);
 244       }
 245     }
 246
 247     Duration = (UINT32) DivU64x32 (Ticker, (UINT32) Freq);
 248
 249     if (Duration > 0) {
 250
 251       GetNameFromHandle (Handles[Index], GaugeString);
 252
 253       AsciiStrCpy (mPerfData.Token, GaugeString);
 254       mPerfData.Duration = Duration;
 255
 256       CopyMem (Ptr, &mPerfData, sizeof (PERF_DATA));
 257       Ptr += sizeof (PERF_DATA);
 258
 259       mPerfHeader.Count++;
 260       if (mPerfHeader.Count == LimitCount) {
 261         goto Done;
 262       }
 263     }
 264   }
 265
 266   FreePool (Handles);
 267
 268   //
 269   // Get inserted performance data
 270   //
 271   LogEntryKey = 0;
 272   while ((LogEntryKey = GetPerformanceMeasurement (
 273                           LogEntryKey,
 274                           &Handle,
 275                           &Token,
 276                           &Module,
 277                           &StartTicker,
 278                           &EndTicker)) != 0) {
 279     if (Handle == NULL && EndTicker != 0) {
 280
 281       ZeroMem (&mPerfData, sizeof (PERF_DATA));
 282
 283       AsciiStrnCpy (mPerfData.Token, Token, PERF_TOKEN_LENGTH);
 284       Ticker = CountUp ? (EndTicker - StartTicker) : (StartTicker - EndTicker);
 285
 286       mPerfData.Duration = (UINT32) DivU64x32 (Ticker, (UINT32) Freq);
 287
 288       CopyMem (Ptr, &mPerfData, sizeof (PERF_DATA));
 289       Ptr += sizeof (PERF_DATA);
 290
 291       mPerfHeader.Count++;
 292       if (mPerfHeader.Count == LimitCount) {
 293         goto Done;
 294       }
 295     }
 296   }
 297
 298 Done:
 299
 300   mPerfHeader.Signiture = PERFORMANCE_SIGNATURE;
 301
 302   //
 303   // Put performance data to Reserved memory
 304   //
 305   CopyMem (
 306     (UINTN *) (UINTN) mAcpiLowMemoryBase,
 307     &mPerfHeader,
 308     sizeof (PERF_HEADER)
 309     );
 310
 311   gRT->SetVariable (
 312         L"PerfDataMemAddr",
 313         &gPerformanceProtocolGuid,
 314         EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS,
 315         sizeof (EFI_PHYSICAL_ADDRESS),
 316         &mAcpiLowMemoryBase
 317         );
 318
 319   return ;
 320 }