ShellPkg/Library/UefiDpLib/Dp.c

   1 /** @file
   2   Shell command for Displaying Performance Metrics.
   3
   4   The Dp command reads performance data and presents it in several
   5   different formats depending upon the needs of the user.  Both
   6   Trace and Measured Profiling information is processed and presented.
   7
   8   Dp uses the "PerformanceLib" to read the measurement records.
   9   The "TimerLib" provides information about the timer, such as frequency,
  10   beginning, and ending counter values.
  11   Measurement records contain identifying information (Handle, Token, Module)
  12   and start and end time values.
  13   Dp uses this information to group records in different ways.  It also uses
  14   timer information to calculate elapsed time for each measurement.
  15
  16   Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.
  17   (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>
  18   This program and the accompanying materials
  19   are licensed and made available under the terms and conditions of the BSD License
  20   which accompanies this distribution.  The full text of the license may be found at
  21   http://opensource.org/licenses/bsd-license.php
  22
  23   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  24   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  25 **/
  26
  27 #include "UefiDpLib.h"
  28 #include <Guid/GlobalVariable.h>
  29 #include <Library/PrintLib.h>
  30 #include <Library/HandleParsingLib.h>
  31 #include <Library/DevicePathLib.h>
  32
  33 #include <Library/ShellLib.h>
  34 #include <Library/BaseLib.h>
  35 #include <Library/MemoryAllocationLib.h>
  36 #include <Library/DebugLib.h>
  37 #include <Library/TimerLib.h>
  38 #include <Library/UefiLib.h>
  39
  40 #include <Guid/Performance.h>
  41
  42 #include "PerformanceTokens.h"
  43 #include "Dp.h"
  44 #include "Literals.h"
  45 #include "DpInternal.h"
  46
  47 //
  48 /// Module-Global Variables
  49 ///@{
  50 CHAR16           mGaugeString[DP_GAUGE_STRING_LENGTH + 1];
  51 CHAR16           mUnicodeToken[DXE_PERFORMANCE_STRING_SIZE];
  52 UINT64           mInterestThreshold;
  53 BOOLEAN          mShowId = FALSE;
  54
  55 PERF_SUMMARY_DATA SummaryData = { 0 };    ///< Create the SummaryData structure and init. to ZERO.
  56
  57 /// Timer Specific Information.
  58 TIMER_INFO TimerInfo;
  59
  60 /// Items for which to gather cumulative statistics.
  61 PERF_CUM_DATA CumData[] = {
  62   PERF_INIT_CUM_DATA (LOAD_IMAGE_TOK),
  63   PERF_INIT_CUM_DATA (START_IMAGE_TOK),
  64   PERF_INIT_CUM_DATA (DRIVERBINDING_START_TOK),
  65   PERF_INIT_CUM_DATA (DRIVERBINDING_SUPPORT_TOK)
  66 };
  67
  68 /// Number of items for which we are gathering cumulative statistics.
  69 UINT32 const      NumCum = sizeof(CumData) / sizeof(PERF_CUM_DATA);
  70
  71 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
  72   {L"-v", TypeFlag},   // -v   Verbose Mode
  73   {L"-A", TypeFlag},   // -A   All, Cooked
  74   {L"-R", TypeFlag},   // -R   RAW All
  75   {L"-s", TypeFlag},   // -s   Summary
  76 #if PROFILING_IMPLEMENTED
  77   {L"-P", TypeFlag},   // -P   Dump Profile Data
  78   {L"-T", TypeFlag},   // -T   Dump Trace Data
  79 #endif // PROFILING_IMPLEMENTED
  80   {L"-x", TypeFlag},   // -x   eXclude Cumulative Items
  81   {L"-i", TypeFlag},   // -i   Display Identifier
  82   {L"-c", TypeValue},  // -c   Display cumulative data.
  83   {L"-n", TypeValue},  // -n # Number of records to display for A and R
  84   {L"-t", TypeValue},  // -t # Threshold of interest
  85   {NULL, TypeMax}
  86   };
  87
  88 ///@}
  89
  90 /**
  91    Display the trailing Verbose information.
  92 **/
  93 VOID
  94 DumpStatistics( void )
  95 {
  96   EFI_STRING                StringPtr;
  97   EFI_STRING                StringPtrUnknown;
  98   StringPtr        = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_DP_SECTION_STATISTICS), NULL);
  99   StringPtrUnknown = HiiGetString (gDpHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
 100   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_SECTION_HEADER), gDpHiiHandle,
 101               (StringPtr == NULL) ? StringPtrUnknown : StringPtr);
 102   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMTRACE), gDpHiiHandle,      SummaryData.NumTrace);
 103   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMINCOMPLETE), gDpHiiHandle, SummaryData.NumIncomplete);
 104   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPHASES), gDpHiiHandle,     SummaryData.NumSummary);
 105   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMHANDLES), gDpHiiHandle,    SummaryData.NumHandles, SummaryData.NumTrace - SummaryData.NumHandles);
 106   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPEIMS), gDpHiiHandle,      SummaryData.NumPEIMs);
 107   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMGLOBALS), gDpHiiHandle,    SummaryData.NumGlobal);
 108 #if PROFILING_IMPLEMENTED
 109   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_STATS_NUMPROFILE), gDpHiiHandle,    SummaryData.NumProfile);
 110 #endif // PROFILING_IMPLEMENTED
 111   SHELL_FREE_NON_NULL (StringPtr);
 112   SHELL_FREE_NON_NULL (StringPtrUnknown);
 113 }
 114
 115 /**
 116   Initialize the cumulative data.
 117
 118 **/
 119 VOID
 120 InitCumulativeData (
 121   VOID
 122   )
 123 {
 124   UINTN                             Index;
 125
 126   for (Index = 0; Index < NumCum; ++Index) {
 127     CumData[Index].Count = 0;
 128     CumData[Index].MinDur = PERF_MAXDUR;
 129     CumData[Index].MaxDur = 0;
 130     CumData[Index].Duration = 0;
 131   }
 132 }
 133
 134 /**
 135   Dump performance data.
 136
 137   @param[in]  ImageHandle     The image handle.
 138   @param[in]  SystemTable     The system table.
 139
 140   @retval EFI_SUCCESS            Command completed successfully.
 141   @retval EFI_INVALID_PARAMETER  Command usage error.
 142   @retval value                  Unknown error.
 143
 144 **/
 145 SHELL_STATUS
 146 EFIAPI
 147 ShellCommandRunDp (
 148   IN EFI_HANDLE               ImageHandle,
 149   IN EFI_SYSTEM_TABLE         *SystemTable
 150   )
 151 {
 152   LIST_ENTRY                *ParamPackage;
 153   CONST CHAR16              *CmdLineArg;
 154   EFI_STATUS                Status;
 155
 156   UINT64                    Freq;
 157   UINT64                    Ticker;
 158   UINTN                     Number2Display;
 159
 160   EFI_STRING                StringPtr;
 161   BOOLEAN                   SummaryMode;
 162   BOOLEAN                   VerboseMode;
 163   BOOLEAN                   AllMode;
 164   BOOLEAN                   RawMode;
 165   BOOLEAN                   TraceMode;
 166   BOOLEAN                   ProfileMode;
 167   BOOLEAN                   ExcludeMode;
 168   BOOLEAN                   CumulativeMode;
 169   CONST CHAR16              *CustomCumulativeToken;
 170   PERF_CUM_DATA             *CustomCumulativeData;
 171
 172   StringPtr   = NULL;
 173   SummaryMode = FALSE;
 174   VerboseMode = FALSE;
 175   AllMode     = FALSE;
 176   RawMode     = FALSE;
 177   TraceMode   = FALSE;
 178   ProfileMode = FALSE;
 179   ExcludeMode = FALSE;
 180   CumulativeMode = FALSE;
 181   CustomCumulativeData = NULL;
 182
 183   // Get DP's entry time as soon as possible.
 184   // This is used as the Shell-Phase end time.
 185   //
 186   Ticker  = GetPerformanceCounter ();
 187
 188   //
 189   // initialize the shell lib (we must be in non-auto-init...)
 190   //
 191   Status = ShellInitialize();
 192   ASSERT_EFI_ERROR(Status);
 193
 194   Status = CommandInit();
 195   ASSERT_EFI_ERROR(Status);
 196
 197   //
 198   // Process Command Line arguments
 199   //
 200   Status = ShellCommandLineParse (ParamList, &ParamPackage, NULL, TRUE);
 201   if (EFI_ERROR(Status)) {
 202     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_INVALID_ARG), gDpHiiHandle);
 203     return SHELL_INVALID_PARAMETER;
 204   }
 205
 206   //
 207   // Boolean options
 208   //
 209   VerboseMode = ShellCommandLineGetFlag (ParamPackage, L"-v");
 210   SummaryMode = (BOOLEAN) (ShellCommandLineGetFlag (ParamPackage, L"-S") || ShellCommandLineGetFlag (ParamPackage, L"-s"));
 211   AllMode     = ShellCommandLineGetFlag (ParamPackage, L"-A");
 212   RawMode     = ShellCommandLineGetFlag (ParamPackage, L"-R");
 213 #if PROFILING_IMPLEMENTED
 214   TraceMode   = ShellCommandLineGetFlag (ParamPackage, L"-T");
 215   ProfileMode = ShellCommandLineGetFlag (ParamPackage, L"-P");
 216 #endif  // PROFILING_IMPLEMENTED
 217   ExcludeMode = ShellCommandLineGetFlag (ParamPackage, L"-x");
 218   mShowId     = ShellCommandLineGetFlag (ParamPackage, L"-i");
 219   CumulativeMode = ShellCommandLineGetFlag (ParamPackage, L"-c");
 220
 221   // Options with Values
 222   CmdLineArg  = ShellCommandLineGetValue (ParamPackage, L"-n");
 223   if (CmdLineArg == NULL) {
 224     Number2Display = DEFAULT_DISPLAYCOUNT;
 225   } else {
 226     Number2Display = StrDecimalToUintn(CmdLineArg);
 227     if (Number2Display == 0) {
 228       Number2Display = MAXIMUM_DISPLAYCOUNT;
 229     }
 230   }
 231
 232   CmdLineArg  = ShellCommandLineGetValue (ParamPackage, L"-t");
 233   if (CmdLineArg == NULL) {
 234     mInterestThreshold = DEFAULT_THRESHOLD;  // 1ms := 1,000 us
 235   } else {
 236     mInterestThreshold = StrDecimalToUint64(CmdLineArg);
 237   }
 238
 239   // Handle Flag combinations and default behaviors
 240   // If both TraceMode and ProfileMode are FALSE, set them both to TRUE
 241   if ((! TraceMode) && (! ProfileMode)) {
 242     TraceMode   = TRUE;
 243 #if PROFILING_IMPLEMENTED
 244     ProfileMode = TRUE;
 245 #endif  // PROFILING_IMPLEMENTED
 246   }
 247
 248   //
 249   // Initialize the pre-defined cumulative data.
 250   //
 251   InitCumulativeData ();
 252
 253   //
 254   // Init the custom cumulative data.
 255   //
 256   CustomCumulativeToken = ShellCommandLineGetValue (ParamPackage, L"-c");
 257   if (CustomCumulativeToken != NULL) {
 258     CustomCumulativeData = AllocateZeroPool (sizeof (PERF_CUM_DATA));
 259     CustomCumulativeData->MinDur = 0;
 260     CustomCumulativeData->MaxDur = 0;
 261     CustomCumulativeData->Count  = 0;
 262     CustomCumulativeData->Duration = 0;
 263     CustomCumulativeData->Name   = AllocateZeroPool (StrLen (CustomCumulativeToken) + 1);
 264     UnicodeStrToAsciiStr (CustomCumulativeToken, CustomCumulativeData->Name);
 265   }
 266
 267   //
 268   // Timer specific processing
 269   //
 270   // Get the Performance counter characteristics:
 271   //          Freq = Frequency in Hz
 272   //    StartCount = Value loaded into the counter when it starts counting
 273   //      EndCount = Value counter counts to before it needs to be reset
 274   //
 275   Freq = GetPerformanceCounterProperties (&TimerInfo.StartCount, &TimerInfo.EndCount);
 276
 277   // Convert the Frequency from Hz to KHz
 278   TimerInfo.Frequency = (UINT32)DivU64x32 (Freq, 1000);
 279
 280   // Determine in which direction the performance counter counts.
 281   TimerInfo.CountUp = (BOOLEAN) (TimerInfo.EndCount >= TimerInfo.StartCount);
 282
 283   //
 284   // Print header
 285   //
 286   // print DP's build version
 287   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_BUILD_REVISION), gDpHiiHandle, DP_MAJOR_VERSION, DP_MINOR_VERSION);
 288
 289   // print performance timer characteristics
 290   ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_KHZ), gDpHiiHandle, TimerInfo.Frequency);
 291
 292   if (VerboseMode && !RawMode) {
 293     StringPtr = HiiGetString (gDpHiiHandle,
 294                   (EFI_STRING_ID) (TimerInfo.CountUp ? STRING_TOKEN (STR_DP_UP) : STRING_TOKEN (STR_DP_DOWN)), NULL);
 295     ASSERT (StringPtr != NULL);
 296     // Print Timer count range and direction
 297     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_TIMER_PROPERTIES), gDpHiiHandle,
 298                 StringPtr,
 299                 TimerInfo.StartCount,
 300                 TimerInfo.EndCount
 301                 );
 302     ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DP_VERBOSE_THRESHOLD), gDpHiiHandle, mInterestThreshold);
 303   }
 304
 305 /****************************************************************************
 306 ****            Print Sections based on command line options
 307 ****
 308 ****  Option modes have the following priority:
 309 ****    v Verbose     --  Valid in combination with any other options
 310 ****    t Threshold   --  Modifies All, Raw, and Cooked output
 311 ****                      Default is 0 for All and Raw mode
 312 ****                      Default is DEFAULT_THRESHOLD for "Cooked" mode
 313 ****    n Number2Display  Used by All and Raw mode.  Otherwise ignored.
 314 ****    A All         --  R and S options are ignored
 315 ****    R Raw         --  S option is ignored
 316 ****    s Summary     --  Modifies "Cooked" output only
 317 ****    Cooked (Default)
 318 ****
 319 ****  The All, Raw, and Cooked modes are modified by the Trace and Profile
 320 ****  options.
 321 ****    !T && !P  := (0) Default, Both are displayed
 322 ****     T && !P  := (1) Only Trace records are displayed
 323 ****    !T &&  P  := (2) Only Profile records are displayed
 324 ****     T &&  P  := (3) Same as Default, both are displayed
 325 ****************************************************************************/
 326   GatherStatistics (CustomCumulativeData);
 327   if (CumulativeMode) {
 328     ProcessCumulative (CustomCumulativeData);
 329   } else if (AllMode) {
 330     if (TraceMode) {
 331       DumpAllTrace( Number2Display, ExcludeMode);
 332     }
 333     if (ProfileMode) {
 334       DumpAllProfile( Number2Display, ExcludeMode);
 335     }
 336   } else if (RawMode) {
 337     if (TraceMode) {
 338       DumpRawTrace( Number2Display, ExcludeMode);
 339     }
 340     if (ProfileMode) {
 341       DumpRawProfile( Number2Display, ExcludeMode);
 342     }
 343   } else {
 344     //------------- Begin Cooked Mode Processing
 345     if (TraceMode) {
 346       ProcessPhases ( Ticker );
 347       if ( ! SummaryMode) {
 348         Status = ProcessHandles ( ExcludeMode);
 349         if ( ! EFI_ERROR( Status)) {
 350           ProcessPeims ();
 351           ProcessGlobal ();
 352           ProcessCumulative (NULL);
 353         }
 354       }
 355     }
 356     if (ProfileMode) {
 357       DumpAllProfile( Number2Display, ExcludeMode);
 358     }
 359   } //------------- End of Cooked Mode Processing
 360   if ( VerboseMode || SummaryMode) {
 361     DumpStatistics();
 362   }
 363
 364   SHELL_FREE_NON_NULL (StringPtr);
 365   if (CustomCumulativeData != NULL) {
 366     SHELL_FREE_NON_NULL (CustomCumulativeData->Name);
 367   }
 368   SHELL_FREE_NON_NULL (CustomCumulativeData);
 369
 370   return SHELL_SUCCESS;
 371 }